[java]23:包装类

包装类的分类：

1) 针对八种基本数据类型相应的引用类型—包装类

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

3)如图 :

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

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

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

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

3)自动装箱底层调用的是valueOf方法，比如Integer.valueOf()4)其它包装类的用法类似，不—一举例

public class Integer01 {
public static void main(String[] args) {
//演示 int <--> Integer 的装箱和拆箱
//jdk5 前是手动装箱和拆箱
//手动装箱 int->Integer
int n1 = 100;
Integer integer = new Integer(n1);
Integer integer1 = Integer.valueOf(n1);
//手动拆箱
//Integer -> int
int i = integer.intValue();
//jdk5 后，就可以自动装箱和自动拆箱
int n2 = 200;
//自动装箱 int->Integer
Integer integer2 = n2; //底层使用的是 Integer.valueOf(n2)
//自动拆箱 Integer->int
int n3 = integer2; //底层仍然使用的是 intValue()方法
}
}

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

public class WrapperVSString {
public static void main(String[] args) {
//包装类(Integer)->String
Integer i = 100;//自动装箱
//方式 1
String str1 = i + "";
//方式 2
String str2 = i.toString();
//方式 3
String str3 = String.valueOf(i);
//String -> 包装类(Integer)
String str4 = "12345";
Integer i2 = Integer.parseInt(str4);//使用到自动装箱
Integer i3 = new Integer(str4);//构造器
System.out.println("ok~~");
}
}

Integer 类和 Character 类的常用方法：

public class WrapperMethod {
public static void main(String[] args) {
System.out.println(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 类：

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

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

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

4) String类较常用构造器(其它看手册）：

String s1 = new String();

//String s2 = new String(String original);

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

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

说明：

public class String01 {
public static void main(String[] args) {
//1.String 对象用于保存字符串，也就是一组字符序列
//2. "jack" 字符串常量, 双引号括起的字符序列
//3. 字符串的字符使用 Unicode 字符编码，一个字符(不区分字母还是汉字)占两个字节
//4. String 类有很多构造器，构造器的重载
// 常用的有 String s1 = new String(); //
//String s2 = new String(String original);
//String s3 = new String(char[] a);
//String s4 = new String(char[] a,int startIndex,int count)
//String s5 = new String(byte[] b)
//5. String 类实现了接口 Serializable【String 可以串行化:可以在网络传输】
// 接口 Comparable [String 对象可以比较大小]
//6. String 是 final 类，不能被其他的类继承
//7. String 有属性 private final char value[]; 用于存放字符串内容
//8. 一定要注意：value 是一个 final 类型， 不可以修改(需要功力)：即 value 不能指向
// 新的地址，但是单个字符内容是可以变化
String name = "jack";
name = "tom";
final char[] value = {'a','b','c'};
char[] v2 = {'t','o','m'};
value[0] = 'H';
//value = v2; 不可以修改 value 地址
}
}

创建 String 对象的两种方式：

1)方式一：直接赋值String s="hspedu";

2)方式二：调用构造器String s=new String(“hspedu“);

方式一：直接赋值 String s ="hsp";

方式二：调用构造器String s2=new String("hsp");

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

2.方式二：先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间如果常量池没有"hsp”，重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址。画出两种方式的内存分布图3.i

1)String是一个final类，代表不可变的字符序列

2）字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的

1.以下语句创建了几个对象？画出内存布局图。

String s1 = "hello";s1="haha";

//1min

//创建了2个对象.

String 类的常见方法一览：

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

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

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

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

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

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

trim//去前后空格

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

toUpperCase

toLowerCase

concatreplace 替换字符串中的字符

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

案例：String poem="锄禾日当午，汗滴禾下土,谁知盘中餐，粒粒皆辛苦"；和文件路径.

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

toCharArray//转换成字符数组

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

StringBuffer 类:

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

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

StringBuffer是一个容器。

public class StringBuffer01 {
public static void main(String[] args) {
//老韩解读
//1. StringBuffer 的直接父类 是 AbstractStringBuilder
//2. StringBuffer 实现了 Serializable, 即 StringBuffer 的对象可以串行化
//3. 在父类中 AbstractStringBuilder 有属性 char[] value,不是 final
// 该 value 数组存放 字符串内容，引出存放在堆中的
//4. StringBuffer 是一个 final 类，不能被继承
//5. 因为 StringBuffer 字符内容是存在 char[] value, 所有在变化(增加/删除)
// 不用每次都更换地址(即不是每次创建新对象)， 所以效率高于 String
StringBuffer stringBuffer = new StringBuffer("hello");
}
}

String VS StringBuffer:

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

2)StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用每次更新地址，效率较高

//char[] value；

∥/这个放在堆.

String 和 StringBuffer 相互转换:

public class StringAndStringBuffer {
public static void main(String[] args) {
//看 String——>StringBuffer
String str = "hello tom";
//方式 1 使用构造器
//注意： 返回的才是 StringBuffer 对象，对 str 本身没有影响
StringBuffer stringBuffer = new StringBuffer(str);
//方式 2 使用的是 append 方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str);
//看看 StringBuffer ->String
StringBuffer stringBuffer3 = new StringBuffer("韩顺平教育");
//方式 1 使用 StringBuffer 提供的 toString 方法
String s = stringBuffer3.toString();
//方式 2: 使用构造器来搞定
String s1 = new String(stringBuffer3);
}
}

StringBuffer 类常见方法:

public class StringBufferMethod {
public static void main(String[] args) {
StringBuffer s = new StringBuffer("hello");
//增
s.append(',');// "hello,"
s.append("张三丰");//"hello,张三丰"
s.append("赵敏").append(100).append(true).append(10.5);//"hello,张三丰赵敏 100true10.5" System.out.println(s);//"hello,张三丰赵敏 100true10.5"
//删
/*
* 删除索引为>=start && <end 处的字符
* 解读: 删除 11~14 的字符 [11, 14)
*/
s.delete(11, 14);
System.out.println(s);//"hello,张三丰赵敏 true10.5"
//改
//使用 周芷若 替换 索引 9-11 的字符 [9,11)
s.replace(9, 11, "周芷若");
System.out.println(s);//"hello,张三丰周芷若 true10.5"
//查找指定的子串在字符串第一次出现的索引，如果找不到返回-1
int indexOf = s.indexOf("张三丰");
System.out.println(indexOf);//6
//插
//老韩解读，在索引为 9 的位置插入 "赵敏",原来索引为 9 的内容自动后移
s.insert(9, "赵敏");
System.out.println(s);//"hello,张三丰赵敏周芷若 true10.5"
//长度
System.out.println(s.length());//22
System.out.println(s);
}
}

StringBuilder 类:

1)一个可变的字符序列。此类提供一个与 StringBuffer兼容的 API，但不保证同步(StringBuilder 不是线程安全）。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类因为在大多数实现中，它比 StringBuffer要快[后面测]。

2)在StringBuilder上的主要操作是append和insert方法，可重载这些方法，以接受任意类型的数据。

StringBuilder 常用方法:

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

String 、 StringBuffer 和 StringBuilder 的选择:

使用的原则，结论：

1.如果字符串存在大量的修改操作，一般使用 StringBuffer 或StringBuilder

2.如果字符串存在大量的修改操作，并在单线程的情况，使用StringBuilder

3.如果字符串存在大量的修改操作，并在多线程的情况，使用 StringBuffer

4.如果我们字符串很少修改，被多个对象引用，使用String，比如配置信息等StringBuilder 的方法使用和 StringBuffer 一样，不再说.

Math 类:

1 . 基本介绍

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

2.方法一览 ( 均为静态方法 )

Arrays 类:

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

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

2)sort排序（自然排序和定制排序） Integer arr[]={1,-1,7,0,89};

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

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

5)fill数组元素的填充

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

Arrays.fill(num, 99);

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

7)asList将一组值，转换成listList<Integer> asList = Arrays.asList(2,3,4,5,6,1);System.out.println("asList=" + asList);

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.gc();

BigInteger 和 BigDecimal 类:

应用场景：

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

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

package com.hspedu.bignum;
import java.math.BigInteger;

public class BigInteger_ {
public static void main(String[] args) {
//当我们编程中，需要处理很大的整数，long 不够用
//可以使用 BigInteger 的类来搞定
// long l = 23788888899999999999999999999l;
// System.out.println("l=" + l);
BigInteger bigInteger = new BigInteger("23788888899999999999999999999");
BigInteger bigInteger2 = new

BigInteger("10099999999999999999999999999999999999999999999999999999999999999999999999999999999");
System.out.println(bigInteger);
//解读
//1. 在对 BigInteger 进行加减乘除的时候，需要使用对应的方法，不能直接进行 + - * /
//2. 可以创建一个 要操作的 BigInteger 然后进行相应操作
BigInteger add = bigInteger.add(bigInteger2);
System.out.println(add);//
BigInteger subtract = bigInteger.subtract(bigInteger2);
System.out.println(subtract);//减
BigInteger multiply = bigInteger.multiply(bigInteger2);
System.out.println(multiply);//乘
BigInteger divide = bigInteger.divide(bigInteger2);
System.out.println(divide);//除
}
}
package com.hspedu.bignum;
import java.math.BigDecimal;

public class BigDecimal_ {
public static void main(String[] args) {
//当我们需要保存一个精度很高的数时，double 不够用
//可以是 BigDecimal
// double d = 1999.11111111111999999999999977788d;
// System.out.println(d);
BigDecimal bigDecimal = new BigDecimal("1999.11");
BigDecimal bigDecimal2 = new BigDecimal("3");
System.out.println(bigDecimal);
//解读
//1. 如果对 BigDecimal 进行运算，比如加减乘除，需要使用对应的方法
//2. 创建一个需要操作的 BigDecimal 然后调用相应的方法即可
System.out.println(bigDecimal.add(bigDecimal2));
System.out.println(bigDecimal.subtract(bigDecimal2));
System.out.println(bigDecimal.multiply(bigDecimal2));
//System.out.println(bigDecimal.divide(bigDecimal2));//可能抛出异常 ArithmeticException
//在调用 divide 方法时，指定精度即可. BigDecimal.ROUND_CEILING
//如果有无限循环小数，就会保留 分子 的精度
System.out.println(bigDecimal.divide(bigDecimal2, BigDecimal.ROUND_CEILING));
}
}

日期类:

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

2) SimpleDateFormat：格式和解析日期的类SimpleDateFormat 格式化和解析日期的具体类。它允许进行格式化（日期->文本）、解析（文本->日期）和规范化.

第二代日期类:

1)第二代日期类，主要就是 Calendar类（日历）。public abstract class Calendar extends Object implements Seriallzable,Cloneable, Comparable<Calendar>

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

public class Calendar_ {
public static void main(String[] args) {
//解读
//1. Calendar 是一个抽象类， 并且构造器是 private
//2. 可以通过 getInstance() 来获取实例
//3. 提供大量的方法和字段提供给程序员

//4. Calendar 没有提供对应的格式化的类，因此需要程序员自己组合来输出(灵活)
//5. 如果我们需要按照 24 小时进制来获取时间， Calendar.HOUR ==改成=> Calendar.HOUR_OF_DAY
Calendar c = Calendar.getInstance(); //创建日历类对象//比较简单，自由
System.out.println("c=" + c);
//2.获取日历对象的某个日历字段
System.out.println("年：" + c.get(Calendar.YEAR));
// 这里为什么要 + 1, 因为 Calendar 返回月时候，是按照 0 开始编号
System.out.println("月：" + (c.get(Calendar.MONTH) + 1));
System.out.println("日：" + c.get(Calendar.DAY_OF_MONTH));
System.out.println("小时：" + c.get(Calendar.HOUR));
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) +
" " + c.get(Calendar.HOUR_OF_DAY) + ":" + c.get(Calendar.MINUTE) + ":" + c.get(Calendar.SECOND) );
}
}

第三代日期类:

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

1）可变性：像日期和时间这样的类应该是不可变的。

2）偏移性：Date中的年份是从1900开始的，而月份都从0开始。

3）格式化：格式化只对Date有用，Calendar则不行。

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

1)LocalDate(日期/年月日）、LocalTime(时间/时分秒）、LocalDateTime(日期时间/年月日时分秒）JDK8加入LocalDate只包含日期，可以获取日期字段LocalTime只包含时间，可以获取时间字段LocalDateTime包含日期+时间，可以获取日期和时间字段

案例演示[后ppt]:

LocalDateTime ldt = LocalDateTime.now(); //LocalDate.now();//LocalTime.now()

System.out.println(ldt);Idt.getYear0;ldt.getMonthValue();ldt.getMonth();

ldt.getDayOfMonth();ldt.getHour():ldt.getMinute():ldt.getSecond():

public class LocalDate_ {
public static void main(String[] args) {
//第三代日期
//解读
//1. 使用 now() 返回表示当前日期时间的 对象
LocalDateTime ldt = LocalDateTime.now(); //LocalDate.now();//LocalTime.now()
System.out.println(ldt);
//2. 使用 DateTimeFormatter 对象来进行格式化
// 创建 DateTimeFormatter 对象
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String format = dateTimeFormatter.format(ldt);
System.out.println("格式化的日期=" + format);
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());
LocalDate now = LocalDate.now(); //可以获取年月日

LocalTime now2 = LocalTime.now();//获取到时分秒
//提供 plus 和 minus 方法可以对当前时间进行加或者减
//看看 890 天后，是什么时候 把 年月日-时分秒
LocalDateTime localDateTime = ldt.plusDays(890);
System.out.println("890 天后=" + dateTimeFormatter.format(localDateTime));
//看看在 3456 分钟前是什么时候，把 年月日-时分秒输出
LocalDateTime localDateTime2 = ldt.minusMinutes(3456);
System.out.println("3456 分钟前 日期=" + dateTimeFormatter.format(localDateTime2));
}
}

DateTimeFormatter 格式日期类:

类似于SimpleDateFormat

DateTimeFormat dtf = DateTimeFormatter.ofPattern(格式);

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

案例演示：

LocalDateTime ldt = LocalDateTime.now();

//关于DateTimeFormatter 的各个格式参数，需要看jdk8的文档.

DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH小时mm分钟ss秒“);String strDate = dtf.format(ldt);

Instant 时间戳:

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

Instant—>Date:

Date date = Date.from(instant);

Date—>Instant:

Instant instant = date.tolnstant();

案例演示：

nstant now = Instant.now();

System.out.println(now);

Date date = Date.from(now);

nstant instant = date.tolnstant();

第三代日期类更多方法:

LocalDateTime类

MonthDay类：检查重复事件

是否是闰年

增加日期的某个部分

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

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

其他的方法，使用的时候，自己查看API使用即可