Java常用类

一，字符串相关的类

1，String类

1,概述

1. String：字符串，使用一对**""**引起来表示
2. String声明为final的，不可被继承
3. String实现了Serialzable接口：表示字符串是支持序列化的，
4. String实现了Comparable接口：表示String可以比较大小，
5. String内部定义了private final byte[] value;（jdk 9之前char[]） 用于存储字符串的数据
6. String ：代表不可变的字符序列。简称不可变性。
   1. 体现：当对字符串重新赋值时，需要重写指定内存区赋值，不能使用原有的value进行赋值。
   2. 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能在原有的value进行赋值
   3. 当调用String的replace()方法修改指定的字符或字符串时，也需要重新指定内存区域赋值
7. 通过字面量的方式（区别于new给一个字符串赋值，此时的字符串值声明在字符串常量池中）[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cf8l0bkJ-1634050674593)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\image-20210324092229964.png)]
8. 字符串常量池中是不会存储相同内容的字符串的。

2.String对象的创建。

  @Test
    public void test2(){
        //字面量的定义方式
        String s = "hello";
        //本质上this.value = new char[0];
        String s1 = new String();
        s1 = "hello";
        //this.value = original.value
        String s2 = new String(s1);
        System.out.println(s1);//hello
        System.out.println(s2);//hello
        //public String(char value[]):
        char[] a = {'h','e','l','l','o'};
        String s3 = new String(a);
        System.out.println(s3);//hello

        //public String(char value[], int offset, int count)
        String s4 = new String(a,0,1);//h
        System.out.println(s4);

    }

3.字符串的特性：

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

4，String的常用方法：

package JavaSE.JavaApi;

import org.junit.jupiter.api.Test;

public class Test_String_Method {
    @Test
    public void test1(){
        String s = "Hello World!";
        
        //1.int length():返回字符串的长度
        System.out.println(s.length());//12
        
        //2.char charAt(int index)：返回index处的字符
        System.out.println(s.charAt(0));//H
        
        //3.boolean isEmpty()：判断字符串是否为空
        System.out.println(s.isEmpty());//false
        
        //4.String toLowerCase():使用默认语言环境，将字符串所有字符转换为小写
        System.out.println(s.toLowerCase());//hello world!
        
        //5.String toUpperCase():使用默认语言环境，将字符串所有字符转换为大写
        System.out.println(s.toUpperCase());//HELLO WORLD!
        
        //6.String trim()：返回字符串的副本，忽略前后空白
        System.out.println(s.trim());//Hello World!
        
        //7.boolean equals(Object anObject):比较字符串的内容是否相同
        String s1 = "Hello World!";
        System.out.println(s.equals(s1));//true
        
        //8.boolean equalsIgnoreCase(String anotherString):比较字符串的内容是否相同，忽略大小写
        System.out.println(s.toUpperCase().equalsIgnoreCase(s));//true
        
        //9.String concat(String str):将指定字符串连接到此字符串的结尾并返回，相当于+
        System.out.println(s.concat(s1));//Hello World!Hello World!
        
        //10.int compareTo(String anotherString):比较两个字符串的大小
        System.out.println(s.compareTo(s1));
        
        //11.String substring(int beginIndex):返回从beginIndex开始截取的字符串
        System.out.println(s.substring(6));//World!
        
        //12.String substring(int beginIndex, int endIndex) :返回从beginIndex到endIndex的字符串，长度为end-begin
        System.out.println(s.substring(0, 5));//Hello
        
        //13.String[] split(String str):分割成字符串数组
        for (String a:
             s.split(" ")) {
            System.out.println(a);
        }
        /*
        Hello
        World!
         */
        //14.String replace(char oldChar, char newChar):替换字符串中的字符
        System.out.println(s.replace(' ', '#'));//Hello#World!

    }
}

2.StringBuffer类&&StringBulider类

1.String类StringBuffer类&&StringBulider类三者的异同

String：不可变的字符序列

StringBuffer：可变的字符序列，线程安全的，效率偏低

StringBulider：可变的字符序列，线程不安全的，效率高一些

String长度不可变，StringBuffer和StringBulider默认初始化为16个字节长度的数组，如果append后底层数组容量不够，扩容为原来的 2倍，注意：StringBuffer和StringBulider重写了length方法，所以没有初始化length为0。

2.StringBuffer&&StringBulider的常用方法

package JavaSE.JavaApi;

import org.junit.jupiter.api.Test;

public class Test_StringBuffer_StringBuilder {
    @Test
    public void test(){
        var s1 = new StringBuffer("abc");

        //1.StringBuffer append() :提供了很多参数的append方法，用于进行字符串的拼接
        s1.append("Hello");
        System.out.println(s1);//abcHello

        //2.StringBuffer delete(int start, int end) :删除到start 到 end索引的字符串
        s1.delete(0, 3);
        System.out.println(s1);//Hello

        //3.StringBuffer replace(int start, int end, String str):替换指定位置的字符串为str
        s1.replace(0,1,"Y");
        System.out.println(s1);//Yello

        //4.StringBuffer insert(int offset, String str) :在指定位置插入str
        s1.insert(0,"Hello   ");
        System.out.println(s1);//Hello   Yello

        //5.StringBuffer reverse():逆转当前字符串序列
        System.out.println(s1.reverse());//olleY   olleH
        System.out.println(s1.reverse());

        //6.int indexOf(String str)：返回指定字符串的索引
        System.out.println(s1.indexOf("H"));//0

        //7.String substring(int start, int end):返回指定位置的字符串
        System.out.println(s1.substring(0,5));//Hello
        System.out.println(s1);//Hello   Yello

        //8.int length():返回长度
        System.out.println(s1.length());//13

        //9. char charAt(int index) :返回指定索引的字符char
        char ch = s1.charAt(0);
        System.out.println(ch);//H
        System.out.println(s1);//Hello   Yello

        //10.void setCharAt(int index, char ch):替换指定索引位置的字符为ch
        s1.setCharAt(1,ch);
        System.out.println(s1);//HHllo   Yello

    }
}

二，时间类2

在jdk8之后增加了新的处理时间的类

1.LocalDate、LocalDateTime、LocalTime等类

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

package JavaSE.JavaApi;

import org.junit.jupiter.api.Test;

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

public class Test_DateTimeJDK8 {
    @Test
    public void test1(){
        //now():获取当前的时间，日期，日期加时间
        LocalDate ld =  LocalDate.now();
        LocalTime lt = LocalTime.now();
        LocalDateTime ldt = LocalDateTime.now();

        System.out.println(lt);//22:00:25.796960800
        System.out.println(ld);//2021-03-24
        System.out.println(ldt);//2021-03-24T22:00:25.796960800

        //of():设置指定的时间（没有偏移量，区别于Date）
        var ldt1 = LocalDateTime.of(2020,11,29,0,0);
        System.out.println(ldt1);//2020-11-29T00:00

        //getXxx()：获取属性
        System.out.println(ldt.getDayOfMonth());//24
        System.out.println(ldt.getDayOfWeek());//WEDNESDAY
        System.out.println(ldt.getHour());//WEDNESDAY
        System.out.println(ldt.getMinute());//4
        System.out.println(ldt.getDayOfYear());//83

        //体现不可变性，修改后是一个返回值，不修改之前的内容
        //with():相当于设置相关的时间属性
        var ldt2 = ldt.withDayOfMonth(12);
        System.out.println(ldt);//2021-03-24T22:06:09.325862800
        System.out.println(ldt2);//2021-03-12T22:06:09.325862800

        //plus():加时间
        var ldt3 = ldt.plusMonths(3);//加三个月
        System.out.println(ldt3);

        //minus()：减时间
        System.out.println(ldt.minusMonths(12));//2020-03-24T22:10:09.342367100

    }
}

2.Instant

Instant：时间线上的一个瞬时点。这可能被用来记录应用程序中的事件时间戳。

@Test
    public void test2(){
        //now()：获取本初子午线对应的时间，类比Date类
        var instant = Instant.now();
        System.out.println(instant);//2021-03-24T14:15:30.156727400Z加8个小时

        //添加时间偏移量
        System.out.println(instant.atOffset(ZoneOffset.ofHours(8)));//2021-03-24T22:17:58.514141+08:00

        //获取对应的毫秒数    1970年一月一日。。。到现在的毫秒数  对应的本初子午线时间
        System.out.println(instant.toEpochMilli());//1616595613701

        //ofEpochMilli()：通过给定的毫秒数，获取Instant实例
        System.out.println(Instant.ofEpochMilli(1616595613701L));//2021-03-24T14:20:13.701Z
        
        
    }

3.DateTimeFormatter类

用来格式化或解析日期时间，类似于SimpleDateFormat

 @Test
    public void test3(){
        //方法一：预定义 的标准格式
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        //格式化：日期--》字符串
        LocalDateTime localDateTime = LocalDateTime.now();
        var format = dateTimeFormatter.format(localDateTime);
        System.out.println(localDateTime);//2021-03-24T22:32:00.720018800
        System.out.println(format);//2021-03-24T22:32:00.7200188

        var parse = dateTimeFormatter.parse("2021-03-24T22:32:00.7200188");
        System.out.println(parse);// {},ISO resolved to 2021-03-24T22:32:00.720018800

        //方法二：本地化相关的格式。如FormatStyle.SHORT/FormatStyle.FULL/FormatStyle.LONG/FormatStyle.MEDIUM
        var dateTimeFormatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
        System.out.println(dateTimeFormatter1.format(localDateTime));//2021/3/24 下午10:36
        var dateTimeFormatter2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG).withZone(ZoneOffset.ofHours(8));
        System.out.println(dateTimeFormatter2.format(localDateTime));//2021年3月24日 +08:00 下午10:40:55

        //方法三：自定义的格式。如：ofPattern("yyyy-MM-dd hh:mm:ss E")
        System.out.println(DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss E").format(localDateTime));//2021-03-24 10:48:17 周三
        

    }

4.其他API

…

三，Java比较器

1.概述

需求：java中的对象，正常情况下，只能进行比较：== != 。不能使用>或<，但是在实际开发过程中，我们需要对多个对象进行排序，也就是说，我们需要比较对象的大小。这个时候我们就需要实现两个接口中的任何一个：Comparable或Comparator

• 在java中经常会涉及到对象数组的排序问题，那么就涉及到对象之间的比较问题

• 在java中实现对象排序的方式有两种：

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

2.Comparable接口的使用

像String，包装类等实现了Comparable接口，重写了ComparTo()方法，给出了比较两个对象大小的方式。像String，包装类重写了ComparTo()方法之后，进行了从小到大的排列。

重写ComparTo()方法的规则：

• 如果当前对象this大于形参对象obj，则返回正整数；
• 如果当前对象this小于形参对象obj，则返回负整数；
• 如果当前对象this等于形参对象obj，则返回零。

自定义类实现Comparable类 自然排序

举例：

package JavaSE.JavaApi;

import org.junit.jupiter.api.Test;

import java.util.TreeSet;

public class Test_Compare {


    class Teacher implements Comparable{
        public int age;
        public int stu_age;
        public String name;

        Teacher(int age,int stu_age,String name){
            this.age = age;
            this.stu_age = stu_age;
            this.name = name;


        }

//        //按照年龄从小到大排列
//        @Override
//        public int compareTo(Object o) {
//
//            if (o instanceof Teacher) {
//                Teacher teacher = (Teacher) o;
//                //方法一：
                if (this.age > teacher.age) {
                    return this.age - teacher.age;
                } else if (this.age < teacher.age) {
                    return teacher.age - this.age;
                } else {
                    return 0;
                }
//                //方法二：
//                return Double.compare(this.age,teacher.age);
//            }
//            throw new RuntimeException("传入参数类型错误");
//        }
        /*按照年龄从小到大排列
        Teacher{age=30, stu_age=8, name='Jack'}
        Teacher{age=50, stu_age=20, name='Mike'}
        Teacher{age=45, stu_age=25, name='John'}
        Teacher{age=60, stu_age=35, name='Alice'}
         */

        //按照教学年龄从小到大排列
//        @Override
//        public int compareTo(Object o) {
//            if (o instanceof Teacher){
//                Teacher teacher = (Teacher) o;
//                return Double.compare(this.stu_age,teacher.stu_age);
//
//            }
//            throw new RuntimeException("传入参数类型错误");
//        }
        /*按照教学年龄从小到大排列
        Teacher{age=30, stu_age=8, name='Jack'}
        Teacher{age=50, stu_age=20, name='Mike'}
        Teacher{age=45, stu_age=25, name='John'}
        Teacher{age=60, stu_age=35, name='Alice'}
         */

        //按照姓名(英文字母顺序)排序
        @Override
        public int compareTo(Object o) {
            if (o instanceof Teacher){
                Teacher teacher = (Teacher) o;
                return this.name.compareTo(teacher.name);
            }
            throw new RuntimeException("传入参数类型错误");
        }
        /*按照姓名(英文字母顺序)排序
        Teacher{age=60, stu_age=35, name='Alice'}
        Teacher{age=30, stu_age=8, name='Jack'}
        Teacher{age=45, stu_age=25, name='John'}
        Teacher{age=50, stu_age=20, name='Mike'}
         */

        @Override
        public String toString() {
            return "Teacher{" +
                    "age=" + age +
                    ", stu_age=" + stu_age +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
    @Test
    public void Test(){
        //Comparable接口的使用举例
        Teacher[] teachers = new Teacher[4];
        teachers[0] = new Teacher(30,8,"Jack");
        teachers[1] = new Teacher(50,20,"Mike");
        teachers[2] = new Teacher(45,25,"John");
        teachers[3] = new Teacher(60,35,"Alice");

        var set = new TreeSet();
        for (int i = 0; i < 4; i++) {
            set.add(teachers[i]);
        }

        for (Object obj:
             set) {
            System.out.println(obj);
        }
    }
}

3.Comparator接口的使用

说明：

• 当前对象的类没有实现Comparable接口而又不方便修改代码，或者实现了Comparable接口的排序规则不适合当前的操作，那么可以考虑使用Comparator接口的对象来排序。强行对多个对象进行整体排序的比较
• 重写Comparator接口里面的compare（Object o1,Object o2）方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2;如果返回负整数，表示o1小于o2；如果返回0，表示相等。
• 可以将Comparator传递给sort方法(如：Collection.sort或Arrays.sort)，从而允许在排序顺序上实现精确控制。
• 还可以用该接口来控制某些数据结构的顺序…

//这个方法在上面public class Test_Compare类中
@Test
public void Test_Comparator(){
    Teacher[] teachers = new Teacher[4];
    teachers[0] = new Teacher(30,8,"Jack");
    teachers[1] = new Teacher(50,20,"Mike");
    teachers[2] = new Teacher(50,20,"John");
    teachers[3] = new Teacher(50,35,"Alice");

    var set = new TreeSet(new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
            if (o1 instanceof Teacher && o2 instanceof Teacher){
                Teacher t1 = (Teacher) o1;
                Teacher t2 = (Teacher) o2;
                if (Double.compare(t1.age, t2.age) == 0){//如果年龄相等比较教学年龄
                    if (Double.compare(t1.stu_age, t2.stu_age) == 0){//如果教学年龄相等比较姓名字母
                        return t1.name.compareTo(t2.name);
                    }else return Double.compare(t1.stu_age, t2.stu_age);
                }else return Double.compare(t1.age, t2.age);
            }
            throw new RuntimeException("传入参数类型错误");
        }
    });


    for (int i = 0; i < 4; i++) {
        set.add(teachers[i]);
    }

    for (Object obj:
         set) {
        System.out.println(obj);
    }

    /*运行结果：
        Teacher{age=30, stu_age=8, name='Jack'}
        Teacher{age=50, stu_age=20, name='John'}
        Teacher{age=50, stu_age=20, name='Mike'}
        Teacher{age=50, stu_age=35, name='Alice'}
         */
}

四：Java中的大数（BigInteger类和BigDecimal类）

表示比long更大的整数，BigInteger类可以表示不可变的任意精度的整数。。。。。BigDecimal的运算精度比double高