首页 > 其他 > 详细

常用类

时间:2021-05-04 14:15:52      阅读:18      评论:0      收藏:0      [点我收藏+]

常用类

包装类

  • 包装类分类 WrapperType.java

    1. 针对八种基本数据类型定义相应的引用类型-包装类

    2. 有了类的特点,就可以调用类中的方法

    3. 除了Boolean和Character,其他六个的父类都是Number

基本数据类型包装类
boolean Boolean
char Character
byte Byte
short Short
int Integer
long Long
float Float
double Double
  • 包装类和基本数据的转换

    1. jdk5前的手动装箱和拆箱方式,装箱:基本类型->包装类型,反之,拆箱

    2. jdk5以后(含jdk5)的自动装箱和拆箱方式

    3. 自动装箱底层调用的是valueOf方法

public static void main(String[] args) {
       //int<-->Integer的装箱和拆箱
       //手动装箱int->Integer
       int n1=100;
       Integer integer = new Integer(n1);
       Integer integer1 = Integer.valueOf(n1);
       //手动拆箱Integer->int
       int i=integer.intValue();
       //jdk5后,就可以自动装箱和拆箱
       //自动装箱int->Integer
       int n2=200;
       Integer integer2=n2;//底层使用的是Integer.valuOf(n2)
       //自动拆箱Integer->int
       int i1=integer2;//底层仍然使用的是intValue()方法
  }
  • 包装类型和String类型的相互转换

public static void main(String[] args) {
       //包装类(Integer)->String
       Integer i=100;//自动装箱
       //方式1
       String str1=i+"";
       //方式2
       String str2 = i.toString();
       //方式3
       String str3 = String.valueOf(i);
       //String->包装类(Integer)
       String str="12345";
       int i1 = Integer.parseInt(str);//使用到自动装箱
       Integer i2 = new Integer(str);//构造器
  }
  • Integer创建机制:

    1. 如果i在(-128~127),就直接从数组返回

    2. 如果不在(-128~127),就直接new Integer(i)

String类

  • String类的理解和创建对象

    1. String对象用于保存字符串,也就是一组字符序列

    2. 字符串常量对象是用双引号括起的字符序列。例:“12”,“你好”,"boy"等

    3. 字符串的字符使用Unicode字符编码,一个字符(不区分字母还是汉字)占两个字节

    4. String类较常用构造方法

    5. String类实现了接口Serializable[String可以串行化:可以在网络传输]

    6. String类实现了接口Comparable[String对象可以比较大小]

    7. String有属性private final char value[]; 用于存放字符串内容

    8. 一定要注意:value是一个final类型,不可以修改(不能指向新的地址,但是单个字符内容是可以变化)

  • 两种创建String对象的区别

  • 方式一:直接赋值String s="aw";

  • 方式二:调用构造器String s2=new String("aw");

    • 方式一:先从常量池查看是否有“aw”数据空间,如果有,直接指向;如果没有则呈现创建,然后指向。s最终指向的是常量池的空间地址

    • 方式二:先在堆中创建空间,里面维护了value属性,指向常量池的aw空间。如果常量池没有“aw”,重新创建,如果有,直接通过value指向。最终指向的是堆中的空间地址。

  • 字符串的特性

    1. String是一个final类,代表不可变的字符序列

    2. 字符串是不可变的。一个字符串对象一旦被分配,其内容是不可变的。

public static void main(String[] args) {
       String a="Hello";
       String b="abc";
       //1.先创建一个StringBuilder sb=new StringBuilder();
       //2.执行 sb.append("Hello");
       //3. sb.append("abc");
       //4.String c=sb.toString
       //最后其实是c指向堆中的对象(String)value[]->池中“helloabc”
       String c=a+b;
  }

底层是StringBuilder sb=new StringBuilder();sb.append(a); sb.append(b); sb是在堆中,并且append是在原来字符串的基础上追加的。

重要规则:String c1="ab"+"cd";常量相加,看的是池。String c1=a+b;变量相加,是在堆中。

String类常见方法

  • 说明

String类是保存字符串常量的。每次更新都需要重新开辟空间,效率较低,因此java设计者还提供了StringBuilderStringBuffer来增强Sting的功能,并提高效率

  • String类的常见方法一览

    • equals//区分大小写,判断内容是否相等

    • equalsIgnoreCase//忽略大小写的判断内容是否相等

    • length//获取字符的个数,字符串份长度

    • indexOf//获取字符串在字符串中第一次出现的索引,索引从0开始,如果找不到,返回-1

    • lastIndexOf//获取字符串在字符串中最后一次出现的索引,索引从0开始,如果找不到,返回-1

    • substring//截取指定范围的字符串

    • trim//去前后空格

    • charAt:获取某索引处的字符,注意不能使用Str[index]这种方式

    • toUpperCase:转换成大写

    • toLowerCase:转换成小写

    • concat//拼接字符串

    • replace//替换字符串中份字符

    • split//分割字符串,对于某些分割字符,我们需要转义 | \ \等

    • compareTo//比较两个字符串的大小

    • toCharArray//转换成字符数组

    • format//格式字符串,%s字符串,%c字符,%d整型,%.2f浮点型

        //- equals//区分大小写,判断内容是否相等
       String a="java";
       System.out.println("java".equals(a));
       //- equalsIgnoreCase//忽略大小写的判断内容是否相等
       String b="xml";
       System.out.println("XML".equalsIgnoreCase(b));
       //- length//获取字符的个数,字符串份长度
       System.out.println("money".length());
       //- indexOf//获取字符串在字符串中第一次出现的索引,索引从0开始,如果找不到,返回-1
       String s1="wyw@terwe@g";
       int index = s1.indexOf("@");
       System.out.println(index);
       //- lastIndexOf//获取字符串在字符串中最后一次出现的索引,索引从0开始,如果找不到,返回-1
       index = s1.lastIndexOf("@");
       System.out.println(index);
       //- substring//截取指定范围的字符串
       String name="hello,张三";
       System.out.println(name.substring(6));//截取后面的字符
       System.out.println(name.substring(0,5));//截取0到5前一个的
       //- toUpperCase:转换成大写
       System.out.println(name.toUpperCase());
       //- toLowerCase:转换成小写
       System.out.println(name.toLowerCase());
       //- concat//拼接字符串
       a="浊心";
       String c = a.concat("斯卡蒂");
       System.out.println(c);
       //- replace//替换字符串中份字符
       String li = name.replace("张三", "李四");
       System.out.println(li);
       //- split//分割字符串,对于某些分割字符,我们需要转义 | \ \等
       String poem="锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
       String[] split = poem.split(",");
       //1以,为标准对poem进行分割,返回一个数组
       //2在对字符串进行分割时,如果有特殊字符,需要加入转义符\
       poem="E:\\aaa\\bbb";
       split=poem.split("\\\\");
       for (String s : split) {
           System.out.println(s);
      }
       //- compareTo//比较两个字符串的大小,如果前者大,
       //则返回正数,后者大在,则返回负数,如果相等,返回0
       //(1)如果长度相同,并且每个字符也相同,就返回0
       //(2)如果长度相同或者不相同,但是在进行比较时,可以区分大小就返回
       //if(c1!=c2){
       //     return c1-c2;
       // }
       //(3)如果前面的部分都相同,就返回str1.Len-str2.Len
           a="jc";
           b="jack";
       System.out.println(a.compareTo(b));//返回值是c-a=2的值
       //- toCharArray//转换成字符数组
       a="happy";
       char[] chars = a.toCharArray();
       for (char aChar : chars) {
           System.out.println(aChar);
      }
       //- format//格式字符串,%s字符串,%c字符,%d整型,%.2f浮点型
       name="李四";
       int age=10;
       double score=98/3;
       char gender=‘男‘;
       String info="我们姓名是"+name+"年龄是"+age+"成绩是"+score+"性别是"+gender+"。希望大家喜欢我";
       System.out.println(info);
       //1%s,%d,%c,%.2f称为占位符
       //2这些占位符由后面变量来替换
       //3%s表示后面由字符串来替换
       //4%d是整数来替换
       //5%.2f表示使用小数来替换,替换后,只会保留小数点两位,并且进行四舍五入
       //6%c使用字符char来替换
       String formatStr="我的姓名是%s,年龄是%d,成绩是%.2f,性别是%c。希望大家喜欢我";
       String info2=String.format(formatStr,name,age,score,gender);
       System.out.println(info2);

StringBuffer类

  • 基本介绍

    • java.lang.StringBuffer代表可变的字符序列,可以对字符串内容进行增删

    • 很多方法与String相同,但StringBuffer是可变长度的

    • StringBuffer是一个容器

        //1.StringBuffer的直接父类是 AbstractStringBuffer
       //2.StringBuffer实现了Serializable,即StringBuffer的对象可以串行化
       //3.在父类中,AbstractStringBuffer有属性 char[] value,不是final
       //该 value 数组存放字符串内容,引出存放在堆中的
       //4.StringBuffer是一个final类,不能被继承
//5.因为StringBuffer字符内容存放在char[] value,所有在变化(增加/删除)
//不用每次都更换地址(即不是每次创建新对象),所以效率高于String
       StringBuffer buffer = new StringBuffer();
  • String VS StringBuffer

    1. String保存的是字符串常量,里面的值不能更改,每次String类的更新实际上就是更改地址,效率较低//private final char value[];

    2. StringBuffer保存的是字符串变量,里面的值可以更改,每次StringBuffer的更新实际上可以更新内容,不用更新地址,效率较高//char[] value; //这个放在堆

  • StringBuffer构造器的使用

    1. 创建一个大小为16的char[],用于存放字符内容

    2. 通过构造器指定char[] 大小

    3. 通过给一个String 创建StringBuffer

 //构造器的使用
       //1. 创建一个大小为16的char[],用于存放字符内容
       StringBuffer buffer = new StringBuffer();
       //2. 通过构造器指定char[] 大小
       StringBuffer buffer1 = new StringBuffer(100);
       //3. 通过给一个String 创建StringBuffer
       //这时候char[]的大小就是str.length()+16为21
       StringBuffer hello = new StringBuffer("hello");
  • String和StringBuffer相互转换

  //String->StringBuffer
       String str="hello zx";
       //方式1 使用构造器
       //注意:返回的才是StringBuffer对象,对str本身没有影响
       StringBuffer buffer = new StringBuffer(str);
       //方式2 使用的是append的方法
       StringBuffer buffer1 = new StringBuffer();
       buffer1.append(str);
       //StringBuffer->String
       StringBuffer buffer2 = new StringBuffer("歌蕾蒂娅");
       //方式1 使用StringBuffer提供的toString方法
       String string = buffer2.toString();
       //方式2 使用构造器
       String s = new String(buffer2);

StringBuffer类常见方法

  • StringBuffer方法一览

    1. append:增

    2. delete:删

    3. replace(start,end,string)//将start---end间的内容替换掉,不含end

    4. index//查找字符在字符串第一次出现的索引,如果查不到返回-1

    5. insert:插

    6. length:长度

    //1. append:增
   StringBuffer s = new StringBuffer("hello");
   s.append(",").append("凯尔希").append(100).append(true).append(10.5);
   System.out.println(s);
   //2. delete:删
   s.delete(9,12);//删除11-14的字符[9,12)
   System.out.println(s);
   //3. replace(start,end,string)//将start---end间的内容替换掉,不含end
   s.replace(6,9,"阿米娅");//替换6-9的字符[6,9)
   System.out.println(s);
   //4. indexOf//查找字符在字符串第一次出现的索引,如果查不到返回-1
   int i = s.indexOf(String.valueOf(100));
   System.out.println(i);
   //5. insert:插
   s.insert(9,"陈");//在索引为9的位置插入陈,true往后移
   System.out.println(s);
   //6. length:长度
   System.out.println(s.length());

StringBuilder类

  • 基本介绍

    1. StringBuilder是一个可变的字符序列。此类提供一个与StringBuffer兼容的API,但不保证同步(不是线程安全)。该类被设计用作StringBuffer的一个简易替换,用在字符串缓冲区被单个线程使用的时候。如果可能,建议优先采用该类,因为在大多数实现中,它比StringBuffer要快。

    2. 在StringBuilder上的主要操作是append和insert方法,可重载这些方法,以接受任意类型的数据。

  • StringBuilder常用方法

StringBuilder和StringBuffer均代表可变的字符序列,方法是一样的,所以使用和StringBuffer一样

    //1.StringBuilder 继承 AbstractStringBuilder
    //2.实现了Serializable,即StringBuilder的对象可以串行化(该对象可以网络传输,可以保存到文件)
    //3.在父类中,AbstractStringBuilder有属性 char[] value,不是final
    //该 value 数组存放字符串内容,引出存放在堆中的
    //4.StringBuilder是一个final类,不能被继承
    //5.StringBuilder的方法,没有做互斥的处理,即没有synchronized关键字,因此在单线程的情况下使用
	StringBuilder stringBuilder = new StringBuilder();
  • String、StringBuffer和StringBuilder的比较

    1. StringBuilder和StringBuffer非常类似,均代表可变的字符序列,而且方法也一样

    2. String:不可变字符序列,效率低,但是复用率高

    3. StringBuffer:可变字符序列,效率较高(增删)、线程安全

    4. StringBuilder:可变字符序列,效率最高、线程不安全

    5. String使用注意说明:

      • string s="a";//创建了一个字符串

      • s+=“b”;//实际上原来的"a"字符串对象已经丢弃了,现在又产生了一个字符串s+"b"(也就是"ab")。如果多次执行这些字符串内容的操作,会导致大量副本字符串对象存留在内存中,降低效率。如果这样的操作放到循环中,会极大影响程序的性能=>结论:如果我们对字符串做大量修改,不要使用String

  • String、StringBuffer和StringBuilder的选择

    1. 如果字符串存在大量的修改操作,一般使用StringBuffer或StringBuilder

    2. 如果字符串存在大量的修改操作,并在单线程的情况,使用StringBuilder

    3. 如果字符串存在大量的修改操作,并在多线程的情况,使用StringBuffer

    4. 如果我们字符串很少修改,被多个对象引用,使用String,比如配置信息等

Math类

  • 基本介绍

Math类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。

  • Math常见方法

    1. abs:绝对值

    2. pow:求幂

    3. ceil:向上取整

    4. floor:向下取整

    5. round:四舍五入

    6. sqrt:求开方

    7. random:求随机数

    8. max:求两个数的最大值

    9. min:求两个数的最小值

        //1. abs:绝对值
        int abs=Math.abs(-9);
        System.out.println(abs);//9
        //2. pow:求幂
        double pow = Math.pow(2, 4);//2的4次方
        System.out.println(pow);//6
        //3. ceil:向上取整,返回>=该参数的最小整数(转成double)
        double ceil = Math.ceil(-3.0001);
        System.out.println(ceil);//-3.0
        //4. floor:向下取整,返回<=该参数的最小整数(转成double)
        double floor = Math.floor(-4.999);
        System.out.println(floor);//-5.0
        //5. round:四舍五入
        long round = Math.round(5.51);
        System.out.println(round);//6
        //6. sqrt:求开方
        double sqrt = Math.sqrt(9.0);
        System.out.println(sqrt);//3.0
        //7. random:求随机数
        //random返回的是0<=a<1之间的一个随机小数
        //获取一个a-b之间的一个随机整数
        //int num=(int)(a+Math.random()*(b-a+1))
        //8. max:求两个数的最大值
        int max = Math.max(1, 9);
        System.out.println(max);//9
        //9. min:求两个数的最小值
        int min = Math.min(1, 9);
        System.out.println(min);//1

Arrays类

  • Arrays里面包含了一系列静态方法,用于管理或操作数组(比如排序和搜索)

    1. toString:返回数组的字符串形式

    2. sort:排序(自然排序和定制排序)

    3. binarySearch:通过二分搜索法进行查找,要求必须排好序

    4. copyOf:数组元素的复制

    5. fill:数组元素的填充

    6. equals:比较两个数组元素的内容是否完全一致

    7. asList:将一组值,转换成list

    	Integer[] integers={1,20,90,7,60};
        // toString:返回数组的字符串形式
        System.out.println(Arrays.toString(integers));
        // sort:排序(自然排序和定制排序)
        //1.可以直接使用冒泡排序,也可以直接使用Arrays提供的sort方法排序
        //2.因为数组是引用类型,所以通过sort排序后,会直接影响到实参
        //3.sort是重载的,也可以通过传入一个接口Comparator实现定制排序
        //4.调用定制方法时,传入两个参数(1)排序的数组
        // (2)实现了Comparator接口的匿名内部类,要求实现compare方法
        //5.这里体现了接口编程的方式
        Arrays.sort(integers);//默认排序方法
        //定制排序
        Arrays.sort(integers, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                Integer i1=(Integer) o1;
                Integer i2=(Integer) o2;
                return i2-i1;
            }
        });
        System.out.println(Arrays.toString(integers));
        // binarySearch:通过二分搜索法进行查找,要求必须排好序
        //1.使用binarySearch二叉查找
        //2.要求该数组是有序的,如果该数组是无序的,不能使用
        //3.如果数组中不存在该元素,就返回-1
        Integer[] arr={1,2,9,123,567};
        int index = Arrays.binarySearch(arr, 9);
        System.out.println(index);
        // copyOf:数组元素的复制
        //1.从arr数组中,拷贝arr.length个元素到newarr数组中
        //2.如果拷贝的长度>arr.length就在新数组的后面增加null
        //3.如果拷贝长度<0就抛出异常
        Integer[] newarr = Arrays.copyOf(arr, 6);
        System.out.println(Arrays.toString(newarr));
        // fill:数组元素的填充
        //使用99区填充newarr数组,可以理解成是替换原理的元素
        Arrays.fill(newarr, 99);
        System.out.println(Arrays.toString(newarr));
        // equals:比较两个数组元素的内容是否完全一致
        //1.如果arr和newarr数组的元素一样,则返回true
        //2.如果不是完全一样就返回false
        boolean equals = Arrays.equals(arr, newarr);
        System.out.println(equals);
        // asList:将一组值,转换成list
        List<Integer> list = Arrays.asList(arr);
        System.out.println(list);

System类

  • System类常见方法

    1. exit:退出当前程序

    2. arraycopy:复制数组元素,比较适合底层调用,一般使用

    3. currentTimeMillens:返回当前时间距离1970-1-1的毫秒数

    4. gc:运行垃圾回收机制

  // exit:退出当前程序
        System.out.println("ok1");
        //1.exit(0)表示程序退出
        //2.0表示一个状态,正常的状态
        //3.0以外的整数表示非正常退出
        //System.exit(0);
        System.out.println("ok2");
        // arraycopy:复制数组元素,比较适合底层调用,一般使用
        int[] src={1,2,3};
        int[] dest=new int[3];//dest当前是{0,0,0}
        //第一个:源数组
        //第二个:从原数组的哪个索引位置开始拷贝
        //第三个:目标数组,即把源数组的数据拷贝到哪个数组
        //第四个:把源数组的数据拷贝到目标数组的哪个索引
        //第五个:从源数组拷贝多少个数据到目标数组
        System.arraycopy(src,0,dest,0,3);
        System.out.println(Arrays.toString(dest));
        // currentTimeMillens:返回当前时间距离1970-1-1的毫秒数
        System.out.println(System.currentTimeMillis());
        // gc:运行垃圾回收机制
        System.gc();//主动调用垃圾回收器

BigInteger和BigDecimal类

  • BigInteger和BigDecimal介绍

    1. BigInteger适合保存比较大的整型

    2. BigDecimal适合保存精度更高的浮点型

  • BigInteger和BigDecimal常见方法

    1. add:加

    2. subtract:减

    3. multiply:乘

    4. divide:除

 //当我们编程中,需要处理很大的整数,long不够用
        //可以使用BigInteger的类来搞定
        // long l=2378999999999999999l;
        //System.out.println(l);
        BigInteger bigInteger = new BigInteger("29999999999999999999999999999999999999999999999999");
        System.out.println(bigInteger);
        //1.在堆BigInteger进行加减乘除的时候,需要使用对应的方法,不能+-*/
        //2.可以创建一个要操作的BigInteger然后进行相应操作
        //add:加
        BigInteger bigInteger1 = new BigInteger("100");
        BigInteger add = bigInteger.add(bigInteger1);
        System.out.println(add);
        // subtract:减
        BigInteger subtract = bigInteger.subtract(BigInteger.valueOf(200));
        System.out.println(subtract);
        // multiply:乘
        BigInteger multiply = bigInteger.multiply(BigInteger.valueOf(30));
        System.out.println(multiply);
        // divide:除
        BigInteger divide = bigInteger.divide(BigInteger.valueOf(500));
        System.out.println(divide);
 //当我们编程中,需要保存一个精度很高的数时,double不够
        //可以使用BigDecimal的类来搞定
        // double d=199.13316186446156135131315311d;
        //System.out.println(d);
        BigDecimal bigDecimal = new BigDecimal("199.13316186446156135131315311");
        System.out.println(bigDecimal);
        //1.如果对BigDecimal进行运算,比如加减乘除,需要使用对应的方法
        //2.可以创建一个要操作的BigDecimal然后进行相应操作
        //add:加
        System.out.println(bigDecimal.add(BigDecimal.valueOf(100)));
        // subtract:减
        System.out.println(bigDecimal.subtract(BigDecimal.valueOf(200)));
        // multiply:乘
        System.out.println(bigDecimal.multiply(BigDecimal.valueOf(500)));
        // divide:除
        //System.out.println(bigDecimal.divide(BigDecimal.valueOf(200)));//可能抛出异常AritimeticException
        //在调用divide方法时,指定精度即可。bigDecimal.ROUND_CEILING
        //如果有无限循环小数,就会保留分子的精度
        System.out.println(bigDecimal.divide(BigDecimal.valueOf(200),bigDecimal.ROUND_CEILING));

日期类

  • 第一代日期类

    1. Date:精确到毫秒,代表特定的瞬间

    2. SimpleDateFormat:格式和解析日期的类。它允许进行格式化(日期->文本->)、解析(文本->日期)和规范化

 		//1.获取当前系统时间
        //2.这里的Date类是在java.util包
        //3.默认输出的日期格式是国外的方式,因此通常需要对格式进行转换
        Date date = new Date();
        System.out.println(date);
        Date date1 = new Date(912345678);//通过指定毫秒数得到时间
        System.out.println(date1);//获取某个时间对应的毫秒数
        //1.创建SimpleDateFormat对象,可以指定相应的格式
        //2.这里的格式使用的字母是规定好的,不能乱写
        SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E");
        String time = format.format(date);//format:将日期转换成指定格式的字符串
        System.out.println(time);
        //可以把一个格式化的String转成对应的Date
        //2.得到Date仍然是按照国外的格式,如果希望zhid格式输出,需要转换
        //3.在把String->Date,使用format格式需要和你给的String的格式一样,否则会抛出转换异常
        String s="2021年01月01日 10:30:50 星期一";
        Date parse = format.parse(s);
        System.out.println(format.format(parse));
  • 第二代日期类

    1. 第二代日期类,主要就是Calendar类(日历)

    2. Calendar类是一个抽象类,它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法,并为操作日历字段(例如获取下星期的日期)提供了一些方法

        //1.Calendar是一个抽象类,并且构造器是private
        //2.可以通过getInstance()来获取实例
        //3.提供大量的方法和字段提供给程序员
        //4.Calendar没有提供对应的格式化的类,因此需要程序员自己组合来输出
		//5.如果我们需要按照24小时进制来获取时间,Calendar.HOUR=>Calendar.HOUR_OF_DAY
        Calendar c = Calendar.getInstance();//创建日历类对象
        System.out.println(c);
        //获取日历对象的某个日历字段
        System.out.println("年:"+c.get(Calendar.YEAR));
        System.out.println("月:"+(c.get(Calendar.MONTH)+1));//因为Calendar返回月时候,是按照0开始编号
        System.out.println("日:"+c.get(Calendar.DAY_OF_MONTH));
        System.out.println("小时:"+c.get(Calendar.HOUR));
        System.out.println("分钟:"+c.get(Calendar.MINUTE));
        System.out.println("秒:"+c.get(Calendar.SECOND));
        System.out.println(c.get(Calendar.YEAR)+"/"+(c.get(Calendar.MONTH)+1)+"/"+c.get(Calendar.DAY_OF_MONTH)
                +" "+c.get(Calendar.HOUR_OF_DAY)+":"+c.get(Calendar.MINUTE)+":"+c.get(Calendar.SECOND));
  • 第三代日期类

前面两代日期类的不足分析

JDK1.0只包含了一个java.util.Date类,但是它的大多数方法已经在JDK1.1引入Calendar类之后被弃用了。而Calendar也存在问题是:

  1. 可变性:像日期和时间这样的类应该是不可变的

  2. 偏移性:Date中的年份是从1900开始的,而月份都从0开始

  3. 格式化:格式化只对Date有用,Calendar则不行

  4. 此外,它们也不是线程安全的;不能处理闰秒等(每隔两天,多出1s)

  • 第三代日期类常见方法

    1. LocalDate(日期/年月日)、LocalTime(时间/时分秒)、LocalDateTime(日期时间/年月日)JDK8加入

     //使用now()返回表示当前日期时间的对象
            LocalDateTime now = LocalDateTime.now();
            System.out.println(now);
            System.out.println("年:"+now.getYear());
            System.out.println("月:"+now.getMonth());//英文的分
            System.out.println("月:"+now.getMonthValue());
            System.out.println("日:"+now.getDayOfMonth());
            System.out.println("时:"+now.getHour());
            System.out.println("分:"+now.getMinute());
            System.out.println("秒:"+now.getSecond());
            LocalDate now1 = LocalDate.now();//可以获取年月日
            LocalTime now2 = LocalTime.now();//可以获取时分秒
    
    1. DateTimeFormatter格式日期类

    类似于SimpleDateFormat

            //1.使用now()返回表示当前日期时间的对象
            LocalDateTime now = LocalDateTime.now();
            System.out.println(now);
           //2.使用DateTimeFormatter对象来格式化
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
            String format = dateTimeFormatter.format(now);
            System.out.println(format);
    
    1. Instant时间戳

    类似于Date,提供了一系列和Date类转换的方式

       		//1.通过静态方法now()获取表示当前时间戳的对象
            Instant now = Instant.now();
            System.out.println(now);
            //2.通过from可以把Instant转成Date
            Date date = Date.from(now);
            //3.通过date的toInstant()可以把date转成Instant对象
            Instant instant = date.toInstant();
    
    1. 第三代日期类更多方法

    • LocalDateTime类

    • MonthDay类:检查重复事件

    • 是否为闰年

    • 增加日期的某个部分

    • 使用plus方法测试增加时间的某个部分

    • 使用minus方法测试查看一年前和一年后的日期

    		LocalDateTime now = LocalDateTime.now();
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
            //提供plus和minus方法可以把当前时间进行加或者减
            //看看900天后,是什么时候把年月日-时分秒
            LocalDateTime localDateTime = now.plusDays(900);
            System.out.println(dateTimeFormatter.format(localDateTime));
            //看看3456分钟前是什么时候,把年月日-时分秒输出
            LocalDateTime localDateTime1 = now.minusMinutes(3456);
            System.out.println(dateTimeFormatter.format(localDateTime1));
    

     

     

     

  •  

 

常用类

原文:https://www.cnblogs.com/wzhdyyz/p/14729262.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!