【学习笔记之JavaSE】-7.常用类：比较器、String类

String类

String内部定义了final char[] value用于存储字符串数据，具有不可变性，各种增删改查操作的结果都是另开辟空间存储。
实例化方式：

方式一：通过字面量定义的方式
String s1 = "javaEE"; String s2 = "javaEE"; 
方式二：通过new + 构造器的方式
String s3 = new String("javaEE"); String s4 = new String("javaEE");

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

String s1 = "javaEEhadoop";
String s2 = "javaEE";
String s3 = s2 + "hadoop";
System.out.println(s1 == s3);//false

final String s4 = "javaEE";//s4:常量
String s5 = s4 + "hadoop";
System.out.println(s1 == s5);//true

String s6 = s3.intern();
System.out.println(s6 == s3);//true

StringBuffer

增：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()

String、StringBuffer、StringBuilder三者的异同？
String:不可变的字符序列；底层使用char[]存储
StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储
StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储

源码分析：
String str = null；//空指针，注意str.length()是不允许的，报空指针异常
StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组。
StringBuffer sb2 = new StringBuffer(“abc”);//char[] value = new char[“abc”.length() + 16];
//问题1. System.out.println(sb2.length());//3，因为类中有个count用于记录实际装了多少字符
//问题2. 扩容问题:如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中的元素复制到新的数组中。
//问题3. sb1.append(str); System.out.println(sb1.length());//4 空指针比较特殊，等同append(“null”)
注意：StringBuffer sb1 = new StringBuffer(str);是错的，源码需要执行str.length();

Date类

java.util.Date类
|—java.sql.Date类

java.util.Date date = new java.util.Date();
System.out.println(date);//Thu Feb 27 17:15:24 CST 2020   即 toString():显示当前的年、月、日、时、分、秒

// getTime():获取当前Date对象对应的毫秒数。（时间戳) 与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
//new java.util.Date().getTime()==System.currentTimeMillis() 返回当前时间

java.sql.Date date1 = new java.sql.Date(System.currentTimeMillis()); //必须要传入参数,该子类无空参构造器
System.out.println(date1);//2020-02-27

比较器

Comparable接口： 自然排序
像String、包装类重写compareTo()方法以后，进行了从小到大的排列。
重写规则：
1.如果当前对象this大于形参对象obj，则返回正整数，
2.如果当前对象this小于形参对象obj，则返回负整数，
3.如果当前对象this等于形参对象obj，则返回零。

//指明商品比较大小的方式:按照价格从低到高排序,再按照产品名称从高到低排序
    @Override   //其中Goods为自定义的类
    public int compareTo(Object o) {
//        System.out.println("**************");
        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 -this.name.compareTo(goods.name);
            }
            //方式二：
//           return Double.compare(this.price,goods.price);
        }
//        return 0;
        throw new RuntimeException("传入的数据类型不一致！");
    }

Comparator接口：定制排序
重写compare(Object o1,Object o2)方法

Arrays.sort(arr, new Comparator<Goods>() {
    @Override
    public int compare(Goods o1, Goods o2) {
        if (o1.getPrice()==o2.getPrice()) {
            return -o1.getName().compareTo(o2.getName());
        } else {
            return Double.compare(o1.getPrice(), o2.getPrice());
        }
    }
});

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