Java高级部分笔记之常用类

最新推荐文章于 2024-07-18 20:13:39 发布

愤怒且自私22

最新推荐文章于 2024-07-18 20:13:39 发布

阅读量72

点赞数

分类专栏： Java学习笔记文章标签： java

本文链接：https://blog.csdn.net/qq_33317597/article/details/119024028

版权

Java学习笔记专栏收录该内容

18 篇文章 0 订阅

订阅专栏

Java常用类

字符串相关的类

String的特性

String类：代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。

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

字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改。

String对象的字符内容是存储在一个字符数组value[]中的。

package com.test.java;

import org.junit.Test;

/*
    String的使用


 */
public class StringTest {
    /*
        String: 字符串，使用一对""引起来表示。
        1、String声明为final的，不可被继承
        2、String实现了Serializable接口:
                表示字符串是支持序列化的。
                 实现了Comparable接口: 表示String可以比较大小
        3、String内部定义了final char[] value用于存储字符串数据

        4、String:代表不可变的字符序列.简称:不可变性。
                体现:
                    1、当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
                    2、当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能在原有的value进行赋值。
                    3、当调用String的replace()方法修改指定的字符或字符串，也需要重新指定内存区域赋值，不能在原有的value进行赋值。
       5、通过字面量的方式(区别于new)给一个字符串赋值，此时的字符串值声明在字符串常量池中。

       6、字符串常量池中是不会存储相同内容的字符串的。
     */
    @Test
    public void test1(){
        String s1 = "abc";//字面量的定义方式
        String s2 = "abc";
        //s1="hello";

        System.out.println(s1 == s2);//比较s1和s2的地址值
        System.out.println(s1);//hello
        System.out.println(s2);//abc

        System.out.println("***********************");
        String s3 = "abc";
        s3 += "def";

        System.out.println(s3);//abcdef

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


        String s4 = "abc";
       String s5 =  s4.replace('a','m');
        System.out.println(s4);
        System.out.println(s5);

    }

}

请添加图片描述

String不同实例化方式的对比

String str = "hello"; 

//本质上this.value = new char[0]; 

String s1 = new String();  

//this.value = original.value; 

String s2 = new String(String original);  

//this.value = Arrays.copyOf(value, value.length); 

String s3 = new String(char[] a);  

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

String str1 = “abc”;和String str2 = new String(“abc”);的区别

字符串常量存储在字符串常量池，目的是共享
字符串非常量对象存储在堆中。

请添加图片描述

package com.test.java;

import org.junit.Test;

/*
    String的使用

    面试题:
        String s = new String("abc");方式创建对象，在内存中创建了几个对象？
        两个: 一个是堆空间中new 结构，另一个是char[]对应的常量池中的数据: "abc"
        

 */
public class StringTest {


    /*
    String 的实例化方式:
        方式一: 通过字面量定义的方式
        方式二: 通过new + 构造器的方式


     */
    @Test
    public void test2(){

        //通过字面量定义的方式: 此时的s1和s2的数据JavaEE声明在方法区中的字符串常量池中。

        String s1 = "JavaEE";
        String s2 = "JavaEE";

        //通过new + 构造器的方式: 此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
        String s3 = new String("JavaEE");
        String s4 = new String("JavaEE");

        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
        System.out.println(s1 == s4);//false
        System.out.println(s3 == s4);//false


        System.out.println("******************");
        Person p1 = new Person("Tom", 12);
        Person p2 = new Person("Tom", 12);

        System.out.println(p1.name.equals(p2.name));//true
        System.out.println(p1.name == p2.name);//true

        p1.name = "Jerry";
        System.out.println(p2.name);
    }



    /*
        String: 字符串，使用一对""引起来表示。
        1、String声明为final的，不可被继承
        2、String实现了Serializable接口:
                表示字符串是支持序列化的。
                 实现了Comparable接口: 表示String可以比较大小
        3、String内部定义了final char[] value用于存储字符串数据

        4、String:代表不可变的字符序列.简称:不可变性。
                体现:
                    1、当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
                    2、当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能在原有的value进行赋值。
                    3、当调用String的replace()方法修改指定的字符或字符串，也需要重新指定内存区域赋值，不能在原有的value进行赋值。
       5、通过字面量的方式(区别于new)给一个字符串赋值，此时的字符串值声明在字符串常量池中。

       6、字符串常量池中是不会存储相同内容的字符串的。
     */



    @Test
    public void test1(){
        String s1 = "abc";//字面量的定义方式
        String s2 = "abc";
        //s1="hello";

        System.out.println(s1 == s2);//比较s1和s2的地址值
        System.out.println(s1);//hello
        System.out.println(s2);//abc

        System.out.println("***********************");
        String s3 = "abc";
        s3 += "def";

        System.out.println(s3);//abcdef

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


        String s4 = "abc";
       String s5 =  s4.replace('a','m');
        System.out.println(s4);
        System.out.println(s5);

    }

}

String不同拼接操作的对比

 /*

        结论:
           1 常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
           2 只要其中有一个是变量，结果就在堆中
           3 如果拼接的结果调用intern()方法，返回值就在常量池中

     */
    @Test
    public void test3(){
        String s1 = "javaEE";
        String s2 = "hadoop";

        String s3 = "javaEEhadoop";
        String s4 = "jvaEE"+"hadoop";

        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;



        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);
        System.out.println(s3 == s6);
        System.out.println(s5 == s6);
        System.out.println(s5 == s7);
        System.out.println(s6 == s7);

        //
        String s8 = s5.intern();//返回得到的s8使用的常量池中已经存在的"javaEEhadoop"
        System.out.println(s3 == s8);//true
    }

JVM中涉及字符串的内存结构

String常用方法

package com.test.java;

import org.junit.Test;

import java.util.Locale;


public class StringMethodTest {
    /*
        替换:
        String replace(char oldChar, char newChar)：返回一个新的字符串，它是
        通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
         String replace(CharSequence target, CharSequence replacement)：使
        用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
         String replaceAll(String regex, String replacement) ： 使 用 给 定 的
        replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
         String replaceFirst(String regex, String replacement) ： 使 用 给 定 的
        replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。

        匹配:
         boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。

        切片:
        String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
         String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此
        字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。
     */
    @Test
    public void test4(){
        String str1 = "HelloWorldHello";
        System.out.println(str1);
        System.out.println(str1.replace('H', 'h'));


        System.out.println(str1.replace("Hello", "bye"));
    }

/*
    boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
     boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
     boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的
    子字符串是否以指定前缀开始


     boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列
    时，返回 true
     int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
     int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出
    现处的索引，从指定的索引开始
     int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
     int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后
    一次出现处的索引，从指定的索引开始反向搜索
    注：indexOf和lastIndexOf方法如果未找到都是返回-1

 */
    @Test
    public void test3(){
        String str1 = "helloworld";

        boolean b1 = str1.endsWith("ld");
        System.out.println(b1);//true


        boolean b2 = str1.startsWith("he");
        System.out.println(b2);//true


        boolean b3 = str1.startsWith("ll",2);
        System.out.println(b2);//true

        String str2 = "wo";
        System.out.println(str1.contains(str2));


        System.out.println(str1.indexOf("lo"));//3

        System.out.println(str1.indexOf("lol"));//-1

        System.out.println(str1.indexOf("lo", 5));


        String str3 = "hhhorwworll";
        System.out.println(str3.lastIndexOf("or"));

        System.out.println(str3.lastIndexOf("or",6));

        //什么情况下，indexOf(str) 和 lastIndexOf(str)返回值相同？
        //情况一，存在唯一的一个str.情况二: 不存在str

    }

    /*
        int length()：返回字符串的长度： return value.length
         char charAt(int index)： 返回某索引处的字符return value[index]
         boolean isEmpty()：判断是否是空字符串：return value.length == 0
         String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写
         String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写
         String trim()：返回字符串的副本，忽略前导空白和尾部空白
         boolean equals(Object obj)：比较字符串的内容是否相同
         boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大
        小写
         String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+”
         int compareTo(String anotherString)：比较两个字符串的大小
         String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从
        beginIndex开始截取到最后的一个子字符串。
         String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字
        符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。

 */
    @Test
    public void test2(){
        String s1 = "HelloWorld";

        String s2 = "helloworld";

        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2));//true

        String s3 = "abc";
        String s4 = s3.concat("def");
        System.out.println(s4);//abcdef

        String s5 = "abc";
        String s6 = new String("abe");
        //涉及到字符串排序
        System.out.println(s5.compareTo(s6));//-2


        String s7 = "abcdef";
        String s8 = s7.substring(2);
        System.out.println(s7);//abcdef
        System.out.println(s8);//cdef

        String s9 = s7.substring(2, 5);
        System.out.println(s9);//cde
    }


    @Test
    public void test1(){
        String s1 = "HelloWorld";

        System.out.println(s1.length());//10

        System.out.println(s1.charAt(0));//h

        System.out.println(s1.isEmpty());//false

        System.out.println(s1.toLowerCase(Locale.ROOT));//改成小写以后的字符串
        System.out.println(s1);//s1不可变的，仍然是原来的字符串

        String s3 = "  he  llo  world ";

        String s4 = s3.trim();
        System.out.println(s3);
        System.out.println(s4);
    }

}

String和char[]或byte[]转换

package com.test.java;

import org.junit.Test;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class StringTest1 {


    /*
        String 与 byte[] 之间的转换
        编码:String ---> byte[]: 调用String的getBytes()
        解码: byte[] ---> String :  调用String的构造器

        编码: 字符串 --->字节 (看得懂 ---> 看不懂的二进制数据)
        解码: 编码的逆过程，字节---> 字符串（看不懂的二进制数据 ---> 看得懂 ）

        说明: 解码时，要求解码使用的字符集必须与编码时使用的字符集一致。
     */
    @Test
    public void test3() throws UnsupportedEncodingException {
        String str1 = "abc123中国";

        byte[] bytes = str1.getBytes();//使用默认的字符集，进行编码

        System.out.println(Arrays.toString(bytes));//[97, 98, 99, 49, 50, 51, -28, -72, -83, -27, -101, -67]

        byte[] gbks = str1.getBytes("gbk");//使用GBK字符集，进行转换

        System.out.println(Arrays.toString(gbks));//[97, 98, 99, 49, 50, 51, -42, -48, -71, -6]


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

        String str2 =  new String(bytes);//使用默认的字符集，进行解码

        System.out.println(str2);


        String str3 = new String(gbks);
        System.out.println(str3);//出现乱码。原因:编码集和解码集不一致！

        String str4 = new String(gbks,"gbk");
        System.out.println(str4);//没有出现乱码。原因:编码集和解码集一致！
    }


    /*
        String 与 char[] 之间的转换

        String ---> char[] : 调用String 的 toCharArray()
        char[] ---> String: 调用String的构造器
     */
    @Test
    public void test2(){
        String str1 = "abc123";

        char[] charArray = str1.toCharArray();

        for (int i = 0; i < charArray.length; i++) {
            System.out.println(charArray[i]);
        }

        char[] arr = new char[]{'h','e','l','l','o'};
        String str2 = new String(arr);
        System.out.println(str2);

    }

}

解决一个拼接小问题

    /*

        结论:
           1 常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
           2 只要其中有一个是变量，结果就在堆中
           3 如果拼接的结果调用intern()方法，返回值就在常量池中

     */
	@Test
    public void test4(){
        String s1 = "javaEEhadoop";
        String s2 = "javaEE";
        String s3 = s2 + "hadhoop";
        System.out.println(s1 == s3);


        final String s4 = "javaEE";//s4:常量
        String s5 = s4 + "hadhoop";
        System.out.println(s1 == s5);//true
    }

关于StringBuffer 和 StringBuilder的使用

package com.test.java;

import org.junit.Test;

/*
    关于StringBuffer 和 StringBuilder的使用

 */
public class StringBufferBuilderTest {
    /*
        String、StringBuffer、StringBuilder三者的异同？
            String: 不可变的字符序列；底层使用char[]存储
            StringBuffer: 可变的字符序列;线程安全的，效率低；底层使用char[]存储
            StringBuilder: 可变的字符序列;jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储


        源码分析:
            String str = new String();//char[] value = new char[0];
            String str1 = new String("abc");//char[] value = new char[]{'a','b','c'}

            StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组。
            System.out.println(sb1.length());//0!!!!!!


            sb1.append('a');//value[0] = 'a';
            sb1.append('b');//value[1] = 'b';

             StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length()+16];

            //问题1. System.out.println(sb2.length());//3

            //问题2. 扩容问题: 如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
                    默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中元素复制到新的数组中。

                    append()
                    开发中建议大家使用: StringBuffer(int capacity)
                    或 StringBuilder(int capacity)
            //
     */

    @Test
    public void test1(){
        StringBuffer sb1 = new StringBuffer("abc");
        sb1.setCharAt(0,'m');
        System.out.println(sb1);

    }






}

一些常用方法

package com.test.java;

import org.junit.Test;

/*
    关于StringBuffer 和 StringBuilder的使用

 */
public class StringBufferBuilderTest {
    /*
        


     */

    /*
    StringBuffer的常用方法:
        StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
        StringBuffer delete(int start,int end)：删除指定位置的内容
        StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str
        StringBuffer insert(int offset, xxx)：在指定位置插入xxx
        StringBuffer reverse() ：把当前字符序列逆转

        public int indexOf(String str)
        public String substring(int start,int end);返回一个从start开始到end索引结束的左闭右开区间的子字符串
        public int length()
        public char charAt(int n )
        public void setCharAt(int n ,char ch)

        总结:
        增: append(xxx)  方法链
        删: delete(int start,int end)
        改: setCharAt(int n ,char ch)/replace(int start, int end, String str)

        查: charAt(int n )
        插:  insert(int offset, xxx)
        长度:  length()
        遍历: for() + charAt() / toString()
     */
        @Test
        public void test2(){
            StringBuffer s1 = new StringBuffer("abc");
            s1.append(1);
            s1.append('1');
            System.out.println(s1);

       //     s1.delete(2,4);
       //     s1.replace(2,4,"hello");
  //          s1.insert(2,false);

        //    s1.reverse();

            s1.substring(1,3);
            System.out.println(s1);
            System.out.println(s1.length());//10




        }


    /*
        String、StringBuffer、StringBuilder三者的异同？
            String: 不可变的字符序列；底层使用char[]存储
            StringBuffer: 可变的字符序列;线程安全的，效率低；底层使用char[]存储
            StringBuilder: 可变的字符序列;jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储


        源码分析:
            String str = new String();//char[] value = new char[0];
            String str1 = new String("abc");//char[] value = new char[]{'a','b','c'}

            StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组。
            System.out.println(sb1.length());//0!!!!!!


            sb1.append('a');//value[0] = 'a';
            sb1.append('b');//value[1] = 'b';

             StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length()+16];

            //问题1. System.out.println(sb2.length());//3

            //问题2. 扩容问题: 如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
                    默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中元素复制到新的数组中。

                    append()
                    开发中建议大家使用: StringBuffer(int capacity)
                    或 StringBuilder(int capacity)
            //
     */

    @Test
    public void test1(){
        StringBuffer sb1 = new StringBuffer("abc");
        sb1.setCharAt(0,'m');
        System.out.println(sb1);

    }






}

JDK 8 之前日期时间API

1、java.lang.System类

System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。

此方法适于计算时间差。

2、java.util.Date类

表示特定的瞬间，精确到毫秒

package com.test.java;

import org.junit.Test;

import java.util.Date;

/*
    JDK 8 之前日期和时间的API测试


 */
public class DateTimeTest {

        /*
            java.util.Date类
                |------java.sql.Date类
            1、两个构造器的使用
                > 构造器一: Date(): 创建了一个对应当前时间的Date对象
                > 构造器二: 创建指定毫秒数的Date对象
            2、两个方法的使用
                > toString();显示当前的年、月、日、时、分、秒

                > getTime(): 获取当前Date对象对应的毫秒数(时间戳)

            3、java.sql.Date对应着数据库中日期类型的变量
                > 如何实例化
                > 如何将java.util.Date对象转换为java.sql.Date对象

         */

    @Test
    public void test2(){
        //构造器一: Date(): 创建了一个对应当前时间的Date对象
        Date date1 = new Date();
        System.out.println(date1.toString());//Sun Jun 06 15:04:51 CST 2021


        System.out.println(date1.getTime());//1622963187358

        //构造器二: 创建指定毫秒数的Date对象
        Date date2 = new Date(1622963187358L);
        System.out.println(date2.toString());

        //创建 java.sql.Date对象
        java.sql.Date date3 = new java.sql.Date(1622963187358L);
        System.out.println(date3.toString());//2021-06-06

        //如何将java.util.Date对象转换为java.sql.Date对象
        //情况一:
//        Date date4 = new java.sql.Date(1622963187358L);
//        java.sql.Date date5 = (java.sql.Date) date4;

        //情况二:
        Date date6 = new Date();
        java.sql.Date date7 = new java.sql.Date(date6.getTime());
    }



    //1、System类中的currentTimeMillis();
    @Test
    public void test1(){



        //返回当前时 间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
        //称为时间戳
        long time = System.currentTimeMillis();
        System.out.println(time);
    }

}

3、java.text.SimpleDateFormat类

 Date类的API不易于国际化，大部分被废弃了，java.text.SimpleDateFormat 类是一个不与语言环境有关的方式来格式化和解析日期的具体类。

它允许进行格式化：日期–>文本、解析：文本–>日期

格式化：

SimpleDateFormat() ：默认的模式和语言环境创建对象
public SimpleDateFormat(String pattern)：该构造方法可以用参数pattern 指定的格式创建一个对象，该对象调用：
public String format(Date date)：方法格式化时间对象date
解析：
public Date parse(String source)：从给定字符串的开始解析文本，以生成一个日期。

package com.test.java2;

import org.junit.Test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
    jdk 8之前的日期时间的API测试

    1、System类中currentTimeMillis();
    2、java.util.Date和子类java.sql.Date
    3、SimpleDateFormat
    4、Calendar
 */
public class DateTimeTest {
    /*
        SimpleDateFormat的使用: SimpleDateFormat对日期Date类的格式化和解析

        1、两个操作:
            1.1 格式化: 日期 ---> 字符串
            1.2 解析: 格式化的逆过程，字符串 ---> 日期

        2、 SimpleDateFormat的实例化

    */

    @Test
    public void testSimpleDateFormat() throws ParseException {
        //实例化SimpleDateFormat:使用默认的构造器
        SimpleDateFormat sdf = new SimpleDateFormat();

        //格式化:  日期 ---> 字符串
        Date date = new Date();
//        System.out.println(date);
        String format = sdf.format(date);
        System.out.println(format);//21-6-6 下午4:26


        //解析: 格式化的逆过程，字符串 ---> 日期
        String str = "21-6-6 下午4:26";
        Date date1 = sdf.parse(str);
        System.out.println(date1);

        //********************按照指定的方式格式化和解析:调用带参的构造器****************************
      //  SimpleDateFormat sdf1 = new SimpleDateFormat("yyyyy.MMMMM.dd GGG hh:mm aaa");
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        String format1 = sdf1.format(date);
        System.out.println(format1);//2021-06-06 04:33:32

        //解析:要求字符串必须是符合SimpleDateFormat识别的格式(通过构造器参数体现)
        //否则，抛异常。
        Date date2 = sdf1.parse("2021-06-06 04:33:32");
        System.out.println(date2);
    }

}

4、java.util.Calendar(日历)类

/*
        Calendar日历类(抽象类)的使用


     */

        @Test
        public void testCalendar(){
            //1、实例化
            //方式一:创建其子类(类GregorianCalendar)的对象
            //方式二:调用其静态方法getInstance()

            Calendar calendar = Calendar.getInstance();

            //2、常用方法
            //get()
            int days = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println(days);
            System.out.println(calendar.get(Calendar.DAY_OF_YEAR));
            //set()
            calendar.set(Calendar.DAY_OF_MONTH,22);
            days = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println(days);
            //add()

            calendar.add(Calendar.DAY_OF_MONTH,-3);
            days = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println(days);
            //getTime()
            //日历类 ---> Date
            Date date = calendar.getTime();
            System.out.println(date);
            //setTime()
            //Date ----->日历类
            Date date1 = new Date();
            calendar.setTime(date1);
            days = calendar.get(Calendar.DAY_OF_MONTH);
            System.out.println(days);
        }

注意:

获取月份时：一月是0，二月是1，以此类推，12月是11

获取星期时：周日是1，周二是2 ，。。。。周六是7

JDK 8中新日期时间API

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

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

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

此外，它们也不是线程安全的；不能处理闰秒等。

java.time - 包含值对象的基础包

java.time.chrono - 提供对不同的日历系统的访问

java.time.format - 格式化和解析时间和日期

java.time.temporal - 包含底层框架和扩展特性

java.time.zone - 包含时区支持的类

说明：大多数开发者只会用到基础包和format包，也可能会用到temporal包。因此，尽管有68个新的公开类型，大多数开发者，大概将只会用到其中的三分之一。

package com.test.java2;

import org.junit.Test;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.Date;

/*
    jdk 8中日期时间API的测试


 */
public class JDK8DateTimeTest {

    @Test
    public void test(){
        //偏移量
        Date date1 = new Date(2020 - 1900,9 - 1,8);
        System.out.println(date1);//Tue Sep 08 00:00:00 CST 2020

    }

   /*
          LocalDate、LocalTime、LocalDateTime的使用

        说明:
        1、LocalDateTime相较于LocalDate、LocalTime，使用频率要高
        2、类似于Calenda
    */
    @Test
    public void test1(){

        //now(): 获取当前的日期、时间、日期+时间
        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();

        LocalDateTime localDateTime = LocalDateTime.now();

        System.out.println(localDate);
        System.out.println(localTime);
        System.out.println(localDateTime);

        //of()//设置指定的年、月、日、时、分、秒。没有偏移量

        LocalDateTime localDateTime1= LocalDateTime.of(2020, 10, 6, 13, 23, 43);

        System.out.println(localDateTime1);


        //getXxx(): 获取相关的属性
        System.out.println(localDateTime.getDayOfMonth());
        System.out.println(localDateTime.getDayOfWeek());
        System.out.println(localDateTime.getMonth());
        System.out.println(localDateTime.getMonthValue());
        System.out.println(localDateTime.getMinute());


        //体现不可变性
        //withXxx():设置相关的属性
        LocalDate localDate1 = localDate.withDayOfMonth(22);
        System.out.println(localDate);
        System.out.println(localDate1);


        LocalDateTime localDateTime2 = localDateTime.withHour(4);
        System.out.println(localDateTime);
        System.out.println(localDateTime2);


        //不可变性
        LocalDateTime localDateTime3 = localDateTime.plusMonths(3);
        System.out.println(localDateTime);
        System.out.println(localDateTime3);


        LocalDateTime localDateTime4 = localDateTime.minusDays(6);
        System.out.println(localDateTime);
        System.out.println(localDateTime4);
    }

}

瞬时: Inatant


    /*
        Instant的使用
            类似于java.util.Date类
     */
    @Test
    public void test2(){

        //now():获取本初子午线对应的标准时间
        Instant instant = Instant.now();
        System.out.println(instant);//2021-06-06T10:23:18.476Z时区本初子午线

        //添加时间的偏移量
        OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
        System.out.println(offsetDateTime);

        //获取自1970年1月1日0时0分0秒（UTC）开始的毫秒数 --> Date(long nillis)
        long milli = instant.toEpochMilli();
        System.out.println(milli);

        //ofEpochMilli(): 通过给定的毫秒数，获取Instant实例
        Instant instant1 = Instant.ofEpochMilli(1622975274698L);
        System.out.println(instant1);


    }

DateTimeFormatter 的使用

 /*
        DateTimeFormatter : 格式化或解析日期、时间
        类似于SimpleDateFormat
     */

    @Test
    public void test3(){

       // 预定义的标准格式。如：
 //           方式一: ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
        DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
       //格式化: 日期--->字符串

        LocalDateTime localDateTime = LocalDateTime.now();
        String str1 = formatter.format(localDateTime);
        System.out.println(localDateTime);
        System.out.println(str1);

        //解析: 字符串 --->日期
        TemporalAccessor parse = formatter.parse("2019-02-18T15:42:18.797");
        System.out.println(parse);

        //          方式二:   本地化相关的格式。如：ofLocalizedDateTime()
        //       FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :适用于LocalDateTime

        DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);

        //格式化:
        String str2 = formatter1.format(localDateTime);
        System.out.println(str2);//21-6-6 下午6:57


//              本地化相关的格式。如：ofLocalizedDate()
//              FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 适用于LocalDate
        DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
        //格式化
        String str3 = formatter2.format(LocalDate.now());
        System.out.println(str3);//2021年6月6日 星期日


        //  重点:    方式三: 自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)
        DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
        //格式化
        String str4 = formatter3.format(LocalDateTime.now());
        System.out.println(str4);//2021-06-06 07:11:02

        //解析
        TemporalAccessor accessor = formatter3.parse("2021-06-06 07:11:02");
        System.out.println(accessor);
    }

其它日期时间API

ZoneId：该类中包含了所有的时区信息，一个时区的ID，如 Europe/Paris
ZonedDateTime：一个在ISO-8601日历系统时区的日期时间，如 2007-12- 03T10:15:30+01:00 Europe/Paris。
- 其中每个时区都对应着ID，地区ID都为“{区域}/{城市}”的格式，例如： Asia/Shanghai等
  
  Clock：使用时区提供对当前即时、日期和时间的访问的时钟。

持续时间：Duration，用于计算两个“时间”间隔

日期间隔：Period，用于计算两个“日期”间隔

TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下一个工作日”等操作。

TemporalAdjusters : 该类通过静态方法 (firstDayOfXxx()/lastDayOfXxx()/nextXxx())提供了大量的常用 TemporalAdjuster 的实现。

Java比较器

Java实现对象排序的方式有两种：

自然排序：java.lang.Comparable
定制排序：java.util.Comparator

package com.test.java2;

import org.junit.Test;

import java.util.Arrays;

/*

        一、说明: Java中的对象，正常情况下，只能进行比较: == 或 != . 不能使用 > 或 < 的
                但是在开发场景中，我们需要对多个对象进行排序，言外之意，就需要比较对象的大小。
                如何实现？使用两个接口中的任何一个: Comparable 或 Comparator


        二、Comparable接口的使用


 */
public class CompareTest {
    /*
        Comparable接口的使用举例:  自然排序
        1、像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式
        2、像String、包装类重写了compareTo()方法以后，进行了从小到大的排序
        3、重写compareTo(obj)的规则:
               如果当前对象this大于形参对象obj，则返回正整数，
               如果当前对象this小于形参对象obj，则返回负整数，
               如果当前对象this等于形参对象obj，则返回零。


        4、对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo(obj)方法
            在compareTo(obj)方法中指明如何排序
     */
    @Test
    public void test1(){
        String[] arr = new String[]{"AA","CC","MM","GG","JJ","DD"};

        Arrays.sort(arr);

        System.out.println(Arrays.toString(arr));

    }
    @Test
    public void test2(){
        Goods[] arr = new Goods[5];
        arr[0] = new Goods("lenovoMouse",34);
        arr[1] = new Goods("dellMouse",43);
        arr[2] = new Goods("xiaomiMouse",12);
        arr[3] = new Goods("huaweiMouse",65);
        arr[4] = new Goods("microsoftMouse",43);

        Arrays.sort(arr);

        System.out.println(Arrays.toString(arr));
    }
}

package com.test.java2;
/*
    商品类
 */
public class Goods implements Comparable{
    private String name;
    private double price;

    public Goods() {
    }

    public Goods(String name, double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    //指明商品比较大小的方式： 按照价格从低到高排序，再按照产品名称从低到高排序
    @Override
    public int compareTo(Object o) {
        if (o instanceof Goods) {
            Goods goods = (Goods) o;
            if (this.price > goods.price) {
                return 1;
            } else if (this.price < goods.price) {
                return -1;
            } else {
              //  return 0;
               return  this.name.compareTo(goods.name);
             //   return  -this.name.compareTo(goods.name);从高到低
            }
            //方式二:
//            return Double.compare(this.price, goods.price);
        }
        throw new RuntimeException("传入的数据类型不一致！");
    }

}

package com.test.java2;

import org.junit.Test;

import java.util.Arrays;
import java.util.Comparator;

/*

        一、说明: Java中的对象，正常情况下，只能进行比较: == 或 != . 不能使用 > 或 < 的
                但是在开发场景中，我们需要对多个对象进行排序，言外之意，就需要比较对象的大小。
                如何实现？使用两个接口中的任何一个: Comparable 或 Comparator


        二、Comparable接口与Comparator的使用的对比:
               Comparable接口的方式一旦指定，保证Comparable接口实现类的对象在任何位置都可以比较大小。
                Comparator接口属于临时性的比较。

 */
public class CompareTest {
    /*
        Comparable接口的使用举例:  自然排序
        1、像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式
        2、像String、包装类重写了compareTo()方法以后，进行了从小到大的排序
        3、重写compareTo(obj)的规则:
               如果当前对象this大于形参对象obj，则返回正整数，
               如果当前对象this小于形参对象obj，则返回负整数，
               如果当前对象this等于形参对象obj，则返回零。


        4、对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo(obj)方法
            在compareTo(obj)方法中指明如何排序
     */
    @Test
    public void test1(){
        String[] arr = new String[]{"AA","CC","MM","GG","JJ","DD"};

        Arrays.sort(arr);

        System.out.println(Arrays.toString(arr));

    }
    @Test
    public void test2(){
        Goods[] arr = new Goods[5];
        arr[0] = new Goods("lenovoMouse",34);
        arr[1] = new Goods("dellMouse",43);
        arr[2] = new Goods("xiaomiMouse",12);
        arr[3] = new Goods("huaweiMouse",65);
        arr[4] = new Goods("microsoftMouse",43);

        Arrays.sort(arr);

        System.out.println(Arrays.toString(arr));
    }

    /*
        Comparator接口的使用: 定制排序
        1、背景：
            当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，
        或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那
        么可以考虑使用 Comparator 的对象来排序，强行对多个对象进行整体排
        序的比较。

        2、重写compare(Object o1,Object o2)方法，比较o1和o2的大小：
        如果方法返回正整数，则表示o1大于o2；
        如果返回0，表示相等；
        返回负整数，表示o1小于o2。


     */
    @Test
    public void test3(){
        String[] arr = new String[]{"AA","CC","MM","GG","JJ","DD"};
        Arrays.sort(arr, new Comparator() {

            //按照字符串从大到小的顺序排列
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof String && o2 instanceof String){
                    String s1 = (String) o1;
                    String s2 = (String) o2;
                    return -s1.compareTo(s2);
                }
                //return 0;
                throw new RuntimeException("输入类型不一致！");
            }
        });
        System.out.println(Arrays.toString(arr));
    }


    @Test
    public void test4(){
        Goods[] arr = new Goods[6];
        arr[0] = new Goods("lenovoMouse",34);
        arr[1] = new Goods("dellMouse",43);
        arr[2] = new Goods("xiaomiMouse",12);
        arr[3] = new Goods("huaweiMouse",65);
        arr[4] = new Goods("huaweiMouse",224);
        arr[5] = new Goods("microsoftMouse",43);

        Arrays.sort(arr, new Comparator() {

            //指明商品比较大小的方式： 按照产品名称从低到高排序，再按照价格从高到低排序
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Goods && o2 instanceof Goods){
                    Goods g1= (Goods) o1;
                    Goods g2= (Goods) o2;
                    if(g1.getName().equals(g2.getName())){
                        return -Double.compare(g1.getPrice(), g2.getPrice());
                    }else{
                        return g1.getName().compareTo(g2.getName());
                    }
                }

                throw new RuntimeException("输入类型不一致！");
            }
        });

        System.out.println(Arrays.toString(arr));


    }


}

System类

System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。

由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。

成员变量

System类内部包含in、out和err三个成员变量，分别代表标准输入流 (键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。

成员方法

native long currentTimeMillis()：该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。

void exit(int status)：该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。

void gc()：

该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况。

String getProperty(String key)：

该方法的作用是获得系统中属性名为key的属性对应的值。系统中常见的属性名以及属性的作用如下表所示：

请添加图片描述

package com.test.java2;

import org.junit.Test;

/*
    其它常用类的使用
    1、System
    2、Math
    3、BigInteger 和 BigDecimal

 */
public class OtherClassTest {
    @Test
    public void test1(){
        String javaVersion = System.getProperty("java.version");
        System.out.println("java的version:" + javaVersion);
        String javaHome = System.getProperty("java.home");
        System.out.println("java的home:" + javaHome);
        String osName = System.getProperty("os.name");
        System.out.println("os的name:" + osName);
        String osVersion = System.getProperty("os.version");
        System.out.println("os的version:" + osVersion);
        String userName = System.getProperty("user.name");
        System.out.println("user的name:" + userName);
        String userHome = System.getProperty("user.home");
        System.out.println("user的home:" + userHome);
        String userDir = System.getProperty("user.dir");
        System.out.println("user的dir:" + userDir);
    }
}

Math类

java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回值类型一般为double型。

abs 绝对值

acos,asin,atan,cos,sin,tan 三角函数

sqrt 平方根 pow(double a,doble b) a的b次幂

log 自然对数

exp e为底指数

max(double a,double b)

min(double a,double b)

random() 返回0.0到1.0的随机数 l

ong round(double a)

double型数据a转换为long型（四舍五入）

toDegrees(double angrad) 弧度—>角度

toRadians(double angdeg) 角度—>弧度

BigInteger 和 BigDecimal

BigInteger类

 Integer类作为int的包装类，能存储的最大整型值为2 31-1，Long类也是有限的，最大为2 63-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。

java.math包的**BigInteger可以表示不可变的任意精度的整数。**BigInteger 提供所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。

构造器

BigInteger(String val)：根据字符串构建BigInteger对象

常用方法

public BigInteger abs()：返回此 BigInteger 的绝对值的 BigInteger。

BigInteger add(BigInteger val) ：返回其值为 (this + val) 的 BigInteger

BigInteger subtract(BigInteger val) ：返回其值为 (this - val) 的 BigInteger

BigInteger multiply(BigInteger val) ：返回其值为 (this * val) 的 BigInteger

BigInteger divide(BigInteger val) ：返回其值为 (this / val) 的 BigInteger。整数相除只保留整数部分。

BigInteger remainder(BigInteger val) ：返回其值为 (this % val) 的 BigInteger。

BigInteger[] divideAndRemainder(BigInteger val)：返回包含 (this / val) 后跟 (this % val) 的两个 BigInteger 的数组。

BigInteger pow(int exponent) ：返回其值为 (thisexponent) 的 BigInteger。

BigDecimal类

一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。

BigDecimal类支持不可变的、任意精度的有符号十进制定点数。

构造器

public BigDecimal(double val)

public BigDecimal(String val)

常用方法

public BigDecimal add(BigDecimal augend)

public BigDecimal subtract(BigDecimal subtrahend)

public BigDecimal multiply(BigDecimal multiplicand)

public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

package com.test.java2;

import org.junit.Test;

import java.math.BigDecimal;
import java.math.BigInteger;

/*
    其它常用类的使用
    1、System
    2、Math
    3、BigInteger 和 BigDecimal

 */
public class OtherClassTest {
    @Test
    public void test1(){
        String javaVersion = System.getProperty("java.version");
        System.out.println("java的version:" + javaVersion);
        String javaHome = System.getProperty("java.home");
        System.out.println("java的home:" + javaHome);
        String osName = System.getProperty("os.name");
        System.out.println("os的name:" + osName);
        String osVersion = System.getProperty("os.version");
        System.out.println("os的version:" + osVersion);
        String userName = System.getProperty("user.name");
        System.out.println("user的name:" + userName);
        String userHome = System.getProperty("user.home");
        System.out.println("user的home:" + userHome);
        String userDir = System.getProperty("user.dir");
        System.out.println("user的dir:" + userDir);
    }
    @Test
    public void test2(){
        BigInteger bi = new BigInteger("12433248776756456781123");
        BigDecimal bd = new BigDecimal("12435.351");
        BigDecimal bd2 = new BigDecimal("11");
        System.out.println(bi);
        // System.out.println(bd.divide(bd2));没告诉怎么处理
        System.out.println(bd.divide(bd2, BigDecimal.ROUND_HALF_UP));
        System.out.println(bd.divide(bd2, 15, BigDecimal.ROUND_HALF_UP));
                        //保留十五位小数
    }
}

愤怒且自私22

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java高级部分笔记之常用类

文章目录Java常用类字符串相关的类String的特性String不同实例化方式的对比String不同拼接操作的对比JVM中涉及字符串的内存结构String常用方法String和char[]或byte[]转换解决一个拼接小问题关于StringBuffer 和 StringBuilder的使用JDK 8 之前日期时间API1、java.lang.System类2、java.util.Date类3、java.text.SimpleDateFormat类4、java.util.Calendar(日历)类JDK 8
复制链接

扫一扫