Class

常用类

包装类

包装类的分类

1.针对八种基本数据类型相应的引用类型一包装类。

2.有了类的特点，就可以调用类中的方法。

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

后面六个的父类是Number

包装类和基本数据的转换：

演示 包装类 和 基本数据类型的相互转换,这里以int 和 Integer演示

1)jdk5 前的手动装箱和拆箱方式，装箱: 基本类型->包装类型,反之，拆箱

2)jdk5 以后(含idk5) 的自动装箱和拆箱方式

3)自动装箱底层调用的是valueOf方法，比如Integer.valueOf()

包装类和String类型的相互转换

Integer类和Character类的常用方法

System.out.printIn(Integer.MIN VALUE);//返回最小值

System.out.println(Integer.MAX VALUE)😕/返回最大值

System.out.println(Character.isDigit(a'));//判断是不是数字

System.out.println(Character.isLetter(a));//判断是不是字母

System.out.println(Character.isUpperCase(a'));//判断是不是大写

System.out.println(Character.isLowerCase(a));//判断是不是小写

System.out.println(Character.isWhitespace(a'));//判断是不是空格

System.out.println(Character.toUpperCase(a'));//转成大写

System.out.println(Character.toLowerCase('A))😕/转成小写

String类

String类的理解和创建对象

1)String 对象用于保存字符串，也就是一组字符序列

2)字符串常量对象是用双引号括起的字符序列。例如:“你好”、”12.97”、"boy”等

3)字符串的字符使用Unicode字符编码(不区分字母还是汉字）占两个字节

4)String类较常用构造方法(其它看手册):

​ String s1 = new String0; //

​ String s2 = new String(String original);

​ String s3 = new String(char[] a);

​ String s4 = new String(char[] a,int startlndex,int count);

​ String s5 = new String(byte[] b);

5)String 类实现了接口Serializable ，说明String 可以串行化（可以在网络传输）

6)String类实现了接口Comparable，说明String对象可以比较

7)String是final类，不能被其他的类继承

8)String 有属性 private final char value[]; 用于存放字符串内容

9)一定要注意: value 是一个final类型，不可以修改：即value不能指向新的地址，但是单个字符内容可以更改

创建String对象的两种方式

1)方式一:直接赋值 String s ="hsp”;

2)方式二:调用构造器 String s = new String("hsp");

方式一: 先从常量池查看是否有"hsp”数据空间，如果有，直接指向;如果s最终指向的是常量池的空间地址没有则重新创建，然后指向。

方式二: 先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间如果常量池没有”hsp”，重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址。

字符串特性

String类的常用方法

String类是保存字符串常量的。每次更新都需要重新开辟空间，效率较低，因此java设计者还提供了StringBuilder 和 StringBuffer 来增强String的功能并提高效率。

equals // 区分大小写，判断内容是否相等

equalslgnoreCase //忽略大小写的判断内容是否相等

length // 获取字符的个数，字符串的长度

indexof //获取字符在字符串中第1次出现的索引,索引从0开始,如果找不到,返回-1

lastIndexof //获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到,返回-1

substring //截取指定范围的子串

trim //去前后空格

charAt:获取某索引处的字符,注意不能使用Str[index] 这种方式

toUpperCase

toLowerCase

concatreplace 替换字符串中的字符

split 分割字符串,对于某些分割字符，我们需要 转义比如|\等

compareTo //比较两个字符串的大小

toCharArray //转换成字符数组

format //格式字符串,%s 字符串 %c 字符 %d 整型 %.2f 浮点型

StringBuffer类

java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。

很多方法与String相同，但StringBuffer是可变长度的。

StringBuffer是一个容器

String VS StringBuffer

1)String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低 //private final char value[];

2)StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用更新地址，效率较高//char[] value; // 这个放在堆

StringBuffer构造器：

StringBuffer()
构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符

StringBuffer(CharSequence seq)
public java.lang.StringBuilder(CharSequence seq) 构造一个字符串缓冲区，它包含与指定的CharSequence 相同的字符。

StringBuffer(int capacity) //capacity [容量]

构造一个不带字符，但具有指定初始容量的字符串缓冲区。即对 charll 大小进行指定

StringBuffer(String str)
构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

String与StringBuffer的相互转换

//String --> StringBuffer
String str = "hello qiu";
//方式一，使用构造器
//返回的才是StringBuffer对象，对str本身没有影响
StringBuffer stringBuffer = new StringBuffer(str);
//方式二，使用的append方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str);

//StringBuffer --> String
StringBuffer stringBuffer3 = new StringBuffer("QIUUUUUUUUUUU");
//1.使用StringBuffer提供的toString方法
String s = stringBuffer3.toString();
//2.使用构造器
String s1 = new String(stringBuffer3);

StringBuffer类常见方法

1)增 append

2)删 delete(start,end)

3)改 replace(start,end,string)//将start----end 间的内容替换掉,不含end

4)查 indexof //查找子串在字符串第1次出现的索引,如果找不到返回-1

5)插insert

6)获取长度 length

测试题：

StringBuilder类

1)一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步（StringBuilder不是线程安全）。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer 要快
2)在 StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法以接受任意类型的数据。

//1.StringBuilder 继承 AbstractStringBuilder 类
//2.实现了 Serializable,说明StringBuilder对象是可以串行化(对象可以网络传输,可以保存到文件)
//3.stringBuilder 是final类，不能被继承
//4.StringBuilder 对象字符序列仍然是存放在其父类 AbstractStringBuilder的 char[] value:因此，字符序列是堆中
//5.StringBuilder 的方法，没有做互斥的处理,即没有synchronized 关键字,因此在单线程的情况下使用

String、StringBuffer 和StringBuilder的比较

1)StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且方法也一样

2)String: 不可变字符序列,效率低,但是复用率高

3)StringBuffer: 可变字符序列、效率较高(增删)、线程安全

4)StringBuilder: 可变字符序列、效率最高、线程不安全

5)String使用注意说明:

string s="a";//创建了一个字符串

s +=“b”; //实际上原来的”a"字符串对象已经丢弃了，现在又产生了一个字符串s+"b”(也就是”ab”)。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能 => 结论: 如果我们对String 做大量修改,不要使用String

使用的原则,结论:

• 如果字符串存在大量的修改操作，一般使用 StringBuffer 或StringBuilder
• 如果字符串存在大量的修改操作，并在单线程的情况，使用 StringBuilder
• 如果字符串存在大量的修改操作，并在多线程的情况,使用 StringBuffer
• 如果我们字符串很少修改，被多个对象引用，使用String,比如配置信息等

Math类

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

常用的方法：

1)abs 绝对值

2)pow 求幂

3)ceil 向上取整

4)floor 向下取整

5)round 四舍五入

6)sqrt 求开方

7)random 求随机数 //random 返回的是 0<= x < 1 之间的一个随机小数

例：返回一个2-7之间的随机整数(int)(2 +Math.random *(7 - 2 + 1))

8)max 求两个数的最大值

9)min 求两个数的最小值

Arrays类

Arrays里面包含了一系列静态方法，用于管理或操作数组(比如排序和搜索)

1)toString 返回数组的字符串形式 Arrays.toString(arr)

2)sort 排序 (自然排序和定制排序) Integer arr[] = {1, -1, 7, 0, 891}

3)binarySearch 通过二分搜索法进行查找，要求必须排好序 int index = Arrays.binarySearch(arr, 3);

4)copyOf 数组元素的复制 Integer[] newArr = Arrays.copyof(arr, arr.length);

从 arr 数组中，拷贝 arr.length个元素到 newArr数组中，若拷贝长度长了 则后面的置空 ，如果拷贝长度 < 0 就抛出异常NegativeArraySizeException

5)fill 数组元素的填充

​ Integer[] num = new Integer[]{9,3,2};

​ Arrays.fill(num,99);

​ 使用 99 去填充 num数组，可以理解成是替换原来的元素

6)equals 比较两个数组元素内容是否完全一致 boolean equals = Arrays.equals(arr, arr2):

7)asList 将一组值，转换成list

​ List asList = Arrays.asList(2,3,4,5,6,1);

​ System.out.println("asList=" + asList);

​ asList方法，会将 (2,3,4,5,6,1)数据转成一个List集合

System类

System类常见方法和案例
1)exit 退出当前程序

2)arraycopy : 复制数组元素，比较适合底层调用，一般使用Arrays.copyof完成复制数组

​ int[] src=(1,2,3);

​ int[] dest = new int[3];

​ System.arraycopy(src, 0, dest, 0, 3);

3)currentTimeMillens:返回当前时间距离1970-1-1 的毫秒数

4)gc:运行垃圾回收机制 System.gc0

BigInteger和BigDecimal类

应用场景:

1)BigInteger适合保存比较大的整型

2)BigDecimal适合保存精度更高的浮点型 (小数)

常用方法：

1. add 加
2. subtract 减
3. multiply 乘
4. divide 除

注意：在进行加减乘除的时候，需要使用对应的方法，不能直接进行+ - * /。

日期类

第一代日期类Date 类

1)Date: 精确到毫秒，代表特定的瞬间

2)SimpleDateFormat: 格式和解析日期的类SimpleDateFormat 格式化和解析日期的具体类。它允许进行格式化 (日期 -> 文本)解析 (文本 -> 日期)和规范化

Date d1 = new Date0;//获取当前系统时间
Date d2 = new Date(9234567);//通过指定毫秒数得到时间
System.out.println(d1.getTime0);//获取某个时间对应的毫秒数
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
String format = sdf.format(d1); //format:将日期转换成指定格式的字符串

String s ="1996年01月01日 10:20:30 星期一";	//待转字符串的格式要严格按照日期类型，否则会报错
Date parse = sdf.parse(s);	//将string类型的字符转为日期

第二代日期类Calendar 类

​ Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTHDAY OF MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段 (例如获得下星期的日期》提供了一些方法

Calendar c = Calendar.getInstance();//创建日历类对象//比较简单，自由
System.out.println(c);//2.获取日历对象的某个日历字段

System.out.println("年:"+c.get(Calendar.YEAR));
System.out.println("月 :"+(c.get(Calendar.MONTH)+1));		//因为CaLendar 返回月时候，是按照 0 开始编号所以+1
System.out.println("日 :"+c.get(Calendar.DAY_OF_MONTH));
System.out.println("小时:"+c.get(Calendar.HOUR));	//如果我们需要接吧，24小时进制来获取时间，Calendar.HOUR ==改成=> Calendar.HOUR OF_DAY
System.out.println("分钟:"+c.get(Calendar.MINUTE));
System.out.println("秒:"+c.get(Calendar.SECOND));//Calender 没有专门的格式化方法，所以需要程序员自己来组合显示、、System.out.println(c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH)+1)+""+c.get(Calendar.DAY_OF MONTH)+"日”)

第三代日期类

前面两代日期类的不足分析
JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar也存在问题是

1)可变性: 像日期和时间这样的类应该是不可变的

2)偏移性: Date中的年份是从1900开始的，而月份都从0开始

3)格式化: 格式化只对Date有用，Calendar则不行

4)此外，它们也不是线程安全的不能处理闰秒等(每隔2天，多出1s)

闰秒：科学上有两种时间计量系统：基于地球自转的天文测量而得出的“世界时”和以原子振荡周期确定的“原子时”。“世界时”由于地球自转的不稳定会带来时间的差异，“原子时”则是相对恒定不变的。这两种时间尺度速率上的差异，一般来说一至二年会差大约1秒时间。

1971年国际计量大会通过决议：使用“协调世界时”来计量时间。当“协调世界时”和“世界时”之差超过0.9秒时，国际地球自转服务组织(IERS)就负责对“协调世界时”拨快或拨慢1秒，这就是闰秒。

第三代日期类常见方法

1. LocalDate(日期/年月日)、LocalTime(时间/时分秒)、LocalDateTime(日期时间/年月日时分秒) JDK8加入

   LocalDate只包含日期可以获取日期字段

   LocalTime只包含时间，可以获取时间字段

   LocalDateTime包含日期+时间，可以获取日期和时间字段

LocalDateTime ldt = LocalDateTime.now(); //LocalDate.now();//LocalTime.now();
System.out.println(ldt);	//返回表示当前日期时间的对象
System.out.println("年=" + ldt.getYear());
System.out.println("月=" + ldt.getMonth());
System.out.println("月=" + ldt.getMonthValue());
System.out.println("日=" + ldt.getDayOfMonth());
System.out.println("时=" + ldt.getHour());
System.out.println("分=" + ldt.getMinute());
System.out.println("秒=" + ldt.getSecond());

2. DateTimeFormatter格式日期类
   类似于SimpleDateFormat

   DateTimeFormat dtf = DateTimeFormatter.ofPattern(格式)；

   String str = dtf.format(日期对象);

DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH小时mm分钟ss秒");
String format = dtf.format(ldt);
System.out.printin("格式化日期" + format);

3. 时间戳

类似于Date提供了一系列和Date类转换的方式

Instant——>Date:

Date date = Date.from(instant);

Date——>Instant.
Instant instant = date.tolnstant()；

//1.通过 静态方法 now() 获取表示当前时间戳的对象
Instant now = Instant.now();
System.out.println(now);
//2.通过 from 可以把 Instant转成 Date
Date date = Date.from(now);
//3.通过 date的toInstant() 可以把 date 转成Instant对象
Instant instant = date .toInstant();

LocalDateTime类

MonthDay类:检查重复事件

是否是闺年

增加日期的某个部分

使用plus方法测试增加时间的某个部分

使用minus方法测试查看一年前和一年后的日期