语言知识——Java常用类

字符串相关类

String类：

/**
  * 根据定义可以知道：
  *     final 因此不可继承
  *     实现了Serializable 所以字符串是支持序列化的
  *     实现了Comparable 所以可以比较大小
  *     String内部定义了final char[] value 这部分是用来存储字符串数据，具有不可变性
  *         不可变性：
  *         当对字符串重新赋值时、当对字符串进行连接操作时、当调用repalce()等修改字符
  *     方法时，需要重写指定内存赋值，不能对原有的value进行赋值、连接或修改；
  *         即，内存中，一种字符串占一块内存，每次改变都会新建一个String对象，不会去操
  *     作之前所声明的内存。
  */
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0


/**
  * String s = "abc" 和 String s = new String("abc")的差别
  */
class Stringtest{
    /**
     *   定义时，看是否存在new String()
     *
     *   拼接时，常量与常量拼接，地址还是指向常量池，
     *   而拼接过程中只要有一个变量，那就是变量，地址指向堆中，堆中对象在指向常量池地址。
     *   若结果调用intern()方法，则地址返回常量池中的地址。
     */
    public static void main(String[] args){
        // 通过字面量定义的方式
        // 此时s1、s2数据声明在方法区的字符串常量池中
        String s1 = "javaEE";
        
        // 通过new+构造器的方式
        // 此时s3保存的是地址值，地址为数据在堆空间中开辟的空间
        String s3 = new String("javaEE");
        
        // 同样的实例化其他对象时，一般来说也用的是字面量的定义方式
        // 所以两个对象之间的String类型属性用equals来比也是相同的，因为在常量池
        
    }
}

String常用方法：java中String类的常用方法_迷途风哥的博客-CSDN博客_javastring类常用方法

String与其他类型的转换问题：

class Stringtest{

    public static void main(String[] args){
        // String -> 基本数据类型、包装类：调用包装类的静态方法
        String s1 = "123";
        // String转为基本数据类型
        int num1 = Integer.parseInt(s1);        // parseXxx(str)

        // 基本数据类型转为String
        String s2 = String.valueOf(num1);       // valueOf(int\long\double\boolean)

        // String和char互相转换
        String s3 = "abc";
        char[] charArray = s3.toCharArray();    // String -> char[]

        char[] charArray1 = new char[]{'a', 'b', 'c'};
        String s4 = new String(charArray);      // char[] -> String

        // String和byte互相转换
        String s5 = "abc123";
        byte[] bytes = s5.getBytes();           // String -> byte[]

        String s6 = new String(bytes);          // byte[] -> String
    }
}

String、StringBuffer、StringBuilder三者异同？

String：不可变字符序列：底层用final char[]

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

StringBuilder：可变字符序列：jdk5.0新增的，线程不安全的、效率高：底层用char[]

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

// char[] value = new char[16]; 底层默认值
StringBuffer str = new StringBuffer(); 
// char[] value = new char["abc".length() + 16];
StringBuffer str = new StringBuffer("abc");  

ps: 
1、str.length() == 3;  
因为StringBuffer底层重写了length()方法，length()返回为元素个数
2、若append过程中大于16，则扩容为原来容量的2倍+2，同时将原有数组复制到新的数组中
3、StringBuilder与StringBuffer声明和扩容方面相同

日期时间相关API

public class timerelated {
    /**
     * JDK8.0前，缺点：
     * 1、可变性：像日期、时间等类应该不可变，即不可修改原内存内容，只可以重新创建并指向
     * 2、偏移性：Date中年份从1900开始，月份都从0开始，所以实际用时还得把这个偏移量去掉才是我们所需的
     * 3、格式化：格式化只对Date有用，Calendar则不行
     * 4、非线程安全、不能处理润秒等
     */
    @Test
    public void test() throws ParseException {
        // System.currentTimeMills：当前时间与1970.1.1 00:00:00以毫秒为单位的时间差
        long time = System.currentTimeMillis();
        System.out.println(time);                  // 1665281905311

        // java.util.Date：
        Date date = new Date();                    // 若为空参，则为当前时间
        System.out.println(date);                  // Sun Oct 09 10:17:21 CST 2022
        System.out.println(date.getTime());        // 1665281905311

        Date date1 = new Date(1600000000000L);     // 若为毫秒数，则为指定时间
        System.out.println(date1);                 // Sun Sep 13 20:26:40 CST 2020
        System.out.println(date1.getTime());       // 1600000000000

        // java.sql.Date：
        java.sql.Date date2 = new java.sql.Date(1500000000000L);
        System.out.println(date2);                  // 2017-07-14
        System.out.println(date2.getTime());        // 1500000000000

        // java.util.Date -> java.sql.Date
        Date date3 = new java.sql.Date(1000000000000L);

        Date date5 = new Date();
        java.sql.Date date6 = new java.sql.Date(date5.getTime());

        // java.text.SimpleDateFormat：日期 <-> 字符串
        java.text.SimpleDateFormat date7 = new java.text.SimpleDateFormat();
        System.out.println(date7.format(date5));    // 22-10-9 上午10:53
        System.out.println(date7.parse("22-10-9 上午10:53"));

        String pattern = "yyyy.MM.dd HH:mm:ss";
        java.text.SimpleDateFormat date8 = new java.text.SimpleDateFormat(pattern);
        System.out.println(date8.format(date5));    // 2022.10.09 11:43:10
        System.out.println(date8.parse("2022.10.09 11:43:10"));

        // java.text.Calender：抽象类
        Calendar calender = Calendar.getInstance();
        Calendar calender1 = new GregorianCalendar();
    }

    /**
     * JDK8.0后
     * Joda-Time.jar在JDK8.0后集成到了java中，为java.time
     * 在JDK8.0之前，可以导入jar包进行使用
     * 另外还有：Instant类（纳秒处理）、DateTimeFormatter类（替换Format类，时间格式化）
     */
    @Test
    public void test1() throws ParseException {
        // java.time：LocalDate、LocalTime、LocalDateTime
        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();
        LocalDateTime localDateTime = LocalDateTime.now();

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

        // LocalDateTime使用频率最高，of用来指定日期，get用来获取具体日期信息，with用来修改
        LocalDateTime localDateTime1 = LocalDateTime.of(2020, 5, 9, 4, 26, 13, 14);
        System.out.println(localDateTime1);

        System.out.println(localDateTime1.getDayOfMonth());

        LocalDateTime localDateTime2 = localDateTime1.withDayOfMonth(4);
        System.out.println(localDateTime1.getDayOfMonth());
        System.out.println(localDateTime2.getDayOfMonth());
    }
}

Java比较器

/**
 * java中对象正常情况下只能比较 == or != ,不能 < or <= or > or >=
 * 现实当中是需要吧比较大小的，实现而言是使用Comparable或Comparator
 * Comparable实现该接口compareTo方法
 * Comparator适用于没实现Comparable接口，或Comparable接口的排序规则不适用于当前是使用
 */
public class compare {
    public static void main(String[] args){
        Compare1[] goods = new Compare1[4];

        goods[0] = new Compare1("a", 1);
        goods[1] = new Compare1("b", 2);
        goods[2] = new Compare1("c", 5);
        goods[3] = new Compare1("d", 4);

        Arrays.sort(goods);
        System.out.println(Arrays.toString(goods));

        String[] arr = new String[]{"AA", "BB", "CC"};
        Arrays.sort(arr, new Comparator<String>(){
            @Override
            public int compare(String o1, String o2) {
                return -o1.compareTo(o2);
            }
        });
        System.out.println(Arrays.toString(arr));
    }
}

class Compare1 implements Comparable{
    private String name;
    private double price;

    public Compare1() {}

    public Compare1(String name, long price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public int compareTo(Object o) {
        if (o instanceof Compare1){
            Compare1 compare1 = (Compare1) o;
            if (this.price > compare1.price){
                return 1;
            }else if(this.price < compare1.price){
                return -1;
            }else{
                return this.name.compareTo(compare1.name);
            }
        }else{return 0;}
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(long price) {
        this.price = price;
    }

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