一、字符串相关类

String类及常用方法

String类：

• final，不能被继承
• 不可变的字符序列。不可变是指常量池中新造字符串，不在原有字符串上改变。
  链接：字符串的不可变性
• 字符串是常量

String s1 = "hello"; //s1是变量

• String类实现了Serializable接口，表示字符串是支持序列化的；实现了Comparable接口，表示字符串是可以比较大小的。
• 两种创建方式：字面量、new。new创建的在堆中，字面量创建的在常量池中。

字面量的定义方式：直接通过" "赋值，不是用new的方式。

@Test
public void test(){
	String s1 = "abc";//字面量的定义方式
	s1 = "hello";

	System.out.println(s1);//hello
}

@Test
public void test(){
	String s1 = "abc";
	String s2 = "abc";

	System.out.println(s1 == s2);//true
	
}

常量池是不会存放相同的字符串的

注意：

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

常用方法：



String 与 char[] 之间的转换：

1. String -> char型数组：调用String的toCharArrray()方法
2. char型数组 -> String：调用String的构造器

String 与 byte[] 之间的转换：

1. String -> 字节数组：调用String的getBytes()方法
2. 字节数组 -> String：调用String的构造器

String与基本数据类型、包装类之间的转换：

1. String -> 基本、包装：调用包装类的静态方法parseXxx(str)
2. 基本、包装 -> String：调用String的valueOf(xxx)

StringBuffer、StringBuilder

比较String、StringBuffer、StringBuilder：
String：不可变的字符序列
StringBuffer：可变的字符序列，线程安全（均为synchronized的同步方法），效率低
StringBuilder：可变的字符序列，jdk1.5新增，线程不安全，效率高
相同：底层都用char[]存储

可变：

@Test
public void test(){
	StringBuffer sb1 = new StringBuffer("abc");
	sb1.setCharAt(0,'m');
}

源码分析：
String str = new String(); //new char[0]
String str1 = new String(“abc”); //new char[]{‘a’, ‘b’, ‘c’}

StringBuffer sb1 =new StringBuffer(); //new char[16]
sb1.append(‘a’); //value[0]=‘a’
sb1.append(‘b’); //value[1]=‘b’

StringBuffer sb2 = new StringBuffer(“abc”); //new char[“abc”.length+16]

System.out.println(sb2.length()); //3，打印count，而不是长度

扩容
默认情况下扩容为原来容量的2倍+2，再将原数组的元素复制到新数组中。
所以，尽量避免扩容，可以指定容量，使用StringBuffer(int capacity)或者StringBuilder(int capacity)

常用方法：


注意：涉及start和end位置的，均左闭右开

总结
增：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()
遍历：直接打印该变量 / toString()

二、JDK 8之前的日期时间API

System类

System类的静态方法currentTimeMillis()，返回当前时间与1970/1/1 00:00:00之间以毫秒为单位的时间差，称为时间戳。此方法适于计算时间差。

long time = System.currentTimeMillis();

Date类

java.util.Date
		/---java.sql.Date
//子父类

java.util.Date：

1. 两个构造器
   new Date()：创建当前时间的对象
   new Date(155030620410L)：创建某个指定时间的对象
2. 两个方法
   toString()：显示当前时间，例子：Sat Feb 16 16:35:31 GMT+08:00 2021
   getTime()：获取当前毫秒数（时间戳），例子：155030620410

java.sql.Date：
对应着数据库中的日期型变量
是子类

sql.Date对象 -> util.Date对象：直接赋值
util.Date对象 -> sql.Date对象：getTime()作为中间桥梁

Date date = new Date();
java.sql.Date date2 = new java.sql.Date(date.getTime());

SimpleDateFormat类

Date类不国际化，引入与语言环境无关的SimpleDateFormat类。

1. 对Date类的格式化和解析
   格式化：日期 -> 字符串
   解析：字符串 -> 日期
2. 实例化

public void test throws ParseException{
	Date date = new Date();

	//实例化，默认构造器（不好）
	SimpleDateFormat sdf = new SimpleDateFormat();
	//格式化
	String format = sdf.format(date);
	//解析
	String str = "21-1-11 上午11:44";//固定格式，且必须捕获异常
	Date date1 = sdf.parse(str);

	//实例化，指定格式
	SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
	//格式化
	String format1 = sdf1.format(date);
	//解析
	Date date2 = sdf1.parse(format1);//必须捕获异常
}

Calendar类

Calendar是一个抽象基类
实例化：

1. 调用Calendar.getInstance()静态方法
2. 调用子类GregorianCalendar的构造器

常用方法：
get()

int day = calendar.get(Calendar.DAY_OF_MONTH);

set()

calendar.set(Calendar.DAY_OF_MONTH,22);//返回值是void

add()

calendar.set(Calendar.DAY_OF_MONTH,3);//设置为在此值上加3，返回值是void

getTime()：日历类 -> Date类

Date date = calendar.getTime(); //返回Tue Feb 19 14:36:16 GMT+08:00 2021

setTime()：Date类 -> 日历类

Date date1 = new Date();
calendar.setTime(date1);

注意：
获取月份时，一月是0，二月是1，…，十二月是11
获取星期时，周日是1，周一是2，…，周六是7

三、JDK 8中新日期时间API

第二代Calendar的问题：(第一代Date)
可变性：calendar可变，set()、add()就可改变日期
偏移性：Date的年份从1900开始，月份从0开始
格式化：格式化只对Date有用，对Calendar不行
此外，线程不安全；不能处理闰秒

jdk8 引入第三代API：java.time
一般只用到java.time(基础包)和java.time.format(格式化解析)

本地日期LocalDate、本地时间LocalTime、本地日期时间LocalDateTime
类似于Calendar类
实例化：

1. now()：静态方法，创建当前时间的对象

LocalDate l1 = LocalDate.now(); //2021-01-11
LocalTime l2 = LocalTime.now(); //15:13:31.650(650指毫秒)
LocalDateTime l3 = LocalDateTime.now(); //2021-01-11T15:13:31.650

2. of()：静态方法，创建指定时间的对象。设置年月日时分秒，没有偏移量

LocalDateTime l = LocalDateTime.of(2020,10,6,13,23,43); 
//2020-10-06T13:23:43

获取：getXxx()

l3.getDayOfMonth();

设置：withXxx()，体现了不可变性

LocalDate l4 = l1.withDayOfMonth(22);
//注意：l1的值并未改变，l4是新值

加：plusXxx()，体现了不可变性

LocalDateTime l5 = l3.plusMonths(3); 

减：minusXxx()，体现了不可变性

LocalDateTime l6 = l3.minusDays(6); 

瞬时：Instant
类似于Date类
创建对象：
now()，静态方法，返回日期加时间，默认的时区是UTC（本初子午线）。计算世界时间的标准：UTC、GMT、CST。
再添加时间的偏移量：对象.atOffset(ZoneOffset.ofHours(8))。
方法：
toEpochMilli()：获取毫秒数，从1970年1月1日0时0分0秒（UTC）到目前时间的毫秒数。
创建对象2：
通过给定的毫秒数实例化：Instant.ofEpochMilli(1550475314878L)

格式化与解析日期时间：DateTimeFormatter
类似于SimpleDateFormat
3种实例化：

预定义的标准格式：ISO_LOCAL_DATE_TIME；ISO_LOCAL_DATE；ISO_LOCAL_TIME

DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
//格式化，日期->字符串
LocalDateTime localDateTime = LocalDateTime.now();
String str = formatter.format(localDateTime);//2019-02-18T15:42:18.797
//解析，字符串->日期
formatter.parse("2019-02-18T15:42:18.797");

本地化格式：

DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
//19-2-18 下午3:47

自定义格式：

DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss E");

其它API

四、比较器

对多个对象排序。例子，京东买鼠标，可以根据销量，价格…把商品排序。

Comparable接口
自然排序
String类、包装类等实现了Comparable接口，重写了compareTo()方法。
重写compareTo(obj)的规则：
如果this>obj，则返回正整数；
如果this<obj，则返回负整数；
如果this=obj，则返回0.
排序：Arrays.sort(arr);Collections.sort(arr);

自定义的类若要排序，需要实现Comparable接口，重写CompareTo()方法。

//指明商品比较大小的方式，按照价格由低到高
@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 Double.compare(this.price, goods.price);
	}
	throw new RuntimeException("传入的数据类型不一致！");
}

注意：instanceof的o是小写！

主程序仍旧调用Arrays.sort(arr)方法！！！此时就排序完毕了！

Comparator接口
定制排序

1. 当元素的类型没有实现Comparable接口而又不方便修改代码，
   或者实现了Comparable接口的排序规则不适合当前的操作（比如由大到小排序），
   则可以考虑Comparator排序。
2. 重写compare(Object o1, Object o2)方法，比较o1和o2的大小：
   如果o1>o2，则返回正整数；
   如果o1<o2，则返回负整数；
   如果o1=o2，则返回0.

Arrays.sort(arr, new Comparator<Goods>(){
	@Override
	public int compare(Goods o1, Goods o2){
		...
	}
});

五、System类

成员变量和方法均为static

成员变量：
in
out
err

方法：
currentTimeMillis()
exit(int status)
gc()
getProperty(String key)

六、Math类

static方法，参数和返回值一般是double型

七、BigInteger与BigDecimal

整型：
BigInteger表示不可变的任意精度的整数

浮点型：
BigDecimal支持不可变的、任意精度的、有符号的十进制定点数