Java常用类

Java常用类

String，StrngBuffer，StringBuilder

String底层是一个char数组

StringBuffer和StringBuilder都继承了AbstractStringBuilder，而AbstractStringBuilder底层也同样是char数组

Stirng,StringBuffer,StringBuilder的区别？

String：不可变的字符序列，底层char[]

StringBuffer：可变的字符序列，线程安全的，效率低，底层char[]

StringBuilder：可变的字符序列，线程不安全，效率高，底层char[]

底层问题

StringBuffer sb = new StringBuffer();底层是创建一个长度是16的char[]数组

扩容问题

如果要添加的数据底层数组盛不下，那么就需要扩充底层的数组，默认情况下，扩容为原来的容量的2倍+2，同时将原来的数组复制到原来的数组中去

常用方法

StringBuffer append()
StringBuffer delete(int start, int end)，删除指定位置的内容
StringBuffer replace(int start, int end, String str)：把[start，end]替换为str
StringBuffer insert(int offset,xxx):在指定位置插入
StringBuffer reverse()：翻转字符串
public int indexOf()
public String substring(int start, int end)
public int length()
public char charAt(int index)
public void setCharAt(int n,char ch)：在指定位置插入元素

一个踩坑点

String str = null;
StringBuilder sb1 = new StringBuilder();
sb1.append(str);
System.out.println(sb1.length());
System.out.println(sb1);
StringBuilder sb2 = new StringBuilder(str);

时间API

Date

java.util.Date
|--------java.sql.Date

//获得1970.1.1日距今的毫秒数
System.out.println(System.currentTimeMillis());
//java.util.Date;
Date date = new Date();
date.getTime();
System.out.println(date);
//和System.currentTimeMillis()一致
System.out.println(date.getTime());
//java.sql.Date
//子类转换为父类可以多态，但是父类转换为子类就得另外想办法了
//java.util.Date转换为java.sql.Date
java.sql.Date data1 = new java.sql.Date(date.getTime());
System.out.println(data1);

SimpleDateFormat

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

//无参构造
SimpleDateFormat sdf = new SimpleDateFormat();
Date date = new Date();
System.out.println(date);
//格式化Date
String format = sdf.format(date);
System.out.println(format);
//解析--->注意格式！！！
String str = "19-10-1 下午2:01";
Date parse = sdf.parse(str);
System.out.println(parse);
//==自定义==有参构造
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
//格式化
Date date1 = new Date();
String format1 = sdf1.format(date1);
System.out.println(format1);
//解析
Date parse1 = sdf1.parse("2021-12-08 02:07:13");
System.out.println(parse1);

Calendar（日历类）

Calendar是一个抽象类，主要用于完成日期字段之间相互操作的功能

Java8java.time

LocalDate LocalTime LocalDateTime

//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);
//get
//of

Instant

DateTimeFormatter

比较器

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

Comparable

1. 像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象的方法
2. 像String、包装类重写compareTo()方法以后，进行了从小到大的排列
3. 重写compareTo(obj)的规则：
   如果当前对象this大于形参对象obj，那么返回正整数
   如果当前对象this小于形参对象obj，那么返回负整数
   如果当前对象this等于形参对象obj，那么返回零

@Test
public void test() {
    String[] str = new String[]{"AA","DD","CC","BB"};
    Arrays.sort(str);
    System.out.println(Arrays.toString(str));
}

自定义实现

自定义类并且实现Comparable接口重写compareTo方法

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

    public Goods() {
    }

    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 String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    /**
     * Comparable为自然排序是优先被选择的一种
     * 指明比较原则
     *
     * @param o
     * @return
     */
    @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 0;
    }
}

public class Test {
    public static void main(String[] args) {
        Goods dell = new Goods("dell", 30);
        Goods xiaomi = new Goods("xiaomi", 20);
        Goods huawei = new Goods("huawei", 35);
        //没有重写
        Goods[] goods = new Goods[]{dell, xiaomi, huawei};
        Arrays.sort(goods);
        System.out.println(Arrays.toString(goods));
    }
}

----------------------------------------------------------
D:\Java\jdk1.8.0_241\bin\java.exe
[Goods{name='xiaomi', price=20}, Goods{name='dell', price=30}, Goods{name='huawei', price=35}]

Process finished with exit code 0    

Comparator

背景

当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不符合当前的操作那么可以考虑使用Comparator的对象来排序，比如想要实现从大到小

重写规则和Comparable一致

@org.junit.Test
    public void test() {
    String[] array = new String[]{"AA", "DD", "CC", "BB"};
    Arrays.sort(array, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            if (o1 instanceof String && o2 instanceof String) {
                String s1 = o1;
                String s2 = o2;
                return -s1.compareTo(s2);
            }
            return 0;
        }
    });
    System.out.println(Arrays.toString(array));
}

Math