Java工具类

API（Application Programming Interface）

1.包装类

Java是面向对象的语言，但其中存在基本类型，违背了面向对象的思想。

包装类是基本类型与引用类型之间交换的桥梁

类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

（1）类所在的包

java.lang，可以省略不写，所以不需要导包，直接拿来用就行。

（2）类的关系

前6个与数字相关的都默认继承父类Number。8个包装类都实现了Serializable, Comparable接口

（3）是否可以创建对象、调用

8个包装类都带有自己对应类型参数的构造方法

除了Character都存在构造方法重载，带String类型

Numer xxxvalue(); 将一个包装类类型转换为对应的基本类型

//1.5之前
Integer i1 = new Integer(10);//引用数据类型	包装类
int value = i1.intValue();

//1.5之后,自动拆箱
int value = new Integer(10);//将包装类的10等号赋值时转换为基本类型的10	
或
Integer i2 = 10;//将基本类型10自动包装成包装类

类型转化：

int value = Integer.parseInt("123");

（4）笔试中出现的问题

Integer i1 = 10;//Integer类加载时，自己的静态空间内有一个Integer[] -128----127范围的对象
Integer i2 = 10;
Integer i3 = new Integer(10);
Integer i4 = new Integer(10);
System.out.println(i1 == i2);//true
System.out.println(i1 == i3);//false
System.out.println(i3 == i4);//false
System.out.println(i1.equals(i2));//true
System.out.println(i1.equals(i3));//true
System.out.println(i3.equals(i4));//true

==号引用类型比较的是变量空间内存的内容（地址引用），如果比较的为基本类型，则比较的是变量中存储的值

euqals()被重写，比较的为两对象的值

:blonde_man:什么情况？

Integer i1 = 1000;
Integer i2 = 1000;
Integer i3 = new Integer(1000);
Integer i4 = new Integer(1000);
//特殊
System.out.println(i1 == i2);//false

System.out.println(i1 == i3);//false
System.out.println(i3 == i4);//false
System.out.println(i1.equals(i2));//true
System.out.println(i1.equals(i3));//true
System.out.println(i3.equals(i4));//true

10包装成Integer对象，在静态元素区中，当为1000时，范围超出范围，则在堆内存中new 新的对象，则 ==比较后为false

2.数学相关

1.所属的包

java.lang

2.Math构造方法是私有的，我们不能直接调用对象

3.由于Math中提供的属性及方法都是static，所以不需要创建对象

4.

random()；0。0-1.0之间的随机数（左闭右开）
abs(a)；a的绝对值

ceil()、floor()、rint()、round()；返回临近的整数

ceil()；向上取值整，返回大于或等于的整数，返回double
floor()；向下取整3.5---》3.0，返回double
rint()；返回临的最近的整数，如果距离一样就取偶数3.5---》4.0，返回double
round()；四舍五入，返回整数，返回int

max(a,b)；找寻最大值//int		long	float	double
min(a,b)；找寻最小值//int		long	float	double
pow(double a, double b)；a的b次方
sqrt(double a)；a的平方根

Math.random()计算小数时精确程度可能有所损失：

(Math.random() * 6) + 5;
(0.0---0.99999) *6
(0.0---5.499999)+5

Random类

1.所属的包

java.util，使用时需要导入

2.没有任何继承关系，默认继承Object类

3.查找构造方法–》如何创建对象

Random r = new Random();       
int num = r.nextInt();//随机产生一个整数
System.out.println(num);//默认范围为int -2147483648--2147483647  
int result = r.nextInt(10);//规定边界
System.out.println(result);//[0,10)

4.类中提供的常用方法

int result = r.nextInt(0);//规定边界

运行时异常
IllegalArgumentException
参数必须大于0

float f = r.nextFloat();//随机小数
System.out.println(f);//[0.0,1.0)，精度欠缺

double f = r.nextDouble() + r.nextInt(6) + 5;//随机小数
System.out.println(f);//[0.0,11)

nextBoolean：随机产生bool值

UUID类：

1.所属的包

java.util，使用时需要导入

2.没有任何继承关系，默认继承Object类

3.查找构造方法–》如何创建对象

构造方法有，但没有无参数的，通常不会创建对象

UUID uuid = UUID.randomUUID();//随机生成的UUID
System.out.println(uuid.toString());//32位的16进制

BigInteger类：大整数

1.所属的包

java.math，使用时需要导入

2.继承自Number

3.如何创建对象？

提供的构造方法全是带参数的，通常利用带String参数的创建这个类的对象

4.类中常用方法：做四则运算

BigInteger bigInteger1 = new BigInteger("5645453456456");BigInteger bigInteger2 = new BigInteger("1");bigInteger1.add(bigInteger2);// +
bigInteger1.subtract(bigInteger2);// -
bigInteger1.multiply(bigInteger2);// *
bigInteger1.divide(bigInteger2);// /

BigInteger bigInteger1 = new BigInteger("5645453456456");BigInteger bigInteger2 = new BigInteger("42453455343543543");BigInteger result = bigInteger1.multiply(bigInteger2);
System.out.println(result);
结果：
239669006207708337752490463608

BigDecima类：长的浮点数

1.所属包与BigInteger一样

2.继承自Number

3.如何创建对象？

提供的构造方法全是带参数的，通常利用带String参数的创建这个类的对象

4.类中常用方法：做四则运算

BigDecimal bigInteger1 = new BigDecimal("5645453456456.1");BigDecimal bigInteger2 = new BigDecimal("42453455343543543");BigDecimal result = bigInteger1.multiply(bigInteger2);
System.out.println(result);
结果：
239669006207712583098024817962.3

关于小数部分的处理：

BigDecimal bigDecimal = new BigDecimal("123.4567");
BigDecimal x = bigDecimal.setScale(2,BigDecimal.ROUND_DOWN);//保留小数点的位数，后米参数是设置的模式
System.out.println(x);
结果：
123.45

DecimalFormat:

1.所属的包

java.text，使用时需要引入

2.通过String参数的构造方法创建一个格式化对象 0、#

3.调用format方法将一个小数格式化一个字符串

DecimalFormat decimalFormat = new DecimalFormat("000.##");
String value = decimalFormat.format(1.534567486);
System.out.println(value);
结果：
001.53

3.日期相关

long m =System.currentTimeMillis();//当前时间的毫秒值（1970-1-1 00:00:00）
System.out.println(m);

Date类：

1.通常使用的是java.util包，不止一个包有，需要导包

2.创建对象

通常使用无参数的构造方法或者带long类型（毫秒）的

3.

Date date = new Date();
System.out.println(date);

结果：
Sun Jul 28 04:53:33 CST 2019

long time = System.currentTimeMillis();
Date date1 = new Date(time);
Date date2 = new Date();
System.out.println(date1.before(date2));//比较两个时间的前后
System.out.println(date1.after(date2));//比较两个时间的前后

long time = System.currentTimeMillis();
Date date1 = new Date();
date1.setTime(time);//设置时间
longSystem.out.println(date1.getTime());//获取date1的时间，毫秒值

DateFormat类（日期格式化）：

1.所属包java.text，需要导包使用

2.此类是一个抽象类，不能创建对象，通过子类来使用

3.SimpleDateFormat类，子类

Date date1 = new Date();
DateFormat l = new SimpleDateFormat();//多态
SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//规定输出格式
String s1 = s.format(date1);System.out.println(s1);

结果：
2019-07-28 05:10:53

Calendar类：

1.所属的包为java.util包，需要导包

2.创建对象

有构造方法，是用protected修饰的，通常访问不到。

调用默认的getInstance()方法，构建系统当前时间的Calendar对象

3.常用方法

after()、before()、setTime()、getTime()、

Calendar m = Calendar.getInstance();
int year = m.get(Calendar.YEAR);//年份
int month = m.get(Calendar.MONTH)+1;//月份
int day = m.get(Calendar.DAY_OF_MONTH);//天
System.out.println(year);//只获取年份
System.out.println(month);//只获取月份
System.out.println(day);//只获取天

结果：
2019
7
28

Calendar m = Calendar.getInstance();
m.set(Calendar.YEAR,1999);//更改值
int year = m.get(Calendar.YEAR);
int month = m.get(Calendar.MONTH)+1;
int day = m.get(Calendar.DAY_OF_MONTH);
System.out.println(year);//只获取年份
System.out.println(month);//只获取月份
System.out.println(day);//只获取天

结果：
1999
7
28

*4.字符串相关

String类：

1.所属的包为java.lang，无需导入

2.找寻构造方法创建对象

String是非常特殊的引用数据类型，可以向基本类型一样赋值

（1）直接将字符串常量赋值给a，（直接把引用字符串常量池）

String a = “123”;

（2）创建对象（在堆内存中创建新的对象空间）

String a = new String();//默认为空串

String a = new String(“123”);

byte[] value=new byte[]{65,97,48};//创建byte数组
String str = new String(value);//将数组中的每个数字转化为对应的字符，在将字符组合成为字符串
System.out.println(str);
结果：
Aa0

byte[] value=new byte[]{65,97,48};;
String str = new String(value,1,2);
System.out.println(str);
结果：
a0

char[] value=new char[]{'a','p','c'};//创建char数组
String str = new String(value);//将char组合成为字符串
System.out.println(str);
结果：
apc

char[] value=new char[]{'a','p','c'};
String str = new String(value,1,2);//第一个整数为偏移量，第二个是偏移个数
System.out.println(str);
结果：
pc

3.String类的特性

没有任何继承关系，实现了3个接口

---

*不可变特性：

在String类中包含一个字符数组

private final char[] value;//存储String中的每个字符

final->指向的空间不能改变，即地址不让改变，数组的长度本身不让改变

private->不能在类的外部访问，即数组中的内容无法改变

不可变特性体现 ：长度及内容不可改变

---

*5.String类中的常用方法

（1）boolean equals(Object obj);//继承自Object类，String进行了重写，

（2）int hashCode();//

public int hashCode() {    
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;
        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }        
        hash = h;
    }    
    return h;
}

（3）int = compareTo(String str);//实现自Comparable接口

str1.compareTo(str2);

按照两个字符串中长度较短的那个作为比较循环的次数，挨个比较元素

str1[i]-str2[i];

循环内如果有结果（差值不为0）直接出结果；如果循环过后发现比较的字符都一样，直接用长度减（len1-len2）

返回0表示两个字符相等

（4）String = toString();//继承自Object，重写，不再输出类名@hashCode

现在输出的字符串的字面值

（5）char = charAt(int index)；//返回给定index对应位置的那个字符

（6）int = codePointAt(int index);//返回给定index对应位置的那个字符对应的code码

（7）int = length()；//返回字符串的长度

（8）String = concat(String);//将给定的字符串拼接在当前字符串之后

（9）boolean = contains(CharSequence s)；//判断给定的s是否在字符串中

boolean a = str1.contains("23");

（10）boolean = startsWith(String prefix)/endsWith(String suffix)：判断是否以这个字符串开头/结尾

boolean a = str1.startsWith("12");
boolean a = str1.endsWith("23");

（11）getBytes()/toCharArray()：将当前的字符串转化为数组。不同的是一个返回值为byte[]，另一个为char[]

byte[] value = new byte[]{65, 97, 48};
String str1 = new String(value);
char[] a = str1.toCharArray();
System.out.println(a[0]);

结果：
A

（12）int = indexOf()：四个。找寻给定的元素在字符串中第一次出现的索引位置，返回值为下标，不存在返回-1

int = lastIndexOf()：四个。找寻给定的元素在字符串中最后一次出现的索引位置，不存在返回-1

（13）boolean = isEmpty()：判断字符串是否为空，（是否为空串，而不是null）

（14）replace()/replaceAll()：将给定的字符串替换成另外的字符串

（15）split(String regex【，int limit】)：可以添加正则表达式。按照给定的表达式将原来的字符串拆开

6.笔试中常见的问题

String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
String s4 = new String("abc");
System.out.println(s1 == s2);//true
System.out.println(s1 == s3);//false
System.out.println(s3 == s4);//false
System.out.println(s1.equals(s2));//true
System.out.println(s1.equals(s3));//true
System.out.println(s3.equals(s4));//true

将字符存储在char数组中,String对象存放在常量区中。

new String()存放在堆内存中

equals方法首先比较的为地址，地址相同值肯定相同，返回true，不同时比较值，值相同返回true,比较字符值

==（栈内存变量空间中的内容），也可以比较基本类型，也可以比较引用类型（比较的为地址）。

equals(Object类中的方法，默认==)，如果想要改变比较的规则，可以重写该方法，比如String、Integer......

---

String str = "a" + "b" + "c" + "d";

问：过程中产生了几个String对象？

答：7个

1."a"
2."b"
3."ab"
4."c"
5."abc"
6."d"
7."abcd"

+与concat()；

+不断创建新的对象

concat()不断操纵自己对象的小数组进行扩容，但这个过程没有产生新的对象，所以效率更高

StringBuffer对象，拼接效率非常高

*5.集合相关

*6.异常相关

7.输入输出相关（I/O）

8.线程相关

9.网络通信相关

10.反射注解

11.GUI