javaEE学习笔记——第十四天正则表达式、Math类、System类、Data类、Calendar类等

2023-01-10 15:50:38

javaEE学习第十四天

java知识

正则表达式的概述和简单使用

A:正则表达式
- 是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。
- 作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的
B:案例演示
- 需求：校验qq号码.
  - 1:要求必须是5-15位数字
  - 2:0不能开头
  - 3:必须都是数字
- a:非正则表达式实现
- b:正则表达式实现

代码

  package com.yinglongwu.regex;
  
  
  
  public class Demo1_Regex {
  
  
  
      public static void main(String[] args) {
  
          System.out.println(checkQQ("012345"));
  
          System.out.println(checkQQ("a1b345"));
  
          System.out.println(checkQQ("123456"));
  
          System.out.println(checkQQ("1234567890987654321"));
  
          
  
          String regex = "[1-9]\\d{4,14}";    //正则表达式的方法
  
          System.out.println("2553868".matches(regex));
  
          System.out.println("012345".matches(regex));
  
          System.out.println("2553868abc".matches(regex));
  
      }
  
      //非正则表达式
  
      public static boolean checkQQ(String qq) {
  
          boolean flag = true;                    //如果校验qq不符合要求就把flag置为false,如果符合要求直接返回
  
          
  
          if(qq.length() >= 5 && qq.length() <= 15) {
  
              if(!qq.startsWith("0")) {
  
                  char[] arr = qq.toCharArray();    //将字符串转换成字符数组
  
                  for (int i = 0; i < arr.length; i++) {
  
                      char ch = arr[i];            //记录每一个字符
  
                      if(!(ch >= '0' && ch <= '9')) {
  
                          flag = false;            //不是数字
  
                          break;
  
                      }
  
                  }
  
              }else {
  
                  flag = false;                    //以0开头,不符合qq标准
  
              }
  
          }else {
  
              flag = false;                        //长度不符合
  
          }
  
          return flag;
  
      }
  
  }
  
  
  ### 正则表达式字符类演示
  
  * A:字符类
  
      * [abc] a、b 或 c（简单类） 
  
      * [^abc] 任何字符，除了 a、b 或 c（否定） 

  * [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围） 

  * [0-9] 0到9的字符都包括

代码示例

package com.yinglongwu.regex;

public class Demo2_Regex {

  /**

   * [abc] a、b 或 c（简单类） 

      [^abc] 任何字符，除了 a、b 或 c（否定） 

      [a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围） 

      [a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集） 

      [a-z&&[def]] d、e 或 f（交集） 

      [a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去） 

      [a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去） 



   */

  public static void main(String[] args) {

      //demo1();

      //demo2();

      //demo3();

      //demo4();

      //demo5();

      //demo6();

      String regex = "[a-z&&[^m-p]]";    //a 到 z，而非 m 到 p：[a-lq-z]（减去） 

      System.out.println("m".matches(regex));//false

      System.out.println("a".matches(regex));//true

      System.out.println("z".matches(regex));//true

      System.out.println("n".matches(regex));//false

  }



  private static void demo6() {

      String regex = "[a-z&&[^bc]]";    // a 到 z，除了 b 和 c：[ad-z]（减去）

      System.out.println("a".matches(regex));//true

      System.out.println("b".matches(regex));//false

      System.out.println("1".matches(regex));//false

  }



  private static void demo5() {

      String regex = "[a-z&&[def]]";    //d、e 或 f（交集)

      System.out.println("a".matches(regex));    //false

      System.out.println("d".matches(regex));    //true

  }



  private static void demo4() {

      String regex = "[a-d[m-p]]";    //a 到 d 或 m 到 p：[a-dm-p]（并集）

      System.out.println("a".matches(regex));//true

      System.out.println("m".matches(regex));//true

      System.out.println("n".matches(regex));//true

  }



  private static void demo3() {

      String regex = "[a-zA-Z]";    //a 到 z 或 A 到 Z，两头的字母包括在内（范围） 

      System.out.println("a".matches(regex));//true

      System.out.println("A".matches(regex));//true

      System.out.println("z".matches(regex));//true

      System.out.println("Z".matches(regex));//true

      System.out.println("1".matches(regex));//false

      System.out.println("%".matches(regex));//false

  }



  private static void demo2() {

      String regex = "[^abc]";    //除了a和b和的单个字符，才返回true

      System.out.println("a".matches(regex));    //false

      System.out.println("b".matches(regex));    //false

      System.out.println("c".matches(regex));    //false

      System.out.println("d".matches(regex));    //true

      System.out.println("1".matches(regex));    //true

      System.out.println("%".matches(regex));    //true

      System.out.println("10".matches(regex));//false，10代表1字符和0字符,不是单个字符

  }



  private static void demo1() {

      String regex = "[abc]";        //[]代表单个字符，只能是a或b或c时返回true

      System.out.println("a".matches(regex));    //true

      System.out.println("b".matches(regex));    //true

      System.out.println("c".matches(regex));    //true

      System.out.println("d".matches(regex));    //false

      System.out.println("1".matches(regex));    //false

      System.out.println("%".matches(regex));    //false

  }

}

正则表达式预定义字符类演示

A:预定义字符类
- . 任何字符。
- \d 数字：[0-9]
- \w 单词字符：[a-zA-Z_0-9]

代码演示

  package com.yinglongwu.regex;

  

  public class Demo3_Regex {

  

      /**

       *     . 任何单个字符返回true

          \d 数字：[0-9] ,单个字符

          \D 非数字： [^0-9] 

          \s 空白字符：[ \t\n\x0B\f\r] ,分别代表：空格、水平制表符table、换行、垂直制表符、翻页、回车

          \S 非空白字符：[^\s] 

          \w 单词字符：[a-zA-Z_0-9] 

          \W 非单词字符：[^\w] 

  

       */

      public static void main(String[] args) {

          //demo1();

          //demo2();

          //demo3();

          //demo4();

          //demo5();

          //demo6();

          String regex = "\\W";

          System.out.println("a".matches(regex));//false

          System.out.println("z".matches(regex));//false

          System.out.println("_".matches(regex));//false

          System.out.println("%".matches(regex));//true

      }

  

      private static void demo6() {

          String regex = "\\w";

          System.out.println("a".matches(regex));//true

          System.out.println("z".matches(regex));//true

          System.out.println("_".matches(regex));//true

          System.out.println("%".matches(regex));//false

      }

  

      private static void demo5() {

          String regex = "\\S";

          System.out.println(" ".matches(regex));        //false，一个空格

          System.out.println("    ".matches(regex));    //false，一个table键

          System.out.println("a".matches(regex));        //true

      }

  

      private static void demo4() {

          String regex = "\\s";

          System.out.println(" ".matches(regex));    //一个空格，true

          System.out.println("    ".matches(regex));     //一个tab键，true

          System.out.println("    ".matches(regex));     //四个空格，false

      }

  

      private static void demo3() {

          String regex = "\\D";

          System.out.println("0".matches(regex));//false

          System.out.println("9".matches(regex));//false

          System.out.println("a".matches(regex));//true

      }

  

      private static void demo2() {

          String regex = "\\d";    //\代表转义字符,如果想表示\d的话,需要\\d

          System.out.println("0".matches(regex));//true

          System.out.println("a".matches(regex));//false

          System.out.println("9".matches(regex));//true

      }

  

      private static void demo1() {

          String regex = "..";    //任意两个字符

          System.out.println("a".matches(regex));    //false

          System.out.println("ab".matches(regex));//true

      }

  

  }

正则表达式数量词

A:Greedy 数量词
- X? X，一次或一次也没有
- X* X，零次或多次
- X+ X，一次或多次
- X{n} X，恰好 n 次
- X{n,} X，至少 n 次
- X{n,m} X，至少 n 次，但是不超过 m 次

代码演示

  package com.yinglongwu.regex;

  

  public class Demo4_Regex {

  

      /**

       * Greedy 数量词 

          X? X，一次或一次也没有 

          X* X，零次或多次 ，包括一次

          X+ X，一次或多次 

          X{n} X，恰好 n 次 

          X{n,} X，至少 n 次 

          X{n,m} X，至少 n 次，但是不超过 m 次 

       */

      public static void main(String[] args) {

          //demo1();

          //demo2();

          //demo3();

          //demo4();

          //demo5();

          String regex = "[abc]{5,15}";

          System.out.println("abcba".matches(regex));                //true

          System.out.println("abcbaabcabbabab".matches(regex));    //true

          System.out.println("abcb".matches(regex));                //false

          System.out.println("abcbaabaabcbaaba".matches(regex));    //false

      }

  

      public static void demo5() {

          String regex = "[abc]{5,}";

          System.out.println("abcba".matches(regex));                //true

          System.out.println("abcbaabcabbabab".matches(regex));    //true

          System.out.println("abcb".matches(regex));                //false

          System.out.println("abcbaaba".matches(regex));            //true

      }

  

      public static void demo4() {

          String regex = "[abc]{5}";

          System.out.println("abcba".matches(regex));                //true

          System.out.println("abcbaabcabbabab".matches(regex));    //false

          System.out.println("abcb".matches(regex));                //false

          System.out.println("abcbaaba".matches(regex));            //false

      }

  

      public static void demo3() {

          String regex = "[abc]+";

          System.out.println("".matches(regex));    //false

          System.out.println("a".matches(regex));    //true

          System.out.println("aaaaabbbbccccc".matches(regex));    //true

      }

  

      public static void demo2() {

          String regex = "[abc]*";

          System.out.println("".matches(regex));        //true

          System.out.println("abc".matches(regex));    //true

          System.out.println("a".matches(regex));        //true

      }

  

      public static void demo1() {

          String regex = "[abc]?";

          System.out.println("a".matches(regex));//true

          System.out.println("b".matches(regex));//true

          System.out.println("c".matches(regex));//true

          System.out.println("d".matches(regex));//false

          System.out.println("".matches(regex));    //true

      }

  

  }

正则表达式的分割功能

A:正则表达式的分割功能
- String类的功能：public String[] split(String regex)

B:案例演示

  package com.yinglongwu.regex;

  

  public class Demo5_Split {

  

      /**

       * @param args

       */

      public static void main(String[] args) {

          String s = "金三胖.郭美美.李dayone";

          String[] arr = s.split("\\.");    //通过正则表达式切割字符串，注意转义

          

          for (int i = 0; i < arr.length; i++) {

              System.out.println(arr[i]);

          }

          //金三胖

          //郭美美

          //李dayone

          System.out.println("11111111111111111");

      }

  

  }

把给定字符串中的数字排序

A:案例演示
- 需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”

代码

  package com.yinglongwu.test;
  
  
  
  import java.util.Arrays;
  
  
  
  public class Test1 {
  
  
  
      /**
  
       * @param args
  
       * * A:案例演示
  
       * 需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”
  
       * 100
  
       * 80
  
       * 分析:
  
       * 1,将字符串切割成字符串数组
  
       * 2,将字符串转换成数字并将其存储在一个等长度的int数组中
  
       * 3,排序
  
       * 4,将排序后的结果遍历并拼接成一个字符串
  
       */
  
      public static void main(String[] args) {
  
          String s = "91 27 46 38 50";
  
          //1,将字符串切割成字符串数组
  
          String[] sArr = s.split(" ");
  
          //2,将字符串转换成数字并将其存储在一个等长度的int数组中
  
          int[] arr = new int[sArr.length];
  
          for (int i = 0; i < arr.length; i++) {
  
              arr[i] = Integer.parseInt(sArr[i]);     //将数字字符串转换成数字
  
          }
  
          
  
          //3,排序
  
          Arrays.sort(arr);
  
          
  
          //4,将排序后的结果遍历并拼接成一个字符串27 38 46 50 91
  
          /*String str = "";    //不推荐这种方法，会产生很多垃圾
  
          for (int i = 0; i < arr.length; i++) {
  
              if(i == arr.length - 1) {
  
                  str = str + arr[i];                //27 38 46 50 91
  
              }else {
  
                  str = str + arr[i] + " ";        //27 38 46 50 
  
              }
  
          }
  
          
  
          System.out.println(str);*/
  
          
  
          StringBuilder sb = new StringBuilder();    //这种方法只创建一个对象，节约内存
  
          for (int i = 0; i < arr.length; i++) {
  
              if(i == arr.length - 1) {
  
                  sb.append(arr[i]);
  
              }else {
  
                  sb.append(arr[i] + " ");
  
              }
  
          }
  
          
  
          System.out.println(sb);
  
      }
  
  
  
  }
  
  
  
  
  
  ### 正则表达式的替换功能
  
  * A:正则表达式的替换功能
  
      * String类的功能：public String replaceAll(String regex,String replacement)

B:案例演示

  package com.yinglongwu.regex;
  
  
  
  public class Demo6_ReplaceAll {
  
  
  
      /**
  
       * * A:正则表达式的替换功能

   * String类的功能：public String replaceAll(String regex,String replacement)

   */

  public static void main(String[] args) {

      String s = "wo111ai222yinglongwu";

      String regex = "\\d";            //\\d代表的是任意数字

      

      String s2 = s.replaceAll(regex, "");    //用空字符代替任意数字

      System.out.println(s2);    //woaiyinglongwu

  }

}

正则表达式的分组功能

A:正则表达式的分组功能
捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B©)) 中，存在四个这样的组：

    1     ((A)(B(C))) 

    2     (A 

    3     (B(C)) 

    4     (C) 



    组零始终代表整个表达式。

B:案例演示

a:切割

    需求：请按照叠词切割： "sdqqfgkkkhjppppkl";

b:替换

    需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程

    将字符串还原成:“我要学编程”。

代码

  package com.yinglongwu.regex;

  

  public class Demo7_Regex {

  

      public static void main(String[] args) {

          //demo1();

          //demo2();

          

          /*

           * 需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程

                  将字符串还原成:“我要学编程”。

           */

          String s = "我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";

          String s2 = s.replaceAll("\\.+", "");    //用空字符替换出现一次到多次的.

          String s3 = s2.replaceAll("(.)\\1+", "$1");    //$1代表第一组中的内容，用第一组的内容（也就是一个我）替换4个我

          System.out.println(s3);    //我要学编程

      }

  

      public static void demo2() {

          //需求：请按照叠词切割： "sdqqfgkkkhjppppkl";

          String s = "sdqqfgkkkhjppppkl";

          String regex = "(.)\\1+";            //+代表第一组出现一次到多次

          String[] arr = s.split(regex);

          

          for (int i = 0; i < arr.length; i++) {

              System.out.println(arr[i]);    //sd

          }                                //fg

      }                                    //hj

                                          //kl

      public static void demo1() {

          //叠词 AABB形式

          /*String regex = "(.)\\1(.)\\2";    // ()代表一组，\\1代表第一组又出现一次    \\2代表第二组又出现一次

          System.out.println("快快乐乐".matches(regex));//true

          System.out.println("快乐乐乐".matches(regex));//true

          System.out.println("高高兴兴".matches(regex));//true

          System.out.println("死啦死啦".matches(regex));//false */

          

          //叠词 ABAB形式

          String regex2 = "(..)\\1";

          System.out.println("死啦死啦".matches(regex2));//true

          System.out.println("高兴高兴".matches(regex2));//true

          System.out.println("快快乐乐".matches(regex2));//false

      }

  

  }

Pattern和Matcher的概述

A:Pattern和Matcher的概述
B:模式和匹配器的典型调用顺序
- 通过JDK提供的API，查看Pattern类的说明
- 典型的调用顺序是
- Pattern p = Pattern.compile(“a*b”);
- Matcher m = p.matcher(“aaaaab”);
- boolean b = m.matches();

正则表达式的获取功能

A:正则表达式的获取功能
- Pattern和Matcher的结合使用
B:案例演示
- 需求：把一个字符串中的手机号码获取出来

代码

  package com.yinglongwu.regex;

  

  import java.util.regex.Matcher;

  import java.util.regex.Pattern;

  

  public class Demo8_Pattern {

      public static void main(String[] args) {

          //demo1();

          String s = "我的手机是18988888888,我曾用过18987654321,还用过18812345678";

          String regex = "1[3578]\\d{9}";    //手机号的正则表达式

          

          

          Pattern p = Pattern.compile(regex);

          Matcher m = p.matcher(s);

          

          /*boolean b1 = m.find();

          System.out.println(b1);

          System.out.println(m.group());

          

          boolean b2 = m.find();

          System.out.println(b2);

          System.out.println(m.group());*/

          

          while(m.find())    //用循环代替上面注释掉的

              System.out.println(m.group());

      }

  

      public static void demo1() {

          Pattern p = Pattern.compile("a*b");    //获取到正则表达式

          Matcher m = p.matcher("aaaaab");    //获取匹配器

          boolean b = m.matches();            //看是否能匹配,匹配就返回true

          

          System.out.println(b);

          

          //与上面的结果一样，可以用下面这一行替代

          System.out.println("aaaaab".matches("a*b"));  

      }

  

  }

Math类概述和方法使用

A:Math类概述
- Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
B:成员方法
- public static int abs(int a)
- public static double ceil(double a)
- public static double floor(double a)
- public static int max(int a,int b) min自学
- public static double pow(double a,double b)
- public static double random()
- public static int round(float a) 参数为double的自学
- public static double sqrt(double a)

代码

  package com.yinglongwu.otherclass;

  

  public class Demo1_Math {

      public static void main(String[] args) {

          System.out.println(Math.PI);                    //圆周率

          System.out.println(Math.abs(-10));              //取绝对值

          

          //ceil天花板

          /*

           * 13.0

           * 12.3

           * 12.0

           */

          System.out.println(Math.ceil(12.3));            //13.0，向上取整,但是结果是一个double

          System.out.println(Math.ceil(12.99));            //13.0

          

          System.out.println("-----------");

          //floor地板

          /*

           * 13.0

           * 12.3

           * 12.0

           */

          System.out.println(Math.floor(12.3));            //12.0向下取整,但是结果是一个double

          System.out.println(Math.floor(12.99));            //12.0

          

          //获取两个值中的最大值

          System.out.println(Math.max(20, 30));

          

          //前面的数是底数,后面的数是指数

          System.out.println(Math.pow(2, 3));                //2.0 ^ 3.0

          

          //生成0.0到1.0之间的所以小数,包括0.0,不包括1.0,[0.0,1.0)

          System.out.println(Math.random());

          

          //四舍五入

          System.out.println(Math.round(12.3f));//12,返回int

          System.out.println(Math.round(12.9f));//13,返回int

          

          //开平方

          System.out.println(Math.sqrt(4));//2.0

          System.out.println(Math.sqrt(2));//1.414......

          System.out.println(Math.sqrt(3));//1.732......

      }

  

  }

Random类的概述和方法使用

A:Random类的概述
- 此类用于产生随机数如果用相同的种子创建两个 Random 实例，
- 则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
B:构造方法
- public Random()
- public Random(long seed)
C:成员方法
- public int nextInt()
- public int nextInt(int n)

代码

  package com.yinglongwu.otherclass;

  

  import java.util.Random;

  

  public class Demo2_Random {

  

      /**

       * * A:Random类的概述

              * 此类用于产生随机数如果用相同的种子创建两个 Random 实例，

              * 则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。

          * B:构造方法

              * public Random()

              * public Random(long seed)

          * C:成员方法

              * public int nextInt()

              * public int nextInt(int n)(重点掌握)

       */

      public static void main(String[] args) {

          Random r = new Random();    //未指定种子，把纳秒值当做种子，所以每一次结果不一样

          //输出一次

          /*int x = r.nextInt();

          System.out.println(x);*/

          //循环输出，结果不一样

          for(int i = 0; i < 10; i++) {

              //System.out.println(r.nextInt());    //生成任意随机数

              System.out.println(r.nextInt(100));    //生成在0到n范围内的随机数,包含0不包含n

          }

          

  

          /*Random r2 = new Random(1001);//指定种子后，输出结果一样

          

          int a = r2.nextInt();

          int b = r2.nextInt();

          

          System.out.println(a);

          System.out.println(b);*/

          /*两次输出结果一样

          -1244746321

          1060493871

          

          -1244746321

          1060493871

           */

          

      }

  

  }

System类的概述和方法使用

A:System类的概述
- System 类包含一些有用的类字段和方法。它不能被实例化。（因为底层把它私有化了）
B:成员方法
- public static void gc()
- public static void exit(int status)
- public static long currentTimeMillis()
- pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
C:案例演示
- System类的成员方法使用

代码演示

  package com.yinglongwu.otherclass;

  

  public class Demo3_System {

      public static void main(String[] args) {

          //demo1();

          //demo2();

          //demo3();

          

          int[] src = {11,22,33,44,55};

          int[] dest = new int[8];

          for (int i = 0; i < dest.length; i++) {

              System.out.println(dest[i]);

          }

          

          System.out.println("--------------------------");

          System.arraycopy(src, 0, dest, 0, src.length);        //将数组内容拷贝

          //(源数组，从源数组哪个下标开始，目标数组，从目标数组的哪个下标开始，源数组的个数)

          for (int i = 0; i < dest.length; i++) {

              System.out.println(dest[i]);

          }

      }

  

      public static void demo3() {

          long start = System.currentTimeMillis();//1秒等于1000毫秒

          for(int i = 0; i < 1000; i++) {

              System.out.println("*");

          }

          long end = System.currentTimeMillis();    //获取当前时间的毫秒值

          

          System.out.println(end - start);

      }

  

      public static void demo2() {

          System.exit(0);            //0是正常终止，非0状态是异常终止,退出jvm

          System.out.println("11111111111");    //退出后这句话输出不了

      }

  

      public static void demo1() {

          for(int i = 0; i < 100; i++) {

              new Demo();        //产生100个垃圾

              System.gc();    //当垃圾不够多时，系统可能不会自动清理垃圾，运行垃圾回收器,相当于呼喊保洁阿姨

          }

      }

  

  }

  

  class Demo {    //在一个源文件中不允许定义两个用public修饰的类

  

      @Override

      public void finalize() {

          System.out.println("垃圾被清扫了");

      }                            

      

  }

BigInteger类的概述和方法使用

A:BigInteger的概述
- 可以让超过Integer范围内的数据进行运算
B:构造方法
- public BigInteger(String val)
C:成员方法
- public BigInteger add(BigInteger val)
- public BigInteger subtract(BigInteger val)
- public BigInteger multiply(BigInteger val)
- public BigInteger divide(BigInteger val)
- public BigInteger[] divideAndRemainder(BigInteger val)

代码

  package com.yinglongwu.otherclass;

  

  import java.math.BigInteger;

  

  public class Demo4_BigInteger {

  

      public static void main(String[] args) {

          //long num = 123456789098765432123L;

          //String s = "123456789098765432123";

          

          BigInteger bi1 = new BigInteger("100");

          BigInteger bi2 = new BigInteger("2");

          

          System.out.println(bi1.add(bi2));                 //+

          System.out.println(bi1.subtract(bi2));            //-

          System.out.println(bi1.multiply(bi2));             //*

          System.out.println(bi1.divide(bi2));            ///(除)

          

          BigInteger[] arr = bi1.divideAndRemainder(bi2);    //取除数和余数，返回到数组里

          

          for (int i = 0; i < arr.length; i++) {

              System.out.println(arr[i]);

          }

      }

  

  }

BigDecimal类的概述和方法使用

A:BigDecimal的概述
- 由于在运算的时候，float类型和double很容易丢失精度，演示案例。
- 所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal
- 不可变的、任意精度的有符号十进制数。
B:构造方法
- public BigDecimal(String val)
C:成员方法
- public BigDecimal add(BigDecimal augend)
- public BigDecimal subtract(BigDecimal subtrahend)
- public BigDecimal multiply(BigDecimal multiplicand)
- public BigDecimal divide(BigDecimal divisor)

D:案例演示

  package com.yinglongwu.otherclass;

  

  import java.math.BigDecimal;

  

  public class Demo5_BigDecimal {

  

      /*

          十进制表示1/3

          0.3333333333333333333333333333333333333333 

               */

      public static void main(String[] args) {

          //System.out.println(2.0 - 1.1);    //0.89999999...

          

          /*BigDecimal bd1 = new BigDecimal(2.0);        //这种方式在开发中不推荐,因为不够精确

          BigDecimal bd2 = new BigDecimal(1.1);        

          System.out.println(bd1.subtract(bd2));*/

          

          /*BigDecimal bd1 = new BigDecimal("2.0");//通过构造中传入字符串的方式,开发时推荐

          BigDecimal bd2 = new BigDecimal("1.1");

          System.out.println(bd1.subtract(bd2));*/    //0.9

          

          BigDecimal bd1 = BigDecimal.valueOf(2.0);    //这种方式在开发中也是推荐的

          BigDecimal bd2 = BigDecimal.valueOf(1.1);

          System.out.println(bd1.subtract(bd2));        //0.9

      }

  

  }

Date类的概述和方法使用

A:Date类的概述
- 类 Date 表示特定的瞬间，精确到毫秒。
B:构造方法
- public Date()
- public Date(long date)
C:成员方法
- public long getTime()
- public void setTime(long time)

代码

  package com.yinglongwu.otherclass;
  
  
  
  import java.util.Date;
  
  
  
  public class Demo6_Date {
  
      public static void main(String[] args) {
  
          //demo1();
  
          //demo2();
  
          Date d1 = new Date();    
  
          d1.setTime(1000);            //设置毫秒值,改变时间对象
  
          System.out.println(d1);        //打印出来比参考时间多一秒，1000毫秒等于一秒
  
      }
  
  
  
      public static void demo2() {
  
          Date d1 = new Date();    
  
          System.out.println(d1.getTime());                //通过时间对象获取毫秒值
  
          System.out.println(System.currentTimeMillis());    //通过系统类的方法获取当前时间毫秒值
  
      }
  
  
  
      public static void demo1() {
  
          Date d1 = new Date();            //如果没有传参数代表的是当前时间
  
          System.out.println(d1);
  
          
  
          Date d2 = new Date(0);            //如果构造方法中参数传为0代表的是1970年1月1日
  
          System.out.println(d2);            //通过毫秒值创建时间对象,输出的具体时间与电脑时区有关
  
      }
  
  
  
  }
  
  
  
  
  
  ### SimpleDateFormat类实现日期和字符串的相互转换
  
  * A:DateFormat类的概述

  * DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽象类，所以使用其子类SimpleDateFormat

B:SimpleDateFormat构造方法
- public SimpleDateFormat()
- public SimpleDateFormat(String pattern)
C:成员方法
- public final String format(Date date)
- public Date parse(String source)

代码

  package com.yinglongwu.otherclass;

  

  import java.text.DateFormat;

  import java.text.ParseException;

  import java.text.SimpleDateFormat;

  import java.util.Date;

  

  public class Demo7_SimpleDateFormat {

  

      @throws ParseException //抛出异常,勿删

  

      public static void main(String[] args) throws ParseException {

          //demo1();

          //demo2();

          //demo3();

          

          //将时间字符串转换成日期对象

          String str = "2000年08月08日 08:08:08";

          SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

          Date d = sdf.parse(str);    //将时间字符串转换成日期对象,目前这里会报异常

          System.out.println(d);

      }

  

      public static void demo3() {

          Date d = new Date();                            //获取当前时间对象

          SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");//创建日期格式化类对象

          System.out.println(sdf.format(d));                //将日期对象转换为字符串

      }

  

      public static void demo2() {

          Date d = new Date();                            //获取当前时间对象

          SimpleDateFormat sdf = new SimpleDateFormat();    //创建日期格式化类对象

          System.out.println(sdf.format(d));                 //88-6-6 下午9:31

      }

  

      public static void demo1() {

          //DateFormat df = new DateFormat();                //DateFormat是抽象类,不允许实例化

          //DateFormat df1 = new SimpleDateFormat();

          DateFormat df1 = DateFormat.getDateInstance();    //相当于父类引用指向子类对象,右边的方法返回一个子类对象

      }

  

  }

Calendar类的概述和获取日期的方法

A:Calendar类的概述
- Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
B:成员方法
- public static Calendar getInstance()
- public int get(int field)

Calendar类的add()和set()方法

A:成员方法
- public void add(int field,int amount)
- public final void set(int year,int month,int date)

代码

  package com.yinglongwu.otherclass;

  

  import java.util.Calendar;

  

  public class Demo9_Calendar {

  

      public static void main(String[] args) {

          //demo1();

          Calendar c = Calendar.getInstance();            //父类引用指向子类对象

          //c.add(Calendar.MONTH, -1);                    //对指定的字段进行向前减或向后加

          //c.set(Calendar.YEAR, 2000);                    //修改指定字段

          c.set(2000, 7, 8);

          

          System.out.println(c.get(Calendar.YEAR) + "年" + getNum((c.get(Calendar.MONTH)+1)) 

                  + "月" + getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));

      }

  

      public static void demo1() {

          Calendar c = Calendar.getInstance();            //父类引用指向子类对象

          //System.out.println(c);

          System.out.println(c.get(Calendar.YEAR));        //通过字段获取年

          System.out.println(c.get(Calendar.MONTH));        //通过字段后期月,但是月是从0开始编号的,我们要自己加一

          System.out.println(c.get(Calendar.DAY_OF_MONTH));//月中的第几天

          System.out.println(c.get(Calendar.DAY_OF_WEEK));//周日是第一天,周六是最后一天

          

          System.out.println(c.get(Calendar.YEAR) + "年" + getNum((c.get(Calendar.MONTH)+1)) 

                  + "月" + getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));

      }

      

      /*

       * 将星期存储表中进行查表

       * 1,返回值类型String

       * 2,参数列表int week

       */

      

      public static String getWeek(int week) {

          String[] arr = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};

          

          return arr[week];

      }

      

      /*

       * 如果是个数数字前面补0

       * 1,返回值类型String类型

       * 2,参数列表,int num

       */

      public static String getNum(int num) {

          /*if(num > 9) {

              return "" + num;

          }else {

              return "0" + num;

          }*/

          return num > 9 ? "" + num : "0" + num;

      }

  }

如何获取任意年份是平年还是闰年（通过判断2月份的天数实现）

A:案例演示

  package com.yinglongwu.test;

  

  import java.util.Calendar;

  import java.util.Scanner;

  

  public class Test3 {

  

      /**

       * 需求：键盘录入任意一个年份，判断该年是闰年还是平年

       * Calendar c = Calendar.getInstance();

       * 

       * 分析:

       * 1,键盘录入年Scanner

       * 2,创建Calendar c = Calendar.getInstance();

       * 3,通过set方法设置为那一年的3月1日

       * 4,将日向前减去1

       * 5,判断日是多少天,如果是29天返回true否则返回false

       */

      public static void main(String[] args) {

          Scanner sc = new Scanner(System.in);

          System.out.println("请输入年份,判断该年份是闰年还是平年:");

          //int year = sc.nextInt();

          

          String line = sc.nextLine();                //录入数字字符串

          int year = Integer.parseInt(line);            //将数字字符串转换成数字

          boolean b = getYear(year);

          System.out.println(b);

      }

  

      private static boolean getYear(int year) {

          //2,创建Calendar c = Calendar.getInstance();

          Calendar c = Calendar.getInstance();

          //设置为那一年的3月1日

          c.set(year, 2, 1);    //月份是从0开始的

          //将日向前减去1

          c.add(Calendar.DAY_OF_MONTH, -1);

          //判断是否是29天

          return c.get(Calendar.DAY_OF_MONTH) == 29;

      }

  

  }

其他知识

无

码农公寓

javaEE学习第十四天

java知识

正则表达式的概述和简单使用

正则表达式预定义字符类演示

正则表达式数量词

正则表达式的分割功能

把给定字符串中的数字排序

正则表达式的分组功能

Pattern和Matcher的概述

正则表达式的获取功能

Math类概述和方法使用

Random类的概述和方法使用

System类的概述和方法使用

BigInteger类的概述和方法使用

BigDecimal类的概述和方法使用

Date类的概述和方法使用

Calendar类的概述和获取日期的方法

Calendar类的add()和set()方法

如何获取任意年份是平年还是闰年（通过判断2月份的天数实现）

其他知识

相关文章