CT的Java基础学习笔记（十）——常用类

Java基础学习笔记整理了我从零开始学习Java时所学习到的内容。
以下内容参考尚硅谷Java教程。

十、Java常用类

1 String类

1.1 概述

String:字符串，用一对""表示。

1. String声明为final的，不可被继承；
2. String实现了Serializable接口：表示String是支持序列化的；
   实现了Comparable接口：表示String可以比较大小；
3. String内部定义了final char[] value用于存储字符串数据；
4. 通过字面量方式给一个String赋值，此时字符串声明在字符串常量池中；
5. 字符串常量池中不会存储相同内容（使用String类重写的equals()方法比较）的字符串。

1.2 String的不可变性

String代表不可变的字符序列。

说明：

1. 对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值；
2. 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值；
3. 当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。

1.3 String实例化的不同方式

说明：

1. 方式一：通过字面量创建
2. 方式二：通过new +构造器的方式创建

1.4 字符串拼接方式赋值的对比

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

代码：

		String s1 = "javaEE";
        String s2 = "hadoop";

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

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

        String s8 = s5.intern();//返回值得到的常量池中已经存在的字符串
        System.out.println(s3 == s8);//true

1.5 String的常用方法

        String s1 = "HelloWorld";
        System.out.println(s1.length());
        System.out.println(s1.charAt(5));
        System.out.println(s1.isEmpty());
        System.out.println(s1.toUpperCase());
        System.out.println(s1.trim());
        System.out.println(s1.equalsIgnoreCase("helloworld"));
        System.out.println(s1.concat("!!"));
        System.out.println(s1.compareTo("yes,sir!are you ok ?"));
        System.out.println(s1.substring(5));
        System.out.println(s1.substring(5,7));
/************************/
        String s1 = "HelloWorld";
        System.out.println(s1.endsWith("ld"));
        System.out.println(s1.startsWith("He"));
        System.out.println(s1.startsWith("ll",2));

1.6 String与其他结构的转换

1.6.1 与基本数据类型、包装类之间的转换

String -->基本数据类型、包装类：调用包装类的静态方法：parsXxx(str)
基本数据类型 -->String：调用String重载的valueOf(xxx)

1.6.2 与字符数组的转换

String --> char[]: String.toCharArray()

char[] --> String: String的构造器

1.6.3 与字节数组的转换

编码：String --> byte[]: String.getByte()

解码：byte[] --> String: String的构造器

编码与解码必须使用相同的字符集，否则会出现乱码。

1.6.4 与StringBuffer、StringBuilder之间的转换

String --> StringBuffer、StringBuilder:调用StringBuffer、StringBuilder的构造器

StringBuffer、StringBuilder -->String ：调用String的构造器；StringBuffer、StringBuilder的toString()

1.6.5 JVM字符串常量池

JDK 1.6：字符串常量池存储在方法区
JDK 1.7：字符串常量池存储在堆空间
JDK 1.8：字符串常量池存储在方法区(元空间)

2 StringBuffer、StringBuilder

三者底层都是用char[]存储

String:不可变的字符序列
StringBuffer:可变的字符序列、线程安全、效率低
StringBuilder:可变的字符序列、线程不安全、效率高

扩容：扩容为原来的容量的2倍+2
开发中建议使用StringBuffer(int capacity)或StringBuilder(int capacity)

2.1 三者的执行效率对比

从高到低：StringBuilder > StringBuffer > String

2.2 StringBuffer、StringBuilder的常用方法

• 增: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()

3 日期时间

3.1 获取系统当前的时间

System类中的currenTimeMillis()：返回当前时间与1970年1月1日00分00秒以毫秒为单位的时间差。

3.2 java.util.Date与java.sql.Date

jdk8之前常用的日期时间API

• 构造器
  构造器一：Date()，创建一个对应当前时间的对象；
  构造器二：创建指定毫秒数的Date对象

• 方法
  toString()：显示当前的年月日时分秒；
  getTime()：获取当前Date对象对应的毫秒数。

3.3 java.text.SimpleDateFormat类

SimpleDateFormat：对日期Date类的格式化和解析

1. 格式化：日期—>字符串
2. 解析：格式化的逆过程，字符串—>日期

SimpleDateFormat实例化方式：new+构造器

		
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        //格式化
        String format1 = sdf1.format(date);
        System.out.println(format1);//2021-01-11 08:58:27
        //解析：要求字符串必须符合SimpleDateFormat识别的格式
        //否则抛出异常
        Date date2 =sdf1.parse("2020-02-18 11:48:27");
        System.out.println(date2);//Tue Feb 18 11:48:27 CST 2020

3.4 Calendar类

Canlendar类：日历类，是一个抽象类

 		//实例化方式
 		Calendar calendar = Calendar.getInstance();
 		//常用方法
        //get()
        int days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);
        //set()
        //calendar可变性
        calendar.set(Calendar.DAY_OF_MONTH,21);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);
        //add()
        calendar.add(Calendar.DAY_OF_MONTH,3);
        //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);

3.5 jdk8中新的日期API

日期API的迭代：
第一代：jdk1.0 Date类
第二代：jdk1.1 Calendar类

第三代：jdk1.8 提出了新的一套API

3.5.1 LocalDate、LocalTime、LocalDateTime

说明：

1. 分别表示使用ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息；
2. LocalDateTime相较于前两种使用频率更高；
3. 与Calendar类相似。

常用方法：

3.5.2 时间点：Instant

说明：

1. 时间上的一个瞬时点。概念上讲，它只是简单表示自1970年1月1日0时0分0秒（UTC开始的秒数）；
2. 类似于java.util.Date

常用方法：

3.5.3 时间格式化及解析：DateTimeFormatter类

说明：

1. 格式化或解析日期、时间；
2. 类似于SimpleDateFormat

常用方法：

1. 实例化

• 预定义的标准格式：ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
• 本地化的相关格式：ofLocalizedDateTime(FormatStyle.LONG)
• 自定义格式：ofPattern(“yyyy-MM-dd hh:mm:ss”)

2. 常用方法：
   

        //方式三：自定义格式：ofPattern("yyyy-MM-dd hh:mm:ss")
        DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
        String format = formatter2.format(LocalDateTime.now());
        System.out.println(format);//2020-11-26 10:05:57
        //解析
        TemporalAccessor parse1 = formatter2.parse("2020-11-26 10:05:57");
        System.out.println(parse1);//{MinuteOfHour=5, HourOfAmPm=10, NanoOfSecond=0, MilliOfSecond=0, MicroOfSecond=0, SecondOfMinute=57},ISO resolved to 2020-11-26

4 Java比较器

使用背景：Java的对象，正常情况下，只能进行比较：== 或 !=，不能使用 > 或 < 的。但是在开发场景中，我们需要对多个对象进行排序，需要比较对象的大小。所以我们使用Comparable或Comparator比较器

4.1 自然排序：使用Comparable接口

说明：

1. 像String、包装类等实现了Comparable接口，重现了compareTo(obj)方法，给出了比较两个对象大小的方式。
2. 像String、包装类重写compareTo()方法以后，进行了从小到大的排列
3. 重写compareTo()规则：
   如果当前对象this大于形参对象obj，则返回正整数；
   如果当前对象this小于形参对象obj，则返回负整数；
   如果当前对象this等于形参对象obj，则返回0。
4. 对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo()方法。在compareTo()方法中指明如何排序。

自定义类代码举例

public class Goods implements Comparable{
    private String name;
    private int price;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.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 this.name.compareTo(goods.name);
            }
        }
        throw new RuntimeException("传入的数据类型不一致");
    }

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

4.2 定制排序：使用Comparator接口

说明：

1. 当元素没有实现Java.lang.Comparable接口而又不方便修改代码,或者实现了java.lang.Comparable接口的排序规则不适合当前操作,那么可以考虑使用Comparator的对象来排序
2. 重写compare(Object o1,Object o2)方法,比较o1和o2的大小
   如果返回正整数,则表示o1大于o2;
   如果返回0,表示相等;
   如果返回负整数,表示o1小于o2。

代码举例：

public void test2(){
        Goods[] arr = new Goods[5];
        arr[0] = new Goods("LenovoMouse",20);
        arr[1] = new Goods("HUAWEIMouse",100);
        arr[2] = new Goods("XiaoMiMouse",35);
        arr[3] = new Goods("AppleMouse",200);
        arr[4] = new Goods("Mouse",20);

        System.out.println("原输出："+Arrays.toString(arr));
        Arrays.sort(arr, new Comparator<Goods>() {
            @Override
            public int compare(Goods o1, Goods o2) {

                    if(o1.getPrice() > o2.getPrice()){
                        return 1;
                    }else if(o1.getPrice()< o2.getPrice()){
                        return -1;
                    }else{
                        return o1.getName().compareTo(o2.getName());
                    }
            }
        });

        System.out.println("自定义后的输出："+Arrays.toString(arr));
    }

使用：
Arrays.sort(goods,comparator)
Collection.sort(coll,comparator)
new TreeSet(com)

4.3 两种方式的对比

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

5 其他类

5.1 System类

System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。
由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的调用。
方法：

• native long currentTimeMillis()
• void exit()：作用为退出程序
• void gc()：请求系统进行垃圾回收
• String getProperty(String key)：获得系统中名为key的属性对应的值。系统中常见的有：

5.2 Math类

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

5.3 BigInteger类、BigDecimal类

java.math.BigInteger可以表示不可变的任意精度的整数；
要求精度比较高时，可以用到java.math.BigDecimal类。