目录
1.String
1.String的基本概念
2.String的不可变性
3.String的实例化方式及内存解析
1.两种方式
2.new+构造器的方式的内存解析
3.字符串对象的存储
4.字符串拼接后的内存解析
6.String中的常用方法
7.什么时候indexOf (str)和LastIndexOf (str)返回值相同
8.String和其他结构之间的转换
1.与包装类，基本数据类型转换
2.与char[ ]转换
3.与byte[ ]转换
9.String,StringBuffer,StringBuilder的异同
相同点
不同点
10.StringBuffer的常用方法
11.String,StringBuffer,StringBuilder的相互转换
1.String转换为StringBuffer,StringBuilder
2.StringBuffer,StringBuilder转换为String
2.日期类
1.jdk8之前的日期和时间API
1.system.currentTimeMills()
2.Date类的使用
3.SimpleDateFormat的使用
2.jdk8中日期时间API
3.Calender类的使用：抽象类
1.实例化
2.常用方法
4.instant
5.DateTimeFormatter的使用
6.编码、解码、格式化、解析
3.java比较器
1.对多个对象排序
2.Comparable接口的使用:自然排序(默认)
3.Comparator：定制排序
4.Comparable接口和Comparator对比
1.String类
1.String的基本概念
1.String是声明为final的，不可被继承
2.String实现了Serializable接口：表示字符串是支持序列化的
3.实现了Comparable接口：表示String可以比较大小
4.String内部定义：final char[] value；用于存储字符串数据
5.String：代表不可变的字符序列，简称：不可变性
6.通过字面量(区别于new)的方式给一个字符串赋值，此时字符串值声明在字符串常量池中。
7.字符串常量池中不会存储相同内容的字符串的。
2.String的不可变性
1.当对字符串重新赋值时，需要重新指定内存区域赋值，不能使用原有的value进行赋值
2.当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值
3.当调用String的replace方法修改字符或字符串时，也必须重新指定内存区域赋值
3.String的实例化方式及内存解析
1.两种方式
方式一：通过字面量定义的方式
方式二：通过new+构造器的方式
2.new+构造器的方式的内存解析
使用如下代码创建对象，在内存中创建了两个对象；在堆中的new结构，另一个是char[]对应的常量池中的数据abc
String s = new String(“abc”)3.字符串对象的存储
String s1 = "javaEE";
String s2 = "javaEE";
String s3 = new String("javaEE");
String s4 = new String("javaEE");
System.out.println(s1 == s2);//true
System.out.println(s1 == s3);//false
System.out.println(s1 == s4);//false
System.out.println(s3 == s4);//false如上代码所示，String通过字面量定义的变量位于字符串常量池中，通过new+构造器会在内存中创建两个对象：堆中的new，char[]对应的常量池数据。用以下的宋老师的图例看会更加清楚：
4.字符串拼接后的内存解析
String s1 = "hello";
String s2 = "world";
String s3 = "hello" + "world";
String s4 = s1 + "world";
String s5 = s1 + s2;
String s6 = (s1 + s2).intern();
System.out.println(s3 == s4);//false
System.out.println(s3 == s5);//false
System.out.println(s3 == s6);//false
System.out.println(s4 == s5);//true1.常量与常量的拼接在常量池中；
2.但只要其中一个为变量，结果就在堆中；
3.若使用intern()方法，则返回值在常量池中；
6.String中的常用方法
1.length()，字符串长度
2.charAt(),返回某索引出的字符
3.isEmpty，是否是空的
4.toLowerCase()，转换为小写
5.toUpperCase(),转换为大写
6.trim(),忽略字符串头部或尾部的空格
7.equalIgnoreCase (),忽略大小写比较
8.concat (),相当于+
9.compareTo (),比较两个字符串大小，负数就是当前数小，涉及到字符串排序
10.substring (),返回一个新字符串，从输入索引开始截取，若输入两个索引，那就是左闭右开的区间
11.endWith (),是否以指定后缀结束
12.startWith (),是否以指定后缀开始，区分大小写，返回布尔类型
13.contains(),当前字符串是否包含形参字符串
14.indexOf(),找到形参出现的第一个索引
15.LastIndexOf (),从后往前找形参出现的第一个索引；找不到就返回默认初始化值减一：-1
16.replace (),将所有旧字符串转换为新字符串
17.match (),确定此字符串是否匹配给定的正则表达式
18.split (),根据正则表达式拆分字符串
7.什么时候indexOf (str)和LastIndexOf (str)返回值相同
答：存在唯一的str或者不存在该str
8.String和其他结构之间的转换
1.与包装类，基本数据类型转换
String转换为包装类：Integer.parseInt(str)；
包装类转换为String：String.valueOf(i1)
Integer i1 = 123;
String s1 = "123";
Integer i2 = Integer.parseInt(s1);
String s2 = String.valueOf(i1);2.与char[ ]转换
String转换为char[ ]：调用toCharArray()
char[ ]转换为String：用String构造器,把char[ ]放进去
char[] char1 = new char[]{'a','b','c'};
String s1 = "abc";
char[] char2 = s1.toCharArray();
String s2 = new String(char1);3.与byte[ ]转换
String转换为byte[ ]（编码）：调用String的getBytes()方法
byte[ ]转换为String（解码）：调用String构造器
byte[] byte1 = new byte[]{1,2,3};
String s1 = "123";
byte[] byte2 = s1.getBytes();
String s2 = new String(byte1);若：byte转换为字符串会出现乱码，是因为编码集与解码集不一致。
其中,编码就是将字符串转换为计算机底层的二进制字节;解码就是将字节转换为字符串。
9.String,StringBuffer,StringBuilder的异同
相同点
底层都使用char[ ]存储
不同点
String:不可变的字符序列
StringBuffer:可变的字符序列；线程安全的，效率低
StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高
效率对比：StringBuilder>StringBuffer>>String
10.StringBuffer的常用方法
1.增：append(),添加字符
2.删：delete (),删除指定位置内容
3.改：replace (),替换指定位置str
4.插：insert (),在指定位置插入xxx
5.反：reverse (),将字符序列反转
setCharAt (),修改一个字符
6.查：charAt (),查询指定索引字符
7.遍历：toString ()
11.String,StringBuffer,StringBuilder的相互转换
1.String转换为StringBuffer,StringBuilder
调用StringBuffer,StringBuilder构造器
2.StringBuffer,StringBuilder转换为String
调用String构造器
2.日期类
1.jdk8之前的日期和时间API
1.system.currentTimeMills()
返回一个毫秒的时间差，通常称为时间戳，同1970.1.1.0:0:0对比
long timeMillis = System.currentTimeMillis();2.Date类的使用
1.两个包
Java.until.Date
Java.sql.Date：对应数据库中的日期类型
2.两个构造器
无参构造器Date()：创建一个当前时间Date
Date(时间戳)：创建指定毫秒数的Date
3.两个方法
toString();返回当前年月日时分秒
getTime():获取当前Date对象的毫秒数
4.util下的date和sql下date转换
将util下date.getTime()放入sql下date构造器即可
代码示例：
//关于日期的API---> Date()方法；
//两种：java.util.Date/java.sql.Date
//每一种都有两个构造器
//两种方法：toString()：返回当前日期的时分秒；getTime():获取当前对象的毫秒值
@Test
public void test(){
//1.Java.util.Date方法
Date date = new Date();
//获取当前日期的时分秒
System.out.println(date.toString());
//获取当前日期的毫秒数
System.out.println(date.getTime());
System.out.println("------------------------------------");
Date date1 = new Date(1234325214214l);
java.sql.Date date7 = new java.sql.Date(date1.getTime());
System.out.println(date7);
System.out.println(date1.toString());
System.out.println(date1.getTime());
System.out.println("-------------------------------------");
//2.java.sql.Date方法
java.sql.Date date2 = new java.sql.Date(System.currentTimeMillis());
// java.sql.Date date3 = new java.sql.Date();
String s = date2.toString();
System.out.println(s);
long time = date2.getTime();
System.out.println(time);
System.out.println("---------------------------------------");
//3.二者之间的转换：靠java.util.Date的有参构造器，形参为毫秒值
Date date3 = new Date(date2.getTime());
System.out.println(date3);
java.sql.Date date4 = new java.sql.Date(date3.getTime());
System.out.println(date4);
}
3.SimpleDateFormat的使用
1.作用
对日期Date类的格式化和解析
2.格式化与解析
格式化：format()方法:将Date对象格式化为字符串
解析：parse()方法：将字符串解析为Date对象
SimpleDateFormat s = new SimpleDateFormat();
Date date = new Date();
//格式化：转化为字符串
String s1 = s.format(date);
System.out.println(s1);
//解析：转化为Date
Date date1 = s.parse(s1);
System.out.println(date1);3.SimpleDateFormat的实例化
1.使用无参构造器造对象，使用format()方法将Date对象转换为字符串；使用pasre方法将字符串转换为日期
2.使用固定格式的有参构造器(常用)
public void test1() throws ParseException {
//第一种方式实例化
SimpleDateFormat s = new SimpleDateFormat();
Date date = new Date();
System.out.println(date);
//格式化：转化为字符串
String s1 = s.format(date);
System.out.println(s1);
//解析：转化为Date
Date date1 = s.parse(s1);
System.out.println(date1);
System.out.println("-------------------------------------------------------");
//2.第二种方式实例化(更常用)
SimpleDateFormat ss = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date date2 = new Date();
System.out.println(date2);
String s2 = ss.format(date2);
System.out.println(s2);
Date date3 = ss.parse(s2);
System.out.println(date3);
}3.解析时，字符串必须满足SimpleDateFormat格式，构造器形参格式，否则异常。
2.jdk8中日期时间API
1.获取当前日期
LocalDate、LocalTime、LocalDateTime
实例化：LocalTime.now()方法
2.设置指定的年月日时分秒
LocalTime.of()方法
3.获取年月日，getXxx()
4.不可变性：设置年月日,withDayofMonth
5.添加：plusMonths()
6.减：minusDay();
//1.获取当前日期
LocalDate l = LocalDate.now();
System.out.println(l);
LocalTime l1 = LocalTime.now();
System.out.println(l1);
LocalDateTime l2 = LocalDateTime.now();
System.out.println(l2);
//2.设置指定的日期
LocalTime l3 = LocalTime.of(5, 8);
System.out.println(l3);
//3.获取年月日
int dayOfMonth = l.getDayOfMonth();
System.out.println(dayOfMonth);
//4.不可变性
LocalDate localDate = l.withDayOfMonth(2);
System.out.println(dayOfMonth);
System.out.println(localDate.getDayOfMonth());
//5.添加
LocalDate l5 = l.plusDays(5);
System.out.println(l);//不可变性
System.out.println(l5);//24
//6.减
LocalDate localDate1 = l.minusDays(5);
System.out.println(l);
System.out.println(localDate1);//143.Calender类的使用：抽象类
1.实例化
Calender类是一个抽象类，无法实例化，通常使用Calendar.getInstance()方法来造对象。
2.常用方法
get():get(Calendar.DAY_OF_MONTH)
set():set(Calendar.DAY_OF_MONTH,22)
add():add(Calendar.DAY_OF_MONTH,3)
getTime():getTime();日历类转为Date对象
setTime():setTime();Date对象转为日历类
代码示例：
//使用Calendar.getInstance方法创建Calendar对象
Calendar c = Calendar.getInstance();
Date date1 = c.getTime();
System.out.println(date1);
//Calendar的常用方法get():获取当前日期的信息
int s1 = c.get(Calendar.DAY_OF_MONTH);
System.out.println(s1);
int s2 = c.get(Calendar.DAY_OF_WEEK);
System.out.println(s2);
int s3 = c.get(Calendar.DAY_OF_YEAR);
System.out.println(s3);
int s4 = c.get(Calendar.HOUR_OF_DAY);
System.out.println(s4);
//Calendar的常用方法set():设置当前日期信息
//注意：此时set()方法为一个void方法，因此直接将Calendar对象本身改了
c.set(Calendar.DAY_OF_MONTH,2);
int i = c.get(Calendar.DAY_OF_MONTH);
System.out.println(i);
//add()
c.add(Calendar.DAY_OF_MONTH,4);
int i1 = c.get(Calendar.DAY_OF_MONTH);
System.out.println(i1);
//getTime():将Calendar对象-->Date对象
Date time = c.getTime();
System.out.println(time);
//setTime():将Date对象-->日历类对象
Date date = new Date();
c.setTime(date);
int i3 = c.get(Calendar.DAY_OF_MONTH);
System.out.println(i3);4.instant
1.instant.now()方法：按照格林威治时间算的，会少八小时
2.添加时间偏移量：atOffset();
3.获取相应的毫秒数：instant.toEpochMilli
4.有参构造器：Instant.ofEpochMilli()
@Test
public void test1(){
Instant i1 = Instant.now();
System.out.println(i1);
OffsetDateTime i2 = i1.atOffset(ZoneOffset.ofHours(8));
System.out.println(i2);
//获取相应instant对象的毫秒数
long l = i1.toEpochMilli();
System.out.println(l);
//有参构造器（同之前一样，都是将毫秒数放入，转换为日期）
Instant i3 = Instant.ofEpochMilli(l);
System.out.println(i3);
}5.DateTimeFormatter的使用
1.自定义格式：DateTimeFormatter.ofPattern()
@Test
public void test(){
DateTimeFormatter d = DateTimeFormatter.ofPattern("yyyy-MM-dd");
LocalDateTime l = LocalDateTime.now();
System.out.println(l);
//格式化：LocalDate --> 字符串
String s = d.format(l);
System.out.println(s);
//解析：
TemporalAccessor parse = d.parse(s);
TemporalAccessor parse1 = d.parse("2023-02-19");
System.out.println(parse);
System.out.println(parse1);
}6.编码、解码、格式化、解析
编码:字符串>字节
解码: 字节 >字符串
格式化:日期 >字符串
解析:字符串 >日期
3.java比较器
1.对多个对象排序
java中的对象正常情况下只能使用:==,!=,但在开发中，我们需要对多个对象进行排序，就需要比较对象的大小。因此需要使用两种接口中的任何一个：comparable；comparator
2.Comparable接口的使用:自然排序(默认)
1.调用Arrays.sort(),Arrays.toString()即可
//第一种方式：comparable--自然排序；按照默认从大到小进行比较
@Test
public void test1(){
String[] arr = new String[]{"AA","CC","DD","BB"};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}2.像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方法。
3.String、包装类排列都是从小到大排。
4.重写compareTo(obj)规则：大于-正整数，小于-负整数，等于-0。
@Override
public int compareTo(Object o) {
if (o instanceof Person){
Person p1 = (Person) o;
if (this.getAge() > p1.getAge()){
return 1;
}else if (this.getAge() < p1.getAge()){
return -1;
}else{
return -this.getName().compareTo(p1.getName());
}
}else{
throw new RuntimeException("您输入的类型不一致！");
}
}5.对于自定义类，如果要进行排序，可以让自定义类实现Comparable接口，重写compareTo(obj)方法，指明如何排序。
3.Comparator：定制排序
匿名实现Comparator方法即可
//第二种方式：comparator--定制排序
@Test
public void test2(){
String[] arr = new String[]{"AA","CC","DD","BB"};
Arrays.sort(arr, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return -o1.compareTo(o2);
}
}
);
System.out.println(Arrays.toString(arr));
}4.Comparable接口和Comparator对比
Comparable接口方式一旦制定，保证Comparable接口实现类的对象在任何位置都能够比较大小，Comparator接口属于临时性的比较。
