常用类与基础API

一、字符串相关类之不可变字符序列String

1.类的声明:

public final class String implements java.io.Serializable,Comparable<String>,CharSequence
1.final:String是不可被继承的;
2.Serializable:可序列化的接口，凡是实现此接口类的对象可以通过网络或本地流进行数据的传输;
3.Comparable:凡是实现此接口的类其对象都可以比较大小

2.内部声明的属性:

JDK8以及之前:
private final char value[];//存储字符串数据的容器;
final:指明此value数据一旦初始化其地址就不可变;
JDK9开始:
private final byte value[];//存储字符串数据的容器;

Java语言提供对字符串串联符号("+")以及将其他对象转换为字符串的特殊支持(toString()方法)

3.字符串常量的存储位置:

1.String s1 = "abc";
字符串常量存储在字符串常量池(StringTable)中,字符串常量池不允许存储两个相同的字符串常量;
字符串常量池在不同的JDK版本中位置不同,在JDK7之前字符串常量池存储在方法区,在JDK7及其之后存储在堆空间

4.String的不可变性:

(1).当对字符串变量重新赋值时，需要重新指定一个字符串常量的位置进行赋值，不能在原有的位置修改;

(2).当对现有的字符串进行拼按操作时，需要重新开辟空问保存拼接以后的字符串，不能在原有的位置修改;

(3).当调用字符串中的replace()替换现有的某个字符时，需要重新开辟空问保存拼接以后的字符串，不能在原有的位置修改;

String s1 = "hello";
String s2 = "hello";
s2 = "hi";
System.out.println(s1 == s2);//false
String s1 = "hello";
String s2 = "hello";
s2 += "hi";
System.out.println(s1 == s2);//false
String s1 = "hello";//hello
String s2 = "hello";//hello
String s3 = s2.replace('l','w');//hewwo

5.String实例化的两种方法:

1.String s1 = "abc";
2.String s2 = new String("abc");在内存空间中创建了两个对象，一个是在堆空间中new的对象，另一个是在字符串常量池中的字面量

6.String的连接操作:

1.变量+变量
2.变量+常量或常量+变量
3.常量+常量
有变量参与就会在堆空间中new一个新的对象，此时地址值会发生变化
只有常量参与字符串拼接运算,结果仍然存储在字符串常量池中,此时常量可能是字面量也可能是final修饰的常量
4.调用字符串的intern()方法
intern()方法返回字符串常量池中字面量的地址
5.调用字符串的concat()方法:
不管是常量还是变量调用此方法，同样不管参数是常量还是变量，该方法调用后会返回一个新new出来的对象
String s1 = "hello";
String s2 = "world";
String s3 = "helloworld";
String s4 = "hello"+"world";
String s5 = s1 + "world";
String s6 = "hello" + s2;
String s7 = s1 + s2;
s3 == s4;
s3 != s5;
s3 != s6;
s3 != s7;

7.String的构造器和常用方法:

(1)构造器:

1.public String():初始化新创建的String对象,以使其表示空字符序列;
2.public String(String original):初始化一个新创建的String对象,使其表示一个与参数相同的字符序列,换句话说新创建的字符串是该参数字符串的副本;
3.public String(char[] value):通过当前参数中的字符数组来构造新的String;
4.public String(byte[] bytes):通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String;
5.public String(char[] value,int offset,int count):通过字符数组的一部分来构造新的String;
6.public String(byte[] bytes,String charsetName):通过使用指定的字符集解码当前参数中的字节数组来构造新的String;

(2)常用方法:

1.boolean isEmpty():字符串是否为空;
2.int length():返回字符串的长度;
3.String concat(xx):拼接;
4.boolean equals(Object obj):比较字符串是否相等,区分大小写;
5.boolean equalsIgnoreCase(Object obj):比较字符串是否相等,不区分大小写;
6.int compareTo(String other):比较字符串大小,区分大小写,按照Unicode编码值比较大小;
7.int compareToIgnoreCase(String other):比较字符串大小,不区分大小写;
8.String toLowerCase():将字符串中大写字母转为小写;
9.String toUpperCase():将字符串中小写字母转为大写;
10.Sting trim():去掉字符串前后空白符;
11.public String intern():结果在常量池中共享;
12.boolean contains(xx):是否包含xx
13.int indexOf(xx):从前往后找当前字符串中xx,即如果有返回第一次出现的下标,要是没有返回-1
14.int indexOf(String str,int fromIndex):返回指定子字符串在此字符串中第一次出现处的素引,从指定的索引开始;
15.int lastIndexOf(xx):从后往前找当前字符串中xx,即如果有返回最后一次出现的下标,要是没有返回-1;
16.int lastIndexOf(String str,int fromIndex):返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索;
17.String subString(int beginIndex):返回一个新的字符串,它是此字符串的从beginIndex开始截取到最后的一个子字符串;
18.string subString(int beginIndex,int endIndex):返回一个新字符串,它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串;
19.char charAt(index):返回[index]位置的字符;
20.char[] toCharArray():将此字符串转换为一个新的字符数组返回;
21.static String valueOf(char[] data):返回指定数组中表示该字符序列的String;
22.static String valueOf(char[] data,int offset,int count):返回指定数组中表示该字符序列的String;
23.static String copyValueOf(char[] data):返回指定数组中表示该字符序列的String;
24.static String copyValueOf(char[] data,int offset,int count):返回指定数组中表示该字符序列的String;
25.boolean startsWith(xx):测试此字符串是否以指定的前缀开始;
26.boolean startsWith(string prefix,int toffset):测试此字符串从指定索引开始的子字符串是否以指定前缀开始
27.boolean endsWith(xx):测试此字符串是否以指定的后缀结束;
28.String replace(char oldChar, char newChar):返回一个新的字符串,它是通过newChar替换此字符串中出现的所有oldChar得到的,不支持正则;
29.String replace(charSequence target,charSequence replacement):使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串;
30.String replaceAll(String regex,String replacement):使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串;
31.String replaceFirst(String regex, String replacement):使用给定的replacement 替换此字符串匹配给定的正则表达式的第一个子字符串;

8.StringBuilder和StringBuffer:

(1)String、StringBuilder、StringBuffer对比:

String:不可变的字符串序列;底层使用char[],

StringBuilder:可变的字符串序列，线程不安全，效率高,底层使用char[]

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

(2)StringBuffer/StringBuilder的可变性分析:

对于StringBuilder来说:
内部的属性有:
char[] value;//存储字符序列,默认情况下长度为16
int count;//实际存储的字符个数
随着不断地append(),一旦count要超过value.length时，就需要扩容;
默认扩容为原有容量的2倍+2,并将原有value数组的元素复制到新的数组中

(3)源码启示:

a.如果开发中需要频繁的针对字符串进行增删改等操作，建议使用StringBuffer或StringBuilder替换String,因为使用String效率低;

b.如果开发中不涉及到线程安全问题，建议使用StringBuilder，因为StringBuilder效率更高;

c.如果开发中大体确定要操作的字符的个数，建议使用带有int capacity参数的构造器，因为可以避免底层多次扩容，性能更高;

(4)常用方法:

能够对当前调用此方法的对象进行修改，无需接收返回值，此时返回值和调用该方法的对象是同一个
1.StringBuffer append(xx):提供了很多的append()方法,用于进行字符串追加的方式拼接;
2.StringBuffer delete(int start, int end):删除[start,end)之间字符;
3.StringBuffer deleteCharAt(int index):删除[index]位置字符;
4.StringBuffer replace(int start, int end, String str):替换[start,end)范围的字符序列为str;
5.void setCharAt(int index,char c):替换[index]位置字符;
6.char charAt(int index):查找指定index位置上的字符;
7.StringBuffer insert(int index, String xx):在[index]位置插入字符串xx
8.int length():返回存储的字符数据的长度;
9.StringBuffer reverse():反转
10.int indexOf(String str):在当前字符序列中查询str的第一次出现下标；
11.int indexOf(String str, int fromIndex):在当前字符序列[fromIndex,最后]中查询str的第一次出现下标;
12.int lastIndexOf(String str):在当前字符序列中查询str的最后一次出现下标;
13.int lastlndexOf(String str, int fromIndex):在当前字符序列[fromIndex,最后]中查询str的最后一次出现下标;
14.String subString(int start):截取当前字符序列[start,最后]
15.String subString(int start,int end):截取当前字符序列[start,end)
16.String toString():返回此序列中数据的字符串表示形式
17.void setLength(int newLength):设置当前字符序列长度为newLength

(5)三者的执行增删改操作的效率:StringBuilder>StringBuffer>String

二、JKD8之前日期时间API的使用:

1.System类的currentTimeMillis()方法:

获取当前时间对应的毫秒数，long类型，时间戳，用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差；

2.两个Date类:

(1)Java.util.Date

1.构造器:
Date date1 = new Date();创建一个基于当前系统时间的Date的实例
Date date2 = new Date(long Millis);创建一个基于指定时间戳的Date的实例
2.方法:
(1)toString();打印当前毫秒值
(2)getTime();获取毫秒数，long类型

(2)Java.sql.Date(Java.util.Date的子类，对应数据库中的Date类型)

1.构造器:
Date date1 = new java.sql.Date(long Millis);创建给定时间戳的Date的实例
2.方法:
(1)toString();打印当前时间值,包含时分秒,例如Mon Dec 05 11:56:26 CST 2022
(2)getTime();获取毫秒数,结果返回值为long类型

3.SimpleDateFormat

java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化(日期变为文本)和解析(文本变为日期)日期的具体类;

1.构造器:
SimpleDateFormat():默认的模式和语言环境创建对象
public SimpleDateFormat(String pattern):该构造方法可以用参数pattern指定的格式创建一个对象
2.格式化:
public String format(Date date):方法格式化时间对象date;
3.解析:
public Date parse(String source):从给定字符串的开始解析文本,以生成一个日期;

Letter	Date or Time Component	Presentation
G	Era designator	Text
y	Year	Year
Y	Week year	Year
M	Month in Year(context sensitive)	Month
L	Month in Year(standalone form)	Month
w	Week in Year	Number
W	Week in Month	Number
D	Day in year	Number
d	Day in month	Number
F	Day of week in month	Number
E	Day name in week	Text
u	Day number of week (1=Monday,...,7=Sunday)	Number
a	Am/Pm marker	Text
H	Hour in day(0~23)	Number
k	Hour in day(1~24)	Number
K	Hour in am/pm(0~11)	Number
h	Hour in am/pm(1~12)	Number
m	Minute in Hour	Number
s	Second in Minute	Number
S	Millisecond	Number
z	Time zone	General time zone
Z	Time zone	RFC 822 time zone
X	Time zone	ISO 8601 time zone

4.Java.util.Calendar(日历)

Date类的API大部分都被弃用了，替换为Calendar，Calendar类是一个抽象类，主要用于完成日期字段之间相互操作的功能；

1.获取Calendar实例的方法:由于Calendar是一个抽象类，需要创建其子类的实例
Calendar calendar = Calendar.getInstance()
2.常用方法
(1)get(int field)
(2)set(int field,xx)
(3)add(int field,xx)
(4)getTime()
(5)setTime(Date date)使用指定的date重置Calendar
field示例:Calendar.DAY_OF_MONTH

三、JDK8中新的时间API

1.本地日期时间:LocalDate,LocalTime,LocalDateTime

now()/now(ZoneId zone):静态方法,根据当前时间创建对象/指定时区的对象;
of(xx,xx,xx,xx,xx,xxx):静态方法,根据指定日期/时间创建对象;
getDayOfMonth()/getDayOfYear():获得月份天数(1-31)/获得年份天数(1-366)
getDayOfWeek():获得星期几(返回一个DayOfWeek枚举值)
getMonth():获得月份,返回一个Month枚举值
getMonthValue()/getYear():获得月份(1-12)/获得年份
getHours()/getMinute()/getSecond():获得当前对象对应的小时、分钟、秒
withDayOfMonth()/withDayOfYear()/withMonth()/withYear():将月份天数、年份天数、月份、年份修改为指定的值并返回新的对象;
调用方法的对象不变
with(TemporalAdjuster t):将当前日期时间设置为校对器指定的日期时间
plusDays(),plusWeeks(),plusMonths(),plusYears(),plusHours():向当前对象添加几天、几周、几个月、几年、几小时;
minusMonths()/minusWeeks()/minusDays()/minusYears()/minusHours():从当前对象减去几月、几周、几天、几年、几小时
plus(TemporalAmount t)/minus(TemporalAmount t):添加或减少一个Duration或Period

2.瞬时:Instant

Instant表示时间线上的一个瞬时点，可能被用来记录应用程序中的时间时间戳;时间戳指的是格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数;java.time.Instant表示时间线上的一点，而不需要任何上下文信息;它只是简单的表示自1970年1月1日0时0分0秒(UTC)开始的秒数;

方法:
now():静态方法,返回默认UTC时区的Instant类的对象
ofEpochMilli(long epochMilli):静态方法,返回在1970-01-01 00:00:00基础上加上指定毫秒数之后的Instant类的对象;
atOffSet(ZoneOffset offset):结合即时的偏移来创建一个offSetDateTime;
toEpochMilli():返回1970-01-01 00:00:00到当前时间的毫秒数,即为时间截

3.日期时间格式化:DateTimeFormatter

用于格式化和解析LocalDate,LocalTime和LocalDateTime

ofPattern(String pattern):静态方法,返回一个指定字符串格式的DateTimeFormatter;
format(TemporalAccessor t):格式化一个日期、时间,返回字符串;
parse(CharSequence text):将指定格式的字符序列解析为一个日期、时间

4.与传统日期处理的转换:

四、Java比较器:

Java引用数据类型需要比较大小

1.实现Comparable接口，并实现该接口中的compareTo方法，在此方法中指明如何判断当前对象的大小;
如果返回值为正数:当前对象大
如果返回值为负数:当前对象小
如果返回值为0:两个对象一样大
public int compareTo(Object o){
    if(o==this)
    {
        return 0;
    }
    if(o instanceof Product){
        Product p = (Product) o;
        return Double.compareTo(this.price,o.price);
    }
    thorw new RuntimeException("类型不匹配");
}
具体步骤:
(1)具体的类A实现Comparable接口;
(2)重写Comparable接口中compareTo(Object obj)方法，在此方法中指明比较大小的具体规则
(3)创建类A的多个实例，进行大小的比较或排序
2.定制排序:java.util.Comparator
重写compare(Object obj1,Object obj2)方法,比较obj1和obj2的大小;
如果方法返回正整数,则obj1比obj2大;
如果方法返回0,则obj1和obj2相等;
如果方法返回负数,则obj1比obj2小;
Comparator comparator = new Comparator(){
    public int compare(Object o1,Object o2){
        if(o1 instanceof Product && o2 instanceof Product){
            Product p1 = (Product) o1;
            Product p2 = (Product) o2;
            return Double.compareTo(o1.price,o2.price);
        }
        thorw new RuntimeException("类型不匹配");
    }
    compare中指定两个对象的比较大小的具体规则
};
(1)创建一个实现了Comparator接口的实现类A
(2)实现类A要求重写Comaparator接口中的抽象方法compare(Object o1,Object o2),在此方法中指明排序的规则;
(3)创建此实现类的对象,并将此对象传递到相关方法的对应参数位置,比如Arrays.sort(类A的实例);
3.两种方法的比较:
(1)自然排序单一唯一、定制排序灵活多样;
(2)自然排序一劳永逸、定制排序是临时的;
(3)自然排序对应的接口是Comparable，对应的抽象方法为compareTo(Object o);定制排序对应的接口是Comparator,对应的抽象方法是compare(Object o1,Object o2);

四、其他常用类的使用:

1.java.lang.System类:

System类代表系统,系统级的很多属性和控制方法都放置在该类的内部,该类位于java.lang包;由于该类的构造器是private的，所以无法创建该类的对象。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用;

成员变量:
Scanner scan =new Scanner(System.in);
System类内部包含in、out和err三个成员变量,分别代表标准输入流(键盘输入),标准输出流(显示器)和标准错误输出流(显示器);
成员方法:
1.native long currentTimeMillis():该方法的作用是返回当前的计算机时间,时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数;
2.void exit(int status):该方法的作用是退出程序,其中status的值为0代表正常退出,非零代表异常退出,使用该方法可以在图形界面编程中实现程序的退出功能等;
3.void gc():该方法的作用是请求系统进行垃圾回收,至于系统是否立刻回收则取决于系统中垃圾回收算法的实现以及系统执行时的情况;
4.String getProperty(String key):
该方法的作用是获得系统中属性名为key的属性对应的值,系统中常见的属性名以及属性的作用如下所示:
java.version:java运行时的环境版本
java.home:java安装目录
os.name:操作系统名称
os.version:操作系统版本
user.name:用户的账号名称
user.home:用户的主目录
user.dir:用户的当前工作目录

2.Runtime类:

每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接

1.public static Runtime getRuntime():返回与当前Java应用程序相关的运行时对象,应用程序不能创建自己的Runtime类实例;
2.public long totalMemory():返回Java虚拟机中初始化时的内存总量,此方法返回的值可能随时间的推移而变化,这取决于主机环境,默认为物理电脑内存的1/64;
3.public long maxMemory():返回Java虚拟机中最大程度能使用的内存总量,默认为物理电脑内存1/4;
4.public long freeMemory():回Java虚拟机中的空闲内存量,调用gc方法可能导致freeMemory返回值的增加;

3.Math类:

java.lang.math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角的数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

1.public static double abs(double a):返回double值的绝对值;
2.public static double ceil(double a):返回大于等于参数的最小的整数;
3.public static double floor(double a):返回小于等于参数最大的整数;
4.public static long round(double a):返回最接近参数的long(相当于四舍五入方法)
5.public static double pow(double a,double b):返回a的b幂次方法;
6.public static double sqrt(double a):返回a的平方根
7.public static double random():返回[0,1)的随机数
8.public static final double PI:返回圆周率;
9.public static double max(double x, double y):返回x,y中的最大值
10.public static double min(double x, double y):返回x,y中的最小值
11.其它:acos,asin,atan,cos,sin,tan三角函数

4.Java.math包:

(1)BigInteger:

Integer类作为int的包装类，能存储的最大整型值为2^31-1，Long类也是有限的，最大为2^63-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。java.math包的BigInteger可以表示不可变的任意精度的整数。 BigInteger 提供所有Java的基本整数操作符的对应物，并提供java.lang.Math的所有相关方法。另外，BigInteger还提供以下运算:模算术、GCD计算、质数测试、素数生成、位操作以及一些其他操作;

构造器:
BigInteger(String val):根据字符串构建BigInteger对象
常用方法:
1.public BigInteger abs():返回此BigInteger的绝对值的BigInteger
2.BigInteger add(BigInteger val):返回其值为(this+val)的BigInteger
3.BigInteger subtract(BigInteger val):返回其值为(this-val)的BigInteger
4.BigInteger multiply(BigInteger val):返回其值为(this*val)的BigInteger
5.BigInteger divide(BigInteger val):返回其值为(this/val)的BigInteger,整数相除只保留整数部分;
6.BigInteger remainder(BigInteger val):返回其偵为(this % val)的BigInteger;
7.BigInteger[] divideAndRemainder(Biginteger val):返回包含(this / val)后跟(this % val) 的两个BigInteger的数组;
8.BigInteger pow(int exponent):返回其值为(this^exponent)的BigInteger;

(2)BigDecimal:

一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中要求数字精度比较高，故用到java.math.BigDecimal类;BigDecimal类支持不可变的、任意精度的有符号十进制定点数。

构造器:
1.public BigDecimal(double val)
2.public BigDecimal(String val)
常用方法:
1.public BigDecimal add(BigDecimal augend)
2.public BigDecimal subtract(BigDecimal subtrahend)
3.public BigDecimal multiply(BigDecimal multiplicand)
4.public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
divisor是除数,scale指明保留几位小数,roundingMode指明舍入模式(ROUND_UP:向上加1、ROUND_DOWN :直接舍去、ROUND_HALF_UP:四舍五入)

5.java.util.Random类:用于产生随机数

1.boolean nextBoolean():返回下一个伪随机数,它是取自此随机数生成器序列的均匀分布的boolean值;
2.void nextBytes(byte[] bytes):生成随机字节并将其置于用户提供的byte数组中;
3.double nextDouble():返回下一个伪随机数,它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布的double值;
4.float nextFloat():返回下一个伪随机数,它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布的float值;
5.double nextGaussian():返回下一个伪随机数,它是取自此随机数生成器序列的、呈高斯(“正态”)分布
的double值,其平均值是0.0,标准差是1.0;
6.int nextInt():返回下一个伪随机数,它是此随机数生成器的序列中均匀分布的int值;
7.int nextInt(int n):返回一个伪随机数,它是取自此随机数生成器序列的、在0(包括)和指定值(不包括)之间均匀分布的int值;
8.long nextLong():返回下一个伪随机数,它是取自此随机数生成器序列的均匀分布的long值;