1. 字符串相关的类
1.1 String的使用
String的使用
- String声明为final的,是不可被继承。
- String实现了Serializable接口:表示字符串是支持序列化的。实现了Comparable接口:表示String可以比较大小。
- String内部定义了final char[ ] value,用于存储字符数据。
- String:代表不可变的字符序列。简称:不可变性。
- 通过字面量的方式(区别于new)给一个字符串赋值,此时的字符串值声明在字符常量池中。
- 字符常量池中是不会存储相同内容的字符串的。
为什么String是不可变的字符序列
- 当对字符串重新赋值时,需要重写指定内存区绒赋值,不能使用原有的value进行赋值。
- 当对现有的字符串进行连接操作时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。
- 当调用string的replace()方法修改指定字符或字符事时,也需要重新指定内存区城赋值,不能使用原有的value进行赋值。
1.2 String的内存解析
String实例化内存解析
- 通过字面量定义的方式
- 通过new + 构造器的方式
import org.junit.Test;
public class StringTest {
@Test
public void test1(){
//通过字面量定义的方式
String s1 = "javaEE";
String s2 = "javaEE";
//通过new + 构造器的方式
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拼接的内存解析
- 常量与常量的拼接结果在常量池。
- 只要其中有一个是变量,结果就在堆中。
- 如果拼接的结果调用intern()方法,返回值就在常量池中。
import org.junit.Test;
public class StringTest {
@Test
public void test2(){
String s1 = "javaEE";
String s2 = "hodoop";
String s3 = "javaEEhodoop";
//常量与常量的拼接结果在常量池
String s4 = "javaEE" + "hodoop";
//只要其中有一个是变量,结果就在堆中
String s5 = s1 + "hodoop";
String s6 = "javaEE" + s2;
String s7 = s1 + s2;
//如果拼接的结果调用intern()方法,返回值就在常量池中
String s8 = (s1 + s2).intern();
System.out.println(s3 == s4);//true
System.out.println(s3 == s5);//false
System.out.println(s3 == s6);//false
System.out.println(s3 == s7);//false
System.out.println(s3 == s8);//true
System.out.println(s6 == s7);//false
}
}
1.3 String中的常用方法
常用方法1
- int length():返回字符串的长度: return value.length。
- char charAt(int index):返回某索引处的字符return value[index] 。
- boolean isEmpty():判断是否是空字符串:return value.length == 0 。
- String toLowerCase():使用默认语言环境,将 String 中的所有字符转换为小写。
- String toUpperCase():**使用默认语言环境,将 String 中的所有字符转换为大写。
- String trim():返回字符串的副本,忽略前导空白和尾部空白。
- boolean equals(Object obj):比较字符串的内容是否相同。
- boolean equalsIgnoreCase(String anotherString):与equals方法类似,忽略大小写。
- String concat(String str):将指定字符串连接到此字符串的结尾。 等价于用“+” 。
- int compareTo(String anotherString):比较两个字符串的大小。
- String substring(int beginIndex):返回一个新的字符串,它是此字符串的从beginIndex开始截取到最后的一个子字符串。
- String substring(int beginIndex, int endIndex):返回一个新字符串,它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
注意:若方法对字符串进行修改,则必须有返回值接收新的字符串,原字符串不发生改变。
常用方法2
- boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束。
- boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始。
- boolean startsWith(String prefix, int toffset):测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
- boolean contains(CharSequence s):当且仅当此字符串包含指定的char值序列时,返回true。
- int indexOf(String str):返回指定子字符串在此字符串中第一次出现处的索引。
- int indexOf(String str, int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引,从指定的索引开始。
- int lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引。
- int lastIndexOf(String str, int fromIndex):返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索。
注意:indexOf和lastIndexOf方法如果未找到都是返回-1。
常用方法3
- String replace(char oldChar, char newChar):返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
- String replace(CharSequence target, CharSequence replacement):使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
- String replaceAll(String regex, String replacement):使 用 给 定 的replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
- String replaceFirst(String regex, String replacement):使 用 给 定 的replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
- boolean matches(String regex):告知此字符串是否匹配给定的正则表达式。
- String[] split(String regex):根据给定正则表达式的匹配拆分此字符串。
- String[] split(String regex, int limit):根据匹配给定的正则表达式来拆分此字符串,最多不超过limit个,如果超过了,剩下的全部都放到最后一个元素中。
1.4 String的类型转换
-
String与char[]之间的转换:
String ------> char[]:调用String的toCharArray()方法
char[] ------> String:调用String的构造器
import org.junit.Test; public class StringTest { @Test public void test2(){ //String ------> char[]:调用String的toCharArray()方法 String str1 = "abc123"; char[] charArray = str1.toCharArray(); //char[] ------> String:调用String的构造器 char[] array = new char[]{'h','o','l','l','e'}; String str2 = new String(array); } }
-
String与byte[]之间的转换:
编码:String ------> byte[]:调用String的getBytes()方法
解码:byte[] ------> String:调用String的构造器
注意:解码时,要求解码使用的字符集必须与编码时使用的字符集一致,否则会出现乱码。
import org.junit.Test; public class StringTest { @Test public void test2(){ String str1 = "abc123中国"; //编码:String ------> byte[]:调用String的getBytes()方法 byte[] bytes = str1.getBytes(); //解码:byte[] ------> String:调用String的构造器 String str2 = new String(bytes); } }
1.5 StringBuffer与StringBuilder
String、StringBuffer、StringBuilder的异同
String:不可变字符序列;底层使用char[]储存
StringBuffer:可变字符序列;线程安全的,效率低;底层使用char[]储存
StringBuilder:不可变字符序列;线程不安全的,效率高;底层使用char[]储存
效率比较:StringBuilder > StringBuffer > String
StringBuffer与StringBuilder源码分析
用String创建字符串时,有几个字符则char[]中有几个空间,因此不可变。
用StringBuffer或StringBuilder创建字符串时,默认为char[16],因此可以添加或修改。
扩容问题:如果要添加的数据底层数组盛不下了,那就需要扩容底层的数组。默认情况下,扩容为原来容量的2倍+2,同时将原有数组中的元素复制到新的数组中。
StringBuffer中的常用方法
- StringBuffer append(xxx):提供了很多的append()方法,用于进行字符串拼接
- StringBuffer delete(int start,int end):删除指定位置的内容
- StringBuffer replace(int start, int end, String str):把[start,end)位置替换为str
- StringBuffer insert(int offset, xxx):在指定位置插入xxx
- StringBuffer reverse() :把当前字符序列逆转
- public int indexOf(String str):返回字符串在当前位置首次出现的位置
- public String substring(int start,int end):返回一个从start开始从end索引结束左闭右开区间的子串
- public int length():返回字符串长度
- public char charAt(int n ):查询指定位置的字符
- public void setCharAt(int n ,char ch):修改指定位置的字符
注意:StringBuilder的方法与StringBuffer的方法类似。
2. 日期时间API
2.1 JDK8之前的时间日期API
1. java.lang.System类
System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
public class DataTimeTest {
@Test
public void test1(){
long time = System.currentTimeMillis();
System.out.println(time);
}
}
2. java.util.Date类
构造器:Date():使用无参构造器创建的对象可以获取本地当前时间。Date(long date):创建指定毫秒数的Data对象
常用方法:getTime():返回自1970年1月1日00:00:00到当前时间的毫秒数。toString():返回当前年、月、日、时、分、秒
import org.junit.Test;
import java.util.Date;
public class DataTimeTest {
@Test
public void test2(){
//构造器一:Data():创建一个对应当前时间的Data对象
Date date1 = new Date();
System.out.println(date1.toString());//Sat May 30 09:20:33 CST 2020
System.out.println(date1.getTime());//1590801633831
//构造器二:创建指定毫秒数的Dat对象
Date date2 = new Date(902338900908L);
System.out.println(date2.toString());//Thu Aug 06 01:41:40 CST 1998
}
}
3. java.sql.Date类
是java.util.Date的子类,创建new Date(long time)对象
import org.junit.Test;
import java.util.Date;
public class DataTimeTest {
@Test
public void test3(){
java.sql.Date date3 = new java.sql.Date(3889230933908L);
System.out.println(date3);//2093-03-30
}
}
4. java.text.SimpleDateFormat类
Date类的API不易于国际化,大部分被废弃了,java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类。可以将日期表现为自己定义的格式。
两个操作:①格式化:日期 ----> 字符串;②解析:格式化的逆过程,字符串 ----> 日期
import org.junit.Test;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatTest {
@Test
public void test() throws ParseException {
//实例化SimpleDateFormat:使用空参构造器
SimpleDateFormat sdf = new SimpleDateFormat();
//格式化:日期---->字符串
Date date = new Date();
String format = sdf.format(date);
System.out.println(format);//20-5-30 上午10:16
//解析:格式化的逆过程,字符串---->日期
//返回的日期是Date类对象
String str = "20-5-30 上午10:16";
Date date1 = sdf.parse(str);
System.out.println(date1);//Sat May 30 10:16:00 CST 2020
//********************按照指定方式格式化和解析:调用带参构造器***********************
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
//格式化
String format1 = sdf1.format(date);
System.out.println(format1);//2020-05-30 10:26:09
//解析
Date date2 = sdf1.parse("2020-05-30 10:26:09");
System.out.println(date2);//Sat May 30 10:26:09 CST 2020
}
}
5. java.util.Calendar(日历)类
Calendar是一个抽象基类,主用用于完成日期字段之间相互操作的功能。
import org.junit.Test;
import java.util.Calendar;
import java.util.Date;
public class CalenderTest {
@Test
public void test(){
//1.实例化
//方式一:创建其子类(GregorianCalendar)的对象,一般不使用
//方式二:调用其静态方法getInstance()
Calendar calendar = Calendar.getInstance();
//2.常用方法
//get()
//得到日期数据,DAY_OF_MONTH代表这个月的第几天
int days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);//30
//set()
//修改日期数据
calendar.set(Calendar.DAY_OF_MONTH,22);
days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);//22
//add()
//给日期数据进行增加或减小
calendar.add(Calendar.DAY_OF_MONTH,3);
days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);//25
//getTime():日历类---->Date
Date date = calendar.getTime();
System.out.println(date);//Mon May 25 11:13:32 CST 2020
//setTime():Date---->日历类
Date date1 = new Date();
calendar.setTime(date1);
days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);//18
}
}
2.2 JDK8中的时间日期API
1. LocalDate、LocalTime、LocalDateTime类
- LocalDateTime相较于LocalDate、LocalTime使用频率高
- 类似于Calendar类
import org.junit.Test;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
public class LocalDateTimeTest {
@Test
public void test(){
//now():获取当前的日期、时间、日期+时间
LocalDate localDate = LocalDate.now();
LocalTime localTime = LocalTime.now();
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println(localDate);//2020-05-31
System.out.println(localTime);//08:53:11.057
System.out.println(localDateTime);//2020-05-31T08:53:11.057
//of():设置指定的年、月、日、时、分、秒。没有偏移量
LocalDateTime localDateTime1 = LocalDateTime.of(2020,10,3,8,56);
System.out.println(localDateTime1);//2020-10-03T08:56
//getXxx():获取相关属性
System.out.println(localDateTime1.getDayOfMonth());//3
System.out.println(localDateTime1.getMonth());//OCTOBER
System.out.println(localDateTime1.getMinute());//56
//设置日期时体现不可变性
//withXxx():设置相关属性
LocalDateTime localDateTime2 = localDateTime1.withYear(2000);
System.out.println(localDateTime1);//2020-10-03T08:56
System.out.println(localDateTime2);//2000-10-03T08:56
//加:体现不可变性
LocalDateTime localDateTime3 = localDateTime1.plusHours(3);
//减:体现不可变性
LocalDateTime localDateTime4 = localDateTime1.minusMinutes(30);
}
}
2. Instant类
- 类似java.util.Date类
import org.junit.Test;
import java.time.*;
public class LocalDateTimeTest {
@Test
public void test1(){
//now():获取本初子午线对应的标准时间
Instant instant = Instant.now();
System.out.println(instant);//2020-05-31T01:36:05.436Z
//添加时间偏移量
OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
System.out.println(offsetDateTime);//2020-05-31T09:36:05.436+08:00
//toEpochMilli():获取自1970年1月1日0时0分0秒(UTC)开始的毫秒数 ----> Date类的getTime()
long milli = instant.toEpochMilli();
System.out.println(milli);//1590888965436
//ofEpochMilli():适过给定的毫秒数,获取Instant实例 ----> Date(long millis)
Instant instant1 = Instant.ofEpochMilli(2347983749948L);
System.out.println(instant1);//2044-05-27T17:42:29.948Z
}
}
3. DateTimeFormatter类
- 类似SimpleDateFormat类
import org.junit.Test;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;
public class LocalDateTimeTest {
@Test
public void test2(){
// 实例化方式一:预定义的标准格式。如:ISO_LOCAL_DATE_TIME; ISO_LOCAL_DATE; ISO_LOCAL_TIME
//格式化:日期 ----> 字符串
DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
LocalDateTime localDateTime = LocalDateTime.now();
String str1 = formatter.format(localDateTime);
System.out.println(localDateTime);//2020-05-31T10:41:08.201
System.out.println(str1);//2020-05-31T10:41:08.201
//解析:字符串 ----> 日期
TemporalAccessor parse = formatter.parse("2020-05-31T10:41:08.201");
System.out.println(parse);//{},ISO resolved to 2020-05-31T10:41:08.201
// 实例化方式二:本地化相关的格式。如:ofLocalizedDateTime(FormatStyle.LONG)
//格式化:日期 ----> 字符串
DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
String str2 = formatter1.format(localDateTime);
System.out.println(str2);//2020年5月31日 上午10时50分09秒
//解析:字符串 ----> 日期
//解码方式与方式一类似
// 重点:实例化方式三:自定义的格式。如:ofPattern(“yyyy-MM-dd hh:mm:ss”)
DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
//格式化:日期 ----> 字符串
String str3 = formatter2.format(localDateTime);
System.out.println(str3);//2020-05-31 10:53:11
//解析:字符串 ----> 日期
TemporalAccessor parse1 = formatter2.parse("2020-05-31 10:53:11");
System.out.println(parse);//{SecondOfMinute=11, NanoOfSecond=0, HourOfAmPm=10, MicroOfSecond=0, MinuteOfHour=53, MilliOfSecond=0},ISO resolved to 2020-05-31
}
4. 其他日期类
3. Java比较器
3.1 自然排序:java.lang.Comparable接口
为什么要使用这两个接口
Java中的对象,正常情况下,只能进行比较:==或!=,不能使用>或<。
但是在开发场景中,我们需要对多个对象进行排序,言外之意,就需要比较对象的大小。
因此我们可以使用两个接口中的任何一个:Comparable或Comparator来进行对象大小的比较。
非自定义类的Comparable的使用
Comparable接口使用举例:
- 像String、包装类等实现了Comparable接口,重写了compareTo(obj)方法,给出了比较两个对象大小的方式。
- 像String、包装类重写compareTo()方法以后,进行了从小到大的排列。
-
重写compareTo(obj)的规则:
- 如果当前对象this大于形参对象obj,则返回正整数,
- 如果当前对象this小于形参对象obj,则返回负整数,
- 如果当前对象this 等于形参对象0bj,则返回零。
import org.junit.Test;
import java.lang.reflect.Array;
import java.util.Arrays;
public class CompareTest {
@Test
public void test(){
String[] arr = new String[]{"AA","FF","DD","CC"};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));//[AA, CC, DD, FF]
}
}
自定义类的Comparable的使用
对于自定义类来说,如果需要排序,我们可以让自定义类实现Comparable接口,重写compareTo(obj),在compareTo(obj)方法中指明如何排序。
import org.junit.Test;
import java.util.Arrays;
public class GoodsTest {
@Test
public void test(){
Goods[] arr = new Goods[4];
arr[0] = new Goods("xiaomi",23);
arr[1] = new Goods("huawei",50);
arr[2] = new Goods("applle",100);
arr[3] = new Goods("nuojiy",60);
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
//[Goods{name='xiaomi', price=23.0}, Goods{name='huawei', price=50.0}, Goods{name='nuojiy', price=60.0}, Goods{name='applle', price=100.0}]
}
}
class Goods implements Comparable{
private String name;
private double price;
public Goods() {
}
public Goods(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Goods{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
//实现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;
}
}
throw new RuntimeException("传入的数据类型不一致");
}
}
java中Arrays.sort为什么要有Comparable接口
Arrays.sort(Object[])我们点进去可以看到有个ComparableTimSort.sort
我们再点进去sort
我们再点进去binarySort
现在我们有了答案,就是用接口定义变量来强转后引用这个数组,这样不管Objcet实际是什么类型的,都可以使用接口中定义的方法。
实现Comparable接口的对象列表(和数组)可以通过 Collections.sort或Arrays.sort进行自动排序。
3.2 定制排序:java.util.Comparator接口
Comparator的使用
出现背景:当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码,或者实现了java.lang.Comparable接口的排序规则不适合当前的操作,那么可以考虑使用Comparator的对象来排序。
重写方式:重写compare(Object o1,Object o2)方法,比较o1和o2的大小:如果方法返回正整数,则表示o1大于o2;如果返回0,表示相等;返回负整数,表示o1小于o2。
排序机制:Comparator 传递给 sort 方法(如 Collections.sort 或 Arrays.sort),从而允许在排序顺序上实现精确控制。
public class ComparatorTest {
@Test
public void test(){
String[] arr = new String[]{"AA","FF","DD","CC"};
Arrays.sort(arr, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
if(o1 instanceof String && o2 instanceof String){
String s1 = (String) o1;
String s2 = (String) o2;
return -s1.compareTo(s2);
}
throw new RuntimeException("输入的数据不一样");
}
});
System.out.println(Arrays.toString(arr));//[FF, DD, CC, AA]
}
}
3.3 两个接口的比较
Comparable接口的方式一旦实现,保证Comparable接口实现类的对象在任何位置都可以比较大小,可以多次使用。
Comparator接口属于临时性的比较,每次比较都需要重新传递参数,重写方法。
4. System类
System类介绍
System类代表系统,系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。
由于该类的构造器是private的,所以无法创建该类的对象,也就是无法实例化该类。其内部的成员变量和成员方法都是static的,所以也可以很方便的进行调用。
System类成员介绍
5. Math类
java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回值类型一般为double型。
6. BigInteger与BigDecimal
6.1 BigInteger类
Integer类作为int的包装类,能存储的最大整型值为2 31-1,Long类也是有限的,最大为2 63-1。如果要表示再大的整数,不管是基本数据类型还是他们的包装类都无能为力,更不用说进行运算了。
java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger 提供所有 Java 的基本整数操作符的对应物,并提供 java.lang.Math 的所有相关方法。
6.2 BigDecimal类
一般的Float类和Double类可以用来做科学计算或工程计算,但在商业计算中,要求数字精度比较高,故用到java.math.BigDecimal类。
BigDecimal类支持不可变的、任意精度的有符号十进制定点数。