String ,,StringBuffer,StringBuilder ,Math , Date

一， String 类的理解和创建对象

　　1.String 的说明

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

　　　　2）. 字符串常量对象是用双引号括起来的字符串序列。例如：“你好” “12.97”等

　　　　3）. 字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节

　　　　4.） String 类较常用的构造器（其它看手册）：

　　　　　　String s1 = new Strign();

　　　　　　String s1 = new Strign(String original);

　　　　　　String s1 = new Strign(char[] a);

　　　　　　String s1 = new Strign(char[] a , int startIndex, int count);

　　　　　　String s1 = new Strign();

　　　　　　String 实现了 Serializable ,说明String 可以串行化，串行化的意思是可以在网络上传输

　　　　　　String 实现了 Comparable ,说明String 对象可以比较

　　　　5）. String 类有很多构造器，构造器的重载

　　　　6）. String 类实现了接口 Serializable【String 可以串行化:可以在网络传输】接口 Comparable [String 对象可以比较大小]

　　　　7）. String 是 final 类，不能被其他的类继承

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

　　　　9).一定要注意：value 是一个 final 类型，不可以修改(需要功力)：即 value 不能指向新的地址，但是单个字符内容是可以变化

　　2. 创建 String 对象的两种方式

　　3. 两种创建 String 对象的区别

　　　　测试题

　　4. 字符串的特性

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

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

　　　5. String类常用的方法

　　　　　　String 类是保存字符串常量的，每次更新都需要重新开辟空间，效率低下，因此java设计者还提供了StringBuilder和 StringBuffer 来增强

　　String的功能，并提高效率。

　　　　　　String类的常见方法

　　　　　　equals 区分大小写，判断内容是否相等

　　　　　　equalslgnoreCase 忽略大小写判断内容是否相等

　　　　　　length 　　　　　　　　　　　　　　　　　　获取字符的个数，字符串的场地

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

　　　　　　lastLindexOf　　　　　　　　　　　　　　　获取字符在字符串中最后1次出现的索引，索引从0开始，如找不到，返回-1

　　　　　　substring 　　　　　　　　　　　　　　　　　获取指定字符串

　　　　　　trim 　　　　　　　　　　　　　　　　　　去前后空格

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

　　　　　 toUpperCase　　　　　　　　　　　　　　　　转换成大写

　　　　　 toLowerCase　　　　　　　　　　　　　　　　转换成小写

　　　　　　concat 　　　　　　　　　　　　　　　　　　拼接字符串 // s1 = "贾宝玉".concat("林岱依").concat("niahao");

　　　　　replace　　　　　　　　　　　　　　　　　　　　替换 String s1= s1.replace("宝玉", "jack");

　　　　　split　　　　　　　　　　　　　　　　　　　　　　分割字符

　　　　　toCharArray 　　　　　　　　　　　　　　　　转换成字符数组，然后遍历

　　　　　compareTo　　　　　　　　　　　　　　　　　　比较两个字符串的大小，如果前者大

　　　　format 　　　　　　　　　　　　　　　　　　　　格式字符串

public class String01 {
    public static void main(String[] args) {
//        %s  字符串 %c  字符 %d  整型 %.2f 浮点型
        String name = "john";
        int age = 10;
        double score = 56.857;
        char gender = '男';
        String info = "我的姓名是" + name + "年龄是" + age + ",成绩是" + score + "性别是" + gender + " 。希望大家喜欢我！ ";
        System.out.println(info);
        String formatStr = "我的姓名是%s  年龄是%d ，成绩是%.2f 性别是%c.希望大家喜欢我！";
        String info2 = String.format(formatStr, name, age, score, gender);
        System.out.println("info2=" + info2);
    }
}

　　5. StringBuffer类

　　　　基本介绍： java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删，很多方法与String相同，但StringBuffer是可变长度的

　　　　StringBuffer是一个容器

　　　　　　1). StringBuffer 的直接父类是 AbstractStringBuilder

　　　　　　2). StringBuffer 实现了 Serializable, 即 StringBuffer 的对象可以串行化

　　　　　　3). 在父类中 AbstractStringBuilder 有属性 char[] value,不是 final 该 value 数组存放字符串内容，引出存放在堆中的

　　　　　　4). StringBuffer 是一个 final 类，不能被继承

　　　　　　5). 因为 StringBuffer 字符内容是存在 char[] value, 所有在变化(增加/删除), 不用每次都更换地址(即不是每次创建新对象) ，所以效率高于 String

　　　　1>String VS StringBuffer

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

　　　　　　2)StringBuffer 保存的是字符串常量，里面的值可以更改，每次StringBuffer 的更新实际上可以更新内容，不用每次更新地址，效率较高

　　　　　　　　char [ ] value ;这个放在堆里

　　　2> String 和 StringBuffer 互相转化

public class StringBuffer01 {
    public static void main(String[] args) {
//        String ----> StringBuffer
        String  s1 = "hello tmo";
        //方式 1  使用构造器
        //注意：  返回的才是 StringBuffer 对象，对 str  本身没有影响
        StringBuffer stringBuffer = new StringBuffer(s1);
        //方式 2  使用的是 append 方法
        StringBuffer stringBuffer1 = new StringBuffer();
        stringBuffer1.append(s1);

        //看看 StringBuffer ->String
        StringBuffer stringBuffer2 = new StringBuffer("平博文");
        //方式 1  使用 StringBuffer 提供的 toString 方法
        String string = stringBuffer2.toString();
        //方式 2:  使用构造器来搞定
        String s = new String(stringBuffer2);
    }
}

　　　　3> StringBuffer 常见方法

　　　　　　1.）增 append

　　　　　　2）删 delete (start,eng)

　　　　　　3) 改 replace(start, end ,string) 将start ------------- end 间的内容替换掉，不包含end

　　　　　　4) 查 indexOf 查找子串在字符串第一次出现的索引，如果找不到就返回-1

　　　　　　5) 插 insert　　　　

　　　　　　6）获取长度 length

public class StringBuffer01 {
    public static void main(String[] args) {
        StringBuffer hello = new StringBuffer("hello");
        hello.append(",");   //增
        hello.append("张三丰").append("周芷若");
        System.out.println(hello);                      //hello,张三丰周芷若
        hello.delete(0,5);  //删
        System.out.println(hello);                      //,张三丰周芷若
        hello.replace(1,6,"我爱你");  //改
        System.out.println(hello);                      //,我爱你若
        int i = hello.indexOf("爱");  //查
        System.out.println(i);                          //  2
        hello.insert(5,"悟空"); //插
        System.out.println(hello);                      //,我爱你若悟空
        System.out.println(hello.length());             // 长度是 7
    }
}

　　　　经典练习题

public class StringBuffer01 {
    public static void main(String[] args) {
        String s1 = null;
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append(s1); //;//需要看源码 ,  底层调用的是 AbstractStringBuilder  的 appendNull
        System.out.println(stringBuffer.length());   //4
        System.out.println(stringBuffer); //null
        //底下代码抛出空指针异常
        StringBuffer stringBuffer1 = new StringBuffer(s1);//看底层源码 super(str.length() + 16);
        System.out.println(stringBuffer1);
    }
}

　　6， StringBuilder 类

　　基本介绍

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

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

　　StringBuilder常用方法

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

　　注意事项

　　　　1）. StringBuilder 继承 AbstractStringBuilder 类

　　　　2）. 实现了 Serializable ,说明 StringBuilder 对象是可以串行化(对象可以网络传输,可以保存到文件)

　　　　3）. StringBuilder 是 final 类, 不能被继承

　　　　4）. StringBuilder 对象字符序列仍然是存放在其父类 AbstractStringBuilder 的 char[] value; 因此，字符序列是堆中

　　　　5）. StringBuilder 的方法，没有做互斥的处理, 即没有 synchronized 关键字, 因此在单线程的情况下使用 StringBuilder

　　7. String, StringBuilder , StringBuffer 比较

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

　　　　　2） String : 不可变字符序列，效率低，但是复用性高

　　　　　3） StringBuffer : 可变字符序列，效率较高（增删），线程安全

　　　　　4）StringBuilder : 可变字符序列，效率最高，线程不安全

　　　　　5） String 使用注意说明“

　　　　　　String s = "a";//创建了一个字符串s += "b"; //实际上原来的"a" 字符串已经丢失，现在又产生一个字符串s + "b" (也就是“ab").

　　　　　　//如果多次执行了这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率，如果这样的操作放到循环当中，
　　　　　　//会爱称极大影响程序的性能，结论：如果我们对String做出大量修改，不要使用Sting

　　8. String 、StringBuffer 和 StringBuilder 的选择

　　9. String 、StringBuffer 和 StringBuilder 的效率测试

　　　　StringBuilder > StringBuffer > String

public class StringVsStringBufferVsStringBuilder {
    public static void main(String[] args) {  //StringBuffer 的执行时间：43StringBuilder 的执行时间：28
        long startTime = 0L;
        long endTime = 0L;
        StringBuffer buffer = new StringBuffer("");
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 80000; i++) {//StringBuffer  拼接 20000 次
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer 的执行时间：" + (endTime - startTime));

        StringBuilder builder = new StringBuilder("");
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 80000; i++) {//StringBuilder  拼接 20000 次
        builder.append(String.valueOf(i));
    }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder 的执行时间：" + (endTime - startTime));
        String text = "";
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 80000; i++) {//String  拼接 20000
        text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String 的执行时间：" + (endTime - startTime));
    }
}

二，　　Math 类

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

　　1. 方法均为静态方法

　　2.Math 常用的方法应用案例

public class MathMethod {
    public static void main(String[] args) {
        //看看 Math 常用的方法(静态方法)
        //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);//16
        //3.ceil  向上取整,返回>=该参数的最小整数(转成 double);
        double ceil = Math.ceil(3.9);
        System.out.println(ceil);//4.0
        //4.floor  向下取整，返回<=该参数的最大整数(转成 double)
        double floor = Math.floor(4.001);
        System.out.println(floor);//4.0
        //5.round  四舍五入  Math.floor(该参数+0.5)
        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 <= x < 1  之间的一个随机小数
        //  思考：请写出获取 a-b 之间的一个随机整数,a,b 均为整数 ，比如 a = 2, b=7
        //    即返回一个数 x    2 <= x <= 7
        //  老韩解读 Math.random() * (b-a)  返回的就是 0    <=  数 <= b-a
        // (1) (int)(a) <= x <= (int)(a + Math.random() * (b-a + 1) )
        // (2)  使用具体的数给小伙伴介绍 a = 2    b = 7
        //    (int)(a + Math.random() * (b-a + 1) ) = (int)( 2 + Math.random()*6)
        //    Math.random()*6  返回的是 0 <= x < 6  小数
        //    2 + Math.random()*6  返回的就是 2<= x < 8  小数
        //    (int)(2 + Math.random()*6) = 2 <= x <= 7
        // (3)  公式就是  (int)(a + Math.random() * (b-a + 1) )
        for(int i = 0; i < 100; i++) {
            System.out.println((int)(2 +    Math.random() * (7 - 2 + 1)));
        }
        //max , min  返回最大值和最小值
        int min = Math.min( 1, 9);
        int max = Math.max(45, 90);
        System.out.println("min=" + min);
        System.out.println("max=" + max);
    }
}

　　3. Arrays 类

　　　　Arrays里面包含了一系列静态方法，用于管理或操作数组（不如排序和搜索）

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

Integer[] integers = { 1, 20, 90};
        for (int i = 0; i < integers.length; i++) {
            System.out.println(integers[i]);   //1   20   90
        }
        System.out.println(Arrays.toString(integers));   //[1, 20, 90]

　　　　2). sort 排序（自然排序和定制排序）

　　　　　　Integer arr[] = { 1, - 1, 7, 0, 89};

　　　　　　Arrays.sort(arr);

　　　　　　System.out.println(Arrays.toString(arr)); // [-1, 0, 1, 7, 89]

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

　　　　　　　　Integer[] arr = { 1, 2, 90, 123, 567};

　　　　　　　　// binarySearch  通过二分搜索法进行查找，要求必须排好
　　　　　　　　//  要求该数组是有序的.  如果该数组是无序的，不能使用binarySearch
　　　　　　　　//如果数组中不存在该元素，就返回 return -(low + 1);    // key not found.
　　　　　　　　int index = Arrays.binarySearch(arr, 567);
　　　　　　　　System.out.println("index=" + index);    //index=4

　　　　4). copyOf 数组元素的复制

　　　　　　Integer[] arr = { 1, 2, 90, 123, 567};

　　　　　　//        从 arr  数组中，拷贝 arr.length 个元素到 newArr 数组中
　　　　　　//        如果拷贝的长度 > arr.length  就在新数组的后面 增加 null
　　　　　　//        如果拷贝长度 < 0  就抛出异常 NegativeArraySizeException
　　　　　　//        该方法的底层使用的是 System.arraycopy()
        　　Integer[] newArr = Arrays.copyOf(arr, arr.length);
        　　System.out.println("==拷贝执行完毕后==");
        　　System.out.println(Arrays.toString(newArr)); //[1, 2, 90, 123, 567]

　　　　5). fill 数组元素的填充

　　　　　　Integer[] num = new Integer[]{9,3,2};

　　　　　　//1.  使用 99  去填充 num 数组，可以理解成是替换原理的元素
　　　　　　Arrays.fill(num, 99);
　　　　　　System.out.println("==num 数组填充后==");
　　　　　　System.out.println(Arrays.toString(num));  //[99, 99, 99]

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

　　　　　　//equals 比较两个数组元素内容是否完全一致

　　　　　　Integer[] arr = { 1, 2, 90, 123};
　　　　　　Integer[] arr2 = { 1, 2, 90, 123};
　　　　　　//1.  如果 arr  和 arr2  数组的元素一样，则方法 true;
　　　　　　//2.  如果不是完全一样，就返回 false
　　　　　　boolean equals = Arrays.equals(arr, arr2);
　　　　　　System.out.println("equals=" + equals);   //equals=true

　　　　7). asList 将一组值，转换成 list

　　　　　　　//asList 将一组值，转换成 list

　　　　　　　　//1. asList 方法，会将 (2,3,4,5,6, 1)数据转成一个 List 集合
　　　　　　　　//2.  返回的 asList  编译类型 List(接口)
　　　　　　　　//3. asList  运行类型 java.util.Arrays#ArrayList,  是 Arrays 类的
　　　　　　　　// 静态内部类 private static class ArrayList<E> extends AbstractList<E>
　　　　　　　　//           implements RandomAccess, java.io.Serializable
　　　　　　　　List asList = Arrays.asList(2,3,4,5,6, 1);
　　　　　　　　System.out.println("asList=" + asList);   //asList=[2, 3, 4, 5, 6, 1]
　　　　　　　　System.out.println("asList 的运行类型" + asList.getClass());

　　4. System 类

　　　　1) exit 退出当前程序

　　　　　　　　System.out.println("ok 1");// ok 1 下面的输出语句不会输出

　　　　　　　　System.exit(0);
　　　　　　　　System.out.println("ok2");

　　　　2) arraycopy : 复制数组元素，比较适合底层调用，一般使用Arrays.copyOf 完成数组复制

　　　　　　int[] src = {1,2,3};

　　　　　　int [] dest = new int [3]

　　　　　　System.arraycopy(src,0,dest,0,3);

public class Arrays01 {
    public static void main(String[] args) {
        //arraycopy  ：复制数组元素，比较适合底层调用，
        //  一般使用 Arrays.copyOf 完成复制数组
        int[] src={1,2,3};
        int[] dest = new int[3];// dest  当前是 {0,0,0}
        System.arraycopy(src, 0, dest, 0, src.length);
        System.out.println("dest=" + Arrays.toString(dest));//[1, 2, 3]
    }
}

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

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

　　　　　　　　　　System.out.println(System.currentTimeMillis()); //1669945372429

　　　　4） gc : 运行垃圾回收机制 System.gc();

　　5. BigInteger 和 BigDecimal 类

public class BigInteger01 {
    public static void main(String[] args) {
        BigInteger b1 = new BigInteger("11111111111111111111111111111111111");
        BigInteger b2 = new BigInteger("2222222222222222222222222222222222222222");
        System.out.println(b1);
        System.out.println(b1.add(b2)); //加
        System.out.println(b1.subtract(b2)); //减
        System.out.println(b1.multiply(b2));  //乘法
        System.out.println(b1.divide(b2)); //除法
    }
}

public class BigDecimal {
    public static void main(String[] args) {
        double d = 1999.5555555555555555555555d;
        System.out.println(d);
        java.math.BigDecimal bigDecimal = new java.math.BigDecimal("1999. 11");
        java.math.BigDecimal bigDecimal2 = new java.math.BigDecimal("3");
        System.out.println(bigDecimal);
        //1.  如果对 BigDecimal 进行运算，比如加减乘除，需要使用对应的方法
        //2.  创建一个需要操作的 BigDecimal  然后调用相应的方法即可
        System.out.println(bigDecimal.add(bigDecimal2));
        System.out.println(bigDecimal.subtract(bigDecimal2));
        System.out.println(bigDecimal.multiply(bigDecimal2));
        //System.out.println(bigDecimal.divide(bigDecimal2));//可能抛出异常 ArithmeticException
        //在调用 divide  方法时，指定精度即可. BigDecimal.ROUND_CEILING
        //如果有无限循环小数，就会保留 分子 的精度
        System.out.println(bigDecimal.divide(bigDecimal2, java.math.BigDecimal.ROUND_CEILING));
    }
}

　　6. 日期类

　　　　1）第一代日期类

　　　　　　1》Date: 精确到毫秒，代表特定的瞬间

　　　　　　2》 SimpleDateFormat : 格式和解析日期的类SimpleDateFormat 格式化和解析日期的具体类，它允许进行格式化(日期 -> 文本），解析（文本-->日期）和规范化

public class Date01 {
    public static void main(String[] args) throws ParseException {
        Date date = new Date();
        System.out.println("现在的时间" + date);  //现在的时间Fri Dec 02 10:01:53 CST 2022
        Date d2 = new Date(9234567); //通过指定毫秒数得到时间
        System.out.println("d2=" + d2); //获取某个时间对应的毫秒数 d2=Thu Jan 01 10:33:54 CST 1970

        //1.  创建 SimpleDateFormat 对象，可以指定相应的格式
        //2.  这里的格式使用的字母是规定好，不能乱写
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy 年 MM 月 dd 日 hh:mm:ss E");
        String format = sdf.format(date); // format:将日期转换成指定格式的字符串
        System.out.println("当前日期=" + format); //当前日期=2022 年 12 月 02 日 10:04:02 星期五
    }
}

　　　　2) 第二代日期类 Calendar类（日历）

　　　　　　1》 public abstract calss Canlendar extends Object implenments Serializable , Comparable , Cloneable<Calendar>

　　　　　　2》 Canlendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR, MONTH, DAY OF MONTH , HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供一些方法。

　　　　　　3》 Calendar 是一个抽象类，并且构造器是 private

　　　　　　　　4》 可以通过 getInstance() 来获取实例

　　　　　　　　5》 提供大量的方法和字段提供给程序员

　　　　　　　　6》 Calendar 没有提供对应的格式化的类，因此需要程序员自己组合来输出(灵活)

　　　　　　　　7》 如果我们需要按照 24 小时进制来获取时间， Calendar.HOUR ==改成=> Calendar.HOUR_OF_DAY

public class Date01 {
    public static void main(String[] args) throws ParseException {
        Calendar c = Calendar.getInstance();
        System.out.println(c);
        //2.获取日历对象的某个日历字段
        System.out.println("年：" + c.get(Calendar.YEAR));   //年：2022
//  这里为什么要 + 1,  因为 Calendar  返回月时候，是按照 0  开始编号
        System.out.println("月：" + (c.get(Calendar.MONTH) + 1));   //月：12
        System.out.println("日：" + c.get(Calendar.DAY_OF_MONTH));   //日：2
        System.out.println("小时：" + c.get(Calendar.HOUR));     //小时：10
        System.out.println("分钟：" + c.get(Calendar.MINUTE));  // 分钟：40
        System.out.println("秒：" + c.get(Calendar.SECOND));   //秒：19
//Calender  没有专门的格式化方法，所以需要程序员自己来组合显示
        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) );
        //2022-12-2 10:40:19
    }

}

　　　3）第三代日期 LocalDate(日期/年月日） LocalDate(时间/时分秒） localDateTime(日期时间/年月日时分秒）JDK8加入的

　　　　　　LocalDate 只包含日期，可以获取日期字段

　　　　　　LocalDate　　只包含时间，可以获取时间字段

　　　　　　localDateTime 包含日期+ 时间可以获取日期和时间字段

　　　　前两代日期类的不足分析

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

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

　　　　　　2》偏移性：Date中的年份是从 1900年开始的，而月份都是从0开始的

　　　　　　3》格式化：格式化只对Date有用，Calendar 则不行

　　　　　　4》此外，他们也不是线程安全的；不能处理闰秒等

　　　　　　DateTimeFormatter 格式日期类

public class Date01 {
    public static void main(String[] args) throws ParseException {
        //1.  使用 now()  返回表示当前日期时间的 对象
        System.out.println(LocalDate.now());   //2022-12-02
        System.out.println(LocalTime.now());   // 11:01:33.587
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);  // 2022-12-02T11:01:33.587

        //2.  使用 DateTimeFormatter  对象来进行格式化
//  创建 DateTimeFormatter 对象
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String format = dateTimeFormatter.format(ldt);
        System.out.println("格式化的日期=" + format);  //格式化的日期=2022-12-02 11:09:42

        System.out.println("年=" + ldt.getYear());            //年=2022
        System.out.println("月=" + ldt.getMonth());          //月=DECEMBER
        System.out.println("月=" + ldt.getMonthValue());     //月=12
        System.out.println("日=" + ldt.getDayOfMonth());       //日=2
        System.out.println("时=" + ldt.getHour());          //时=11
        System.out.println("分=" + ldt.getMinute());             //分=5
        System.out.println("秒=" + ldt.getSecond());            //秒=26
    }
}

　　　　Instant 时间戳

 1 public class Date01 {
 2     public static void main(String[] args) throws ParseException {
 3         //1.通过 静态方法 now()  获取表示当前时间戳的对象
 4         Instant now = Instant.now();
 5         System.out.println(now);
 6         //2.  通过 from  可以把 Instant 转成 Date
 7         Date date = Date.from(now);
 8         //3.  通过 date 的 toInstant()  可以把 date  转成 Instant 对象
 9         Instant instant = date.toInstant();   //2022-12-02T03:13:31.812Z
10     }
11 }

　　　　　　第三代日期类更多方法

public class Date01 {
    public static void main(String[] args) throws ParseException {
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);  // 2022-12-02T11:01:33.587
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String format = dateTimeFormatter.format(ldt);
        System.out.println("格式化的日期=" + format);  //格式化的日期=2022-12-02 11:09:42
        //提供 plus  和 minus 方法可以对当前时间进行加或者
        // 看看 890 天后，是什么时候 把 年月日-时分秒
        LocalDateTime localDateTime = ldt.plusDays(890);
        System.out.println("890 天后=" + dateTimeFormatter.format(localDateTime));     //890 天后=2025-05-10 11:19:02

//看看在 3456 分钟前是什么时候，把 年月日-时分秒输出 
LocalDateTime localDateTime2 = ldt.minusMinutes(3456);
 System.out.println("3456 分钟前 日期=" + dateTimeFormatter.format(localDateTime2));  3456 分钟前 日期=2022-11-30 01:43:02  
 } 
}

public class StringBuider01 {
    public static void main(String[] args) throws ParseException {
        String time = "2022-12-04 12:03:39";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date parse = simpleDateFormat.parse(time);
        System.out.println(parse);  //Sun Dec 04 12:03:39 CST 2022
    }
}

public class DateDemo01 {
    public static void main(String[] args) {
        // 1.获取当前时间
        System.out.println(LocalDateTime.now());  //2022-12-05T08:03:32.437
        //2. 指定时分秒  获取LocalDateTime对象
        LocalDateTime of = LocalDateTime.of(2022, 12, 05, 07, 39, 45);
        System.out.println(of); //2022-12-05T07:39:45
        //3. 时间字符串转换成 LocalDateTime对象
        String strTime = "2022-12-05 07:32:56";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//        System.out.println(LocalTime.parse(strTime, formatter));
        System.out.println(LocalDateTime.parse(strTime, formatter));//2022-12-05T07:32:56
    }
}

posted @ 2022-12-02 11:22 阿文程序猿阅读(27) 评论(0) 收藏举报

刷新页面返回顶部

p1121

String ,,StringBuffer,StringBuilder ,Math , Date

公告