Java 常用API--02

2023-01-30 12:59:17

Java常用类

一，字符串相关的类

1，String类

1,概述

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

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的常用方法

方法名	说明
StringBuffer append()	提供了很多参数的append方法，用于进行字符串的拼接
StringBuffer delete(int start, int end)	删除到start 到 end索引的字符串
StringBuffer replace(int start, int end, String str)	替换指定位置的字符串为str
StringBuffer insert(int offset, String str)	在指定位置插入str
StringBuffer reverse()	逆转当前字符串序列
int indexOf(String str)	返回指定字符串的索引
String substring(int start, int end)	返回指定位置的字符串
int length()	返回长度
char charAt(int index)	返回指定索引的字符char
void setCharAt(int index, char ch)	替换指定索引位置的字符为ch

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高

码农公寓