java基础学习_常用类04_正则表达式、Math类、Random类、System类、BigInteger类、BigDecimal类、Date和DateFormat类、Calendar类_day14总

        A:字符
            x           字符 x。举例：'a'表示字符a
            \\       　  \ 两个反斜杠字符代表一个反斜杠字符
            \n          新行（换行）符 ('\u000A') 
            \r          回车符 ('\u000D')
            
        B:字符类
            [abc]         a、b或 c（简单类） 例如：[38] 表示3或者8
            [^abc]        任何字符，除了a、b或 c（否定） 
            [a-zA-Z]      a到z或 A到Z，两头的字母包括在内（范围） 
            [0-9]         0到9，两头的数字包括在内（范围）
            
        C:预定义字符类
            .          任何字符。我的就是.字符本身，怎么表示呢? \.
            \.         .字符本身
            \\         \ 两个反斜杠字符代表一个反斜杠字符
            \d         数字：[0-9]
            \D         非数字：[^0-9] 
            \w         单词字符：[a-zA-Z_0-9]（在正则表达式里面组成单词的东西必须由这些东西组成。）
                    
        D:边界匹配器
            ^         行的开头 
            $         行的结尾 
            \b        单词边界（不是单词字符的地方。举例：hello world?haha;xixi 例子中：空格、?、;就是单词边界。）
                    
        E:Greedy 数量词 
            X         X出现一次（X后面什么也没有）
            X?        X出现一次或一次也没有
            X*        X出现零次或多次
            X+        X出现一次或多次
            X{n}      X出现恰好 n 次 
            X{n,}     X出现至少 n 次 
            X{n,m}    X出现至少 n 次，但是不超过 m 次 
            
            例如：
                [1-9][0-9]{4,14}    [1-9]出现一次[0-9]出现至少4次，但是不超过14次。

        A:判断功能
            String类的public boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式
        B:分割功能
            String类的public String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串
        C:替换功能
            String类的public String replaceAll(String regex,String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串
        D:获取功能
            Pattern类和Matcher类的使用
                模式和匹配器的典型调用顺序如下：(基本使用顺序)
                // 把正则表达式编译成模式对象
                Pattern p = Pattern.compile("a*b");
                // 通过模式对象得到匹配器对象，这个时候需要的是被匹配的字符串
                Matcher m = p.matcher("aaaaab");
                // 调用匹配器对象的匹配功能
                boolean b = m.matches();
                
                // 注意：一定要先调find()，然后才能调group()
                Matcher类的方法：public boolean find() 查找有没有满足条件的子串
                Matcher类的方法：public String group() 返回由以前匹配操作所匹配的输入子序列

 1 package cn.itcast_02;
 2 
 3 import java.util.Scanner;
 4 
 5 /*
 6  * 校验邮箱
 7  * 
 8  * 分析：
 9  *         A:键盘录入邮箱
10  *         B:定义邮箱的规则
11  *             1517806580@qq.com
12  *             liuyi@163.com
13  *             linqingxia@126.com
14  *             fengqingyang@sina.com.cn
15  *             fqy@itcast.cn
16  *         C:调用功能，判断即可
17  *         D:输出结果
18  */
19 public class RegexTest {
20     public static void main(String[] args) {
21         //键盘录入邮箱
22         Scanner sc = new Scanner(System.in);
23         System.out.println("请输入邮箱：");
24         String email = sc.nextLine();
25         
26         //定义邮箱的规则
27         //String regex = "[a-zA-Z_0-9]+@[a-zA-Z_0-9]{2,6}(\\.[a-zA-Z_0-9]{2,3})+";
28         String regex = "\\w+@\\w{2,6}(\\.\\w{2,3})+";
29         
30         //调用功能，判断即可
31         boolean flag = email.matches(regex);
32         
33         //输出结果
34         System.out.println("flag:"+flag);
35     }
36 }

 1 package cn.itcast_03;
 2 
 3 import java.util.Arrays;
 4 
 5 /*
 6  * 我有如下一个字符串:"91 27 46 38 50"
 7  * 请写代码实现最终输出结果是："27 38 46 50 91"
 8  * 
 9  * 分析：
10  *         A:定义一个字符串
11  *         B:把字符串进行分割，得到一个字符串数组
12  *         C:把字符串数组变换成int数组
13  *         D:对int数组排序
14  *         E:把排序后的int数组再组装成一个字符串
15  *         F:输出字符串
16  */
17 public class RegexTest {
18     public static void main(String[] args) {
19         // 定义一个字符串
20         String s = "91 27 46 38 50";
21 
22         // 把字符串进行分割，得到一个字符串数组
23         String[] strArray = s.split(" ");
24 
25         // 把字符串数组变换成int数组
26         int[] arr = new int[strArray.length];
27 
28         for (int x = 0; x < arr.length; x++) {
29             arr[x] = Integer.parseInt(strArray[x]);
30         }
31 
32         // 对int数组排序
33         Arrays.sort(arr);
34 
35         // 把排序后的int数组在组装成一个字符串缓冲区数组
36         // 可以把任意类型数据添加到字符串缓冲区里面，并返回字符串缓冲区对象本身，所以不需要再去创建对象接收了(该点很重要)。
37         StringBuilder sb = new StringBuilder();
38         for (int x = 0; x < arr.length; x++) {
39             sb.append(arr[x]).append(" ");
40         }
41         // 把字符串缓冲区数组转化为字符串，并去除前后端空格 trim()
42         String result = sb.toString().trim();
43         
44         // 输出字符串
45         System.out.println("result:"+result);
46     }
47 }

 1 package cn.itcast_04;
 2 
 3 /*
 4  * 替换功能
 5  *      String类的public String replaceAll(String regex, String replacement)
 6  *      使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。 
 7  */
 8 public class RegexDemo {
 9     public static void main(String[] args) {
10         // 定义一个字符串
11         String s = "helloqq12345worldkh622112345678java";
12 
13         // 我要去除所有的数字，用*给替换掉
14         // String regex = "\\d+";
15         // String regex = "\\d";
16         // String ss = "*";
17         
18         // 直接把数字干掉
19         String regex = "\\d+";
20         String ss = "";
21 
22         String result = s.replaceAll(regex, ss);
23         System.out.println(result); // helloqqworldkhjava
24     }
25 }

 1 package cn.itcast_05;
 2 
 3 import java.util.regex.Matcher;
 4 import java.util.regex.Pattern;
 5 
 6 /*
 7  * 获取功能：
 8  *         获取下面这个字符串中由三个字符组成的单词
 9  *         da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?
10  */
11 public class RegexDemo2 {
12     public static void main(String[] args) {
13         // 定义字符串
14         String s = "da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?";
15         // 规则
16         String regex = "\\b\\w{3}\\b";
17 
18         // 把规则编译成模式对象
19         Pattern p = Pattern.compile(regex);
20         // 通过模式对象得到匹配器对象
21         Matcher m = p.matcher(s);
22         // 调用匹配器对象的功能
23         // Matcher类的方法：public boolean find() 查找有没有满足条件的子串
24         // boolean flag = m.find();
25         // System.out.println(flag);
26         
27         // 如何或获取值呢？
28         // Matcher类的方法：public String group() 返回由以前匹配操作所匹配的输入子序列
29         // String ss = m.group();
30         // System.out.println(ss);
31 
32         // 再来一次
33         // 判断有没有
34         // flag = m.find();
35         // System.out.println(flag);
36         // 获取值
37         // ss = m.group();
38         // System.out.println(ss);
39 
40         while (m.find()) {
41             System.out.println(m.group());
42         }
43 
44         // 注意：一定要先调find()，然后才能调group()
45         // 若直接group()，会抛出异常
46         // IllegalStateException: No match found
47         // String ss = m.group();
48         // System.out.println(ss);
49     }
50 }

 1 package cn.itcast_02;
 2 
 3 import java.util.Scanner;
 4 
 5 /*
 6  * 需求：请设计一个方法，可以实现获取任意范围内的随机数。
 7  * 
 8  * 分析：
 9  *         A:键盘录入两个数据；
10  *             int strat;
11  *             int end;
12  *         B:想办法获取在start到end之间的随机数；
13  *             我写一个功能实现这个效果，得到一个随机数。(int)
14  *         C:输出这个随机数。
15  */
16 public class MathDemo {
17     public static void main(String[] args) {
18         Scanner sc = new Scanner(System.in);
19         System.out.println("请输入开始数：");
20         int start = sc.nextInt();
21         System.out.println("请输入结束数：");
22         int end = sc.nextInt();
23 
24         for (int x = 0; x < 100; x++) {
25             // 调用功能
26             int num = getRandom(start, end);
27             // 输出结果
28             System.out.println(num);
29         }
30     }
31 
32     /*
33      * 写一个功能 两个明确： 
34      *         返回值类型：int 
35      *         参数列表：int start, int end
36      */
37     public static int getRandom(int start, int end) {
38         // 回想我们讲过的1-100之间的随机数
39         // int number = (int) (Math.random() * 100) + 1;
40         // int number = (int) (Math.random() * end) + start;
41         // 发现有问题了，怎么办呢?
42         int number = (int) (Math.random() * (end - start + 1)) + start;
43         return number;
44     }
45 }

 1 package cn.itcast_01;
 2 
 3 /*
 4  * 看程序写结果：结果和我们想的有一点点不一样，这是因为float类型的数据存储和整数不一样导致的。它们大部分的时候，都是带有有效数字位。
 5  * 
 6  * 由于在运算的时候，float类型和double很容易丢失精度，演示案例。所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal
 7  * 
 8  * BigDecimal类：不可变的、任意精度的有符号十进制数，可以解决数据丢失问题。
 9  */
10 public class BigDecimalDemo {
11     public static void main(String[] args) {
12         System.out.println(0.09 + 0.01); // 0.09999999999999999
13         System.out.println(1.0 - 0.32);  // 0.6799999999999999 
14         System.out.println(1.015 * 100); // 101.49999999999999
15         System.out.println(1.301 / 100); // 0.013009999999999999
16 
17         System.out.println(1.0 - 0.12); // 0.88
18     }
19 }

 1 package cn.itcast_02;
 2 
 3 import java.math.BigDecimal;
 4 
 5 /*
 6  * BigDecimal类的构造方法：
 7  *         public BigDecimal(String val)
 8  * 
 9  * BigDecimal类的成员方法
10  *         public BigDecimal add(BigDecimal augend)
11  *         public BigDecimal subtract(BigDecimal subtrahend)
12  *         public BigDecimal multiply(BigDecimal multiplicand)
13  *         public BigDecimal divide(BigDecimal divisor)
14  *         public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode) 被除数，几位小数，如何舍取
15  *             已过时。 应该优先使用方法divide(BigDecimal, int, RoundingMode) 。 
16  */
17 public class BigDecimalDemo {
18     public static void main(String[] args) {
19         // System.out.println(0.09 + 0.01);
20         // System.out.println(1.0 - 0.32);
21         // System.out.println(1.015 * 100);
22         // System.out.println(1.301 / 100);
23 
24         BigDecimal bd1 = new BigDecimal("0.09");
25         BigDecimal bd2 = new BigDecimal("0.01");
26         System.out.println("add:" + bd1.add(bd2)); // 0.10
27         System.out.println("-------------------");
28 
29         BigDecimal bd3 = new BigDecimal("1.0");
30         BigDecimal bd4 = new BigDecimal("0.32"); 
31         System.out.println("subtract:" + bd3.subtract(bd4)); // 0.68
32         System.out.println("-------------------");
33 
34         BigDecimal bd5 = new BigDecimal("1.015");
35         BigDecimal bd6 = new BigDecimal("100");
36         System.out.println("multiply:" + bd5.multiply(bd6)); // 101.500
37         System.out.println("-------------------");
38 
39         BigDecimal bd7 = new BigDecimal("1.301");
40         BigDecimal bd8 = new BigDecimal("100");
41         System.out.println("divide:" + bd7.divide(bd8)); // 0.01301
42         System.out.println("divide:" + bd7.divide(bd8, 3, BigDecimal.ROUND_HALF_UP)); // 0.013
43         System.out.println("divide:" + bd7.divide(bd8, 8, BigDecimal.ROUND_HALF_UP)); // 0.01301000
44     }
45 }

                把Date(日期)转换为一个毫秒值
                    1.通过Date类的成员方法：public long getTime()
                        Date d = new Date();
                        long time = d.getTime();
                把一个毫秒值转换为Date(日期)
                    1.通过Date类的构造方法：public Date(long date)
                        long time = 1000 * 60 * 60; // 1小时
                        Date d = new Date(time);
                    2.通过Date类的成员方法：public void setTime(long time) 
                        Date d = new Date();
                        d.setTime(1000);

 1 package cn.itcast_05;
 2 
 3 import java.text.ParseException;
 4 import java.text.SimpleDateFormat;
 5 import java.util.Date;
 6 import java.util.Scanner;
 7 
 8 /*
 9  * 算一下你来到这个世界多少天?
10  * 
11  * 分析：
12  *         A:键盘录入你的出生的年月日
13  *         B:把该字符串转换为一个日期
14  *         C:通过该日期得到一个毫秒值
15  *         D:获取当前时间的毫秒值
16  *         E:用D-C得到一个毫秒值
17  *         F:把E的毫秒值转换为天
18  *             /1000/60/60/24
19  */
20 public class MyYearOldDemo {
21     public static void main(String[] args) throws ParseException {
22         // 键盘录入你的出生的年月日
23         Scanner sc = new Scanner(System.in);
24         System.out.println("请输入你的出生年月日:"); // 1992-11-11
25         String line = sc.nextLine();
26 
27         // 把该字符串解析成一个日期
28         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
29         Date d = sdf.parse(line);
30 
31         // 通过该日期得到一个毫秒值
32         long myTime = d.getTime();
33 
34         // 获取当前时间的毫秒值
35         long nowTime = System.currentTimeMillis();
36 
37         // 用D-C得到一个毫秒值
38         long time = nowTime - myTime;
39 
40         // 把E的毫秒值转换为天
41         long day = time / 1000 / 60 / 60 / 24;
42 
43         System.out.println("你来到这个世界：" + day + "天"); // 9259天
44     }
45 }

 1 package cn.itcast_03;
 2 
 3 import java.text.ParseException;
 4 import java.text.SimpleDateFormat;
 5 import java.util.Date;
 6 
 7 /*
 8  *         (格式化)
 9  * Date  -->  String
10  *         public final String format(Date date)
11  * 
12  *         (解析)
13  * String  -->  Date
14  *         public Date parse(String source)
15  * 
16  * DateForamt类是针对日期/时间进行格式化和针对字符串(文本)进行解析的类，但是它是抽象类，所以使用其子类SimpleDateFormat。
17  * 
18  * SimpleDateFormat类的构造方法：
19  *         public SimpleDateFormat() 默认模式
20  *         public SimpleDateFormat(String pattern) 给定的模式
21  *             这个给定的模式字符串该如何写呢?
22  *             通过查看API，我们就找到了对应的模式：
23  *                 年 y
24  *                 月 M    
25  *                 日 d
26  *                 时 H
27  *                 分 m
28  *                 秒 s
29  *             一般我们要以下这种格式：
30  *                 2014年12月12日 12:12:12
31  */
32 public class DateFormatDemo {
33     public static void main(String[] args) throws ParseException {
34         // Date  -->  String(格式化)
35         // 创建日期对象
36         Date d = new Date();
37         
38         // 创建格式化对象
39         // 默认模式
40         // SimpleDateFormat sdf = new SimpleDateFormat();
41         // DateFormat类的方法：public final String format(Date date)
42         // String s = sdf.format(d);
43         // System.out.println(s); // 2018/3/19 下午12:04
44         
45         // 给定模式
46         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
47         SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
48         String s = sdf.format(d);
49         String s2 = sdf2.format(d);
50         System.out.println(s);  // 20180319121200
51         System.out.println(s2); // 2018年03月19日 12:12:00
52         
53         
54         // String  -->  Date(解析)
55         String str = "2008-08-08 12:12:12";
56         // 注意：在把一个字符串解析为日期的时候，解析的格式必须和给定的字符串的格式匹配。
57         SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
58         Date dd = sdf3.parse(str);
59         System.out.println(dd); // Fri Aug 08 12:12:12 CST 2008
60     }
61 }

 1 package cn.itcast_04;
 2 
 3 import java.text.ParseException;
 4 import java.text.SimpleDateFormat;
 5 import java.util.Date;
 6 
 7 /**
 8  * 这是日期和字符串相互转换的工具类
 9  * 
10  * @author 风清扬
11  */
12 public class DateUtil {
13     private DateUtil() {
14     }
15 
16     /**
17      * 这个方法的作用就是把日期格式化成一个字符串
18      * 
19      * @param d
20      *            被格式化的日期对象
21      * @param format
22      *            传递过来的要被转换的格式
23      * @return 格式化后的字符串
24      */
25     public static String dateToString(Date d, String format) {
26         // SimpleDateFormat sdf = new SimpleDateFormat(format);
27         // return sdf.format(d);
28         return new SimpleDateFormat(format).format(d);
29     }
30 
31     /**
32      * 这个方法的作用就是把一个字符串解析成一个日期对象
33      * 
34      * @param s
35      *            被解析的字符串
36      * @param format
37      *            传递过来的要被转换的格式
38      * @return 解析后的日期对象
39      * @throws ParseException
40      */
41     public static Date stringToDate(String s, String format) throws ParseException {
42         return new SimpleDateFormat(format).parse(s);
43     }
44 }

 1 package cn.itcast_04;
 2 
 3 import java.text.ParseException;
 4 import java.util.Date;
 5 
 6 /*
 7  * 工具类的测试
 8  */
 9 public class DateUtilDemo {
10     public static void main(String[] args) throws ParseException {
11         // 格式为：yyyy年MM月dd日 HH:mm:ss
12         Date d = new Date();
13         String s = DateUtil.dateToString(d, "yyyy年MM月dd日 HH:mm:ss");
14         System.out.println(s); // 2018年03月19日 14:57:19
15         
16         // 格式为：yyyy年MM月dd日
17         String s2 = DateUtil.dateToString(d, "yyyy年MM月dd日");
18         System.out.println(s2); // 2018年03月19日
19 
20         // 格式为：HH:mm:ss
21         String s3 = DateUtil.dateToString(d, "HH:mm:ss");
22         System.out.println(s3); // 14:57:19
23 
24         String str = "2014-10-14";
25         Date dd = DateUtil.stringToDate(str, "yyyy-MM-dd");
26         System.out.println(dd); // Tue Oct 14 00:00:00 CST 2014
27     }
28 }

 1 package cn.itcast_03;
 2 
 3 import java.util.Calendar;
 4 import java.util.Scanner;
 5 
 6 /*
 7  * 获取任意一年的二月有多少天
 8  * 
 9  * 分析：
10  *         A:键盘录入任意的年份
11  *         B:设置日历对象的年月日
12  *             年就是A输入的数据
13  *                 月是2
14  *                 日是1
15  *                 是3月1日
16  *         C:把时间往前推一天，就是2月的最后一天
17  *         D:获取这一天输出即可
18  */
19 public class CalendarTest {
20     public static void main(String[] args) {
21         // 键盘录入任意的年份
22         Scanner sc = new Scanner(System.in);
23         System.out.println("请输入年份：");
24         int year = sc.nextInt();
25 
26         // 设置日历对象的年月日
27         Calendar c = Calendar.getInstance();
28         c.set(year, 2, 1); // 其实是这一年的3月1日
29         // 把时间往前推一天，就是2月的最后一天
30         c.add(Calendar.DATE, -1);
31 
32         // 获取这一天输出即可
33         System.out.println(c.get(Calendar.DATE));
34     }
35 }