//演示 int <--> Integer 的装箱和拆箱
//手动装箱 int->Integer
int n1 = 100;
Integer integer = new Integer(n1);
Integer integer1 = Integer.valueOf(n1);
//手动拆箱
//Integer -> int
int i = integer.intValue();

（2）自动装箱、拆箱

jdk5 后，就可以自动装箱和自动拆箱

int n2 = 200;
//自动装箱 int->Integer
Integer integer2 = n2; //底层使用的是 Integer.valueOf(n2)
//自动拆箱 Integer->int
int n3 = integer2; //底层仍然使用的是 intValue()方法

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

以 Integer 和 String 转换为例，其它类似

//包装类(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);//构造器

4.Integer类和Character类的常用方法

（1）Integer常用方法

用法	作用
Integer.MIN_VALUE	返回最小值
Integer.MAX_VALUE	返回最大值

（2）Character常用方法

用法	作用
Character.isDigit('a')	判断是不是数字
Character.isLetter('a')	判断是不是字母
Character.isUpperCase('a')	判断是不是大写
Character.isLowerCase('a')	判断是不是小写
Character.isWhitespace('a')	判断是不是空格
Character.toUpperCase('a')	转成大写
Character.toLowerCase('A')	转成小写

二、String类

1.String类的说明

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

（2）"jack"是字符串常量,双引号括起的字符序列

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

（4）String类有很多构造器，构造器的重载

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

（6）String类实现了接口Comparable（String对象可以比较大小）

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

（8）String有属性private final char value[];用于存放字符串内容，字符串本质是char类型

（9）value是一个final类型，不可以修改：是value指向的数组空间地址不可修改，不是说数组里的值不可修改

final char[] value = {'a','b','c'};
char[] v2 = {'t','o','m'};
value[0] = 'H';//可以修改值
//value = v2; 不可以修改 value地址

String使用注意说明：

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

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

2.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);//传入一个字节数组，生成相应的字符串

String s6 =new String(byte[ ] b,int startIndex,int count);//传入字节数组、开始索引、字符个数，生成相应字符串

public class String01 {
    public static void main(String[] args) {
        //   常用的有 String  s1 = new String();
        String s1 = new String();
        System.out.println();//空字符串
        //String  s2 = new String(String original);
        String s2 = new String("str");
        System.out.println(s2);//str
        //String  s3 = new String(char[] a);
        char[] a = {'1', 'f', 'w'};
        String s3 = new String(a);
        System.out.println(s3);//1fw
        //String  s4 =  new String(char[] a,int startIndex,int count)
        String s4 = new String(a, 1, 1);
        System.out.println(s4);//f
    }
}

运行结果：

3.创建String对象的两种方式

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

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

两方式的区别：

方式一：先从常量池查看是否有"hsp"数据空间，如果有，直接指向；如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址
方式二：先在堆中创建空间，里面存放了value属性的地址，value指向常量池的hsp空间。如果常量池没有"hsp",重新创建，如果有，直接通过value指向。s最终指向的是堆中的空间地址。可使用s.intern()返回常量池的地址

4.字符串的特性

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

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

5.String类的常用方法

方法名	说明	使用
equals()	区分大小写，判断内容是否相等	str1.equals(str2)
equalslgnoreCase()	忽略大小写的判断内容是否相等	"john".equalsIgnoreCase(username)
length()	获取字符的个数，字符串的长度	str.length()
indexOf()	获取字符在字符串中第1次出现的索引，索引从0开始，如果找不到，返回-1	str.indexOf('@')
lastlndexOf()	获取字符在字符串中最后1次出现的索引，索引从0开始，如找不到，返回-1	str.lastIndexOf('@')
substring(int startindex,int endindex)	截取指定范围 [ startindex , endindex ) 的子串	name.substring(0,2)
trim()	去前后空格	String str1 = str.trim();
charAt()	获取某索引处的字符，注意不能使用Str[index]这种方式	char a = str1.charAt(0);
toUpperCase()	转换成大写	String str1 = str.toUpperCase()
toLowerCase()	转换成小写	String str1 = str.toLowerCase()
concat()	拼接字符串	String str1 = str.concat("林黛玉 ")
replace()	替换字符串中的字符	s1.replace(" 宝玉 ", "jack")//把字符串中所有宝玉替换成jack
split()	分割字符串，对于某些分割字符，我们需要转义比如\ //等	String[ ] split = poem.split(",")
compareTo()	比较两个字符串的大小，如果前者大，则返回正数，后者大，则返回负数，如果相等，返回 0	a.compareTo(b)
toCharArray()	转换成字符数组	char[ ] chs = s.toCharArray()
getBytes()	转换成字节数组	byte[ ] b = s.getBytes()
format()	格式字符串，%s字符串%c字符%d整型%.2f浮点型	String info2 = String.format(formatStr, name, age, score, gender);
boolean endsWith(String str)	判断字符串是否是以指定str结尾	boolean b = string.endswith(".class")

说明：

（1）以上方法对原字符串皆无影响

（2）compareTo()解读

如果长度相同，并且每个字符也相同，就返回 0
如果长度相同或者不相同，但是在进行比较时，可以区分大小就返回c1 - c2(c1!=c2)
如果前面的部分都相同，就返回 str1.len - str2.len

（3）format()解读

%s , %d , %.2f %c 称为占位符这些占位符由后面变量来替换

String formatStr = "我的姓名是%s 年龄是%d，成绩是%.2f 性别是%c.希望大家喜欢我！";
String info2 = String.format(formatStr, name, age, score, gender);

三、StringBuffer类

1.介绍

说明：

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

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

（3）StringBuffer是一个容器。

解读：

（1）StringBuffer 的直接父类是 AbstractStringBuilder

（2）StringBuffer 实现了 Serializable, 即StringBuffer的对象可以串行化，对象可以进行网络传输

（3）在父类中 AbstractStringBuilder 有属性 char[] value,不是final。该 value 数组存放字符串内容，引用存放在堆中的

（4）StringBuffer 是一个 final类，不能被继承

（5）因为StringBuffer 字符内容是存在 char[] value, 所有在变化(增加/删除)不用每次都更换地址(即不是每次创建新对象)，所以效率高于 String

2.String和StringBuffer的比较

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

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

3.StringBuffer常用构造器

(1)创建一个大小为 16的 char[] ,用于存放字符内容

StringBuffer stringBuffer = new StringBuffer();

(2)通过构造器指定 char[] 大小

StringBuffer stringBuffer1 = new StringBuffer(100);

(3)通过给一个String 创建 StringBuffer, char[] 大小就是 str.length() + 16

StringBuffer hello = new StringBuffer("hello");

3.String和StringBuffer相互转换

(1)String->StringBuffer

 String str = "hello tom";
//方式1 使用构造器
//注意： 返回的才是StringBuffer对象，对str 本身没有影响
StringBuffer stringBuffer = new StringBuffer(str);
//方式2 使用的是append方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str);

(2)StringBuffer->String

StringBuffer stringBuffer3 = new StringBuffer("韩顺平教育");
//方式1 使用StringBuffer提供的 toString方法
String s = stringBuffer3.toString();
//方式2: 使用构造器
String s1 = new String(stringBuffer3);

4.StringBuffer类的常用方法

方法名	说明	使用
append()	将内容添加到StringBuffer的后面	stringbuffer.append("wang")
delete(start,end)	删除索引为>=start&&<end处的字符（不含end）	stringbuffer.delete(11,14)
replace(start,end,string)	将start--end间的内容替换掉，不含end	stringbuffer.replace(9,11,"懒洋洋")
indexof()	查找子串在字符串第一次出现的索引，如果找不到返回-1	stringbuffer.indexOf("懒羊羊")
insert(start,string)	在索引start处插入string	stringbuffer.insert(9,"沸羊羊")
length()	获取长度	stringbuffer.length()

说明：
（1）append()方法可以添加任意类型的内容到StringBuffer中

四、StringBuilder类

1.介绍

说明：

（1）一个可变的字符序列。此类提供一个与StringBuffer兼容的APl,但不保证同步(StringBuilder不是线程安全)。该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。它比StringBuffer要快。

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

解读：

（1）StringBuilder 继承 AbstractStringBuilder 类

（2）实现了 Serializable ,说明StringBuilder对象是可以串行化(对象可以网络传输,可以保存到文件)

（3）StringBuilder 是final类, 不能被继承

（4）StringBuilder 对象字符序列仍然是存放在其父类 AbstractStringBuilder的 char[] value;因此，字符序列是堆中

（5）StringBuilder 的方法，没有做互斥的处理,即没有synchronized 关键字,因此在单线程的情况下使用

2.StringBuilder类的常用方法

StringBuilder和StringBuffer均代表可变的字符序列，方法是一样的，所以使用和StringBuffer一样。

3.String、StringBuffer 和 StringBuilder 的比较

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

（2）String:不可变字符序列，效率低，但是复用率高，可以被多个对象引用。

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

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

4.String、StringBuffer 和 StringBuilder 的效率测试

效率： StringBuilder > StringBuffer > String

测试：

public class StringVsStringBufferVsStringBuilder {
    public static void main(String[] args) {

        long startTime = 0L;
        long endTime = 0L;
        StringBuffer buffer = new StringBuffer("");

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 80000; i++) {//StringBuffer 拼接 80000次
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的执行时间：" + (endTime - startTime));
        

        StringBuilder builder = new StringBuilder("");
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 80000; i++) {//StringBuilder 拼接 80000次
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间：" + (endTime - startTime));


        String text = "";
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 80000; i++) {//String 拼接 80000
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的执行时间：" + (endTime - startTime));

    }
}

运行结果：

5.String、StringBuffer 和 StringBuilder 的选择

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

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

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

（4）如果我们字符串很少修改，被多个对象引用，使用String,比如配置信息等

五、Math类

1.介绍

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

2.Math类的常用方法

均为静态方法:即可直接通过类名.方法名使用,如Math.pow(2, 4)

方法	说明	返回值类型
pow(double a,double b)	求幂	double
ceil(double a)	向上取整	double
floor(double a)	向下取整	double
round(double a)	四舍五入	long
round(float a)	四舍五入	int
sqrt(double a)	求开方	double
random()	返回一个随机的 double 值，该值大于等于 0.0 且小于 1.0	double
abs(double a)	返回double值的绝对值	double
abs(float a)	返回float值的绝对值	float
abs(int a)	返回int值的绝对值	int
abs(long a)	返回long值的绝对值	long

其他方法可查阅javaAPI文档查看

六、Arrays类

1.Arrays类的常用方法(静态方法)

方法	说明	返回值类型
toString(arr)	返回数组的字符串形式	String
sort(arr)	排序(顺序)	void
binarySearch(arr,元素)	通过二分搜索法进行查找，要求必须排好序	int
copyOf(arr,arr.length)	数组元素的复制，拷贝arr.length个元素到数组中	array
fill(arr,99)	数组元素的填充,将数组中所有元素替换成指定元素	void
equals(arr,arr2)	比较两个数组元素内容是否完全一致	boolean
asList(1,2,3,4,5)	将一组值，转换成list	List

说明：

（1）toString效果：

Integer[] integers = {1, 20, 90};
System.out.println(Arrays.toString(integers));

运行结果：

(2)sort定制排序(逆序)：

Integer arr[] = {1, -1, 7, 0, 89};
Arrays.sort(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer) o1;
                Integer i2 = (Integer) o2;
                return i1 - i2;
            }
        });

Comparater接口的返回值i1-i2的正负影响排序顺序

（3）binarySearch(arr,元素)查找元素，存在返回索引值，不存在返回-(应该在的位置的索引+1)

七、System类

1.System类的常用方法

方法	说明	使用
exit(status)	退出当前程序	System.exit(0)
arraycopy(src,srcPos,dest,destPos,length)	复制数组元素，比较适合底层调用，一般使用Arrays.copyOf完成复制数组	System.arraycopy(src,0,dest,0,3)
currentTimeMillens()	返回当前时间距离1970-1-1的毫秒数	System.currentTimeMillens()
gc()	运行垃圾回收机制	System.gc()

说明：

（1）exit(0)中的0表示正常状态

（2）arraycopy(src,srcPos,dest,destPos,length)中各参数的含义

src：源数组

srcPos：从源数组的哪一个索引开始拷贝

dest：目标数组

destPos：把源数组的元素拷贝到目标数组的哪个索引

length：从源数组拷贝多少个元素到目标数组

八、BigInteger和BigDecimal类

1.BigInteger和BigDecimal的介绍

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

创建对象：BigInteger bigInteger = new BigInteger("23788888899999999999999999999");

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

创建对象：BigDecimal bigDecimal = new BigDecimal("1999.11");

2.BigInteger和BigDecimal的常用方法

BigInteger和BigDecimal 进行加减乘除的时候，需要使用对应的方法，不能直接进行 + - * /

方法	说明	使用
add	加	BigInteger add = bigInteger.add(bigInteger2)
subtract	减	BigInteger subtract = bigInteger.subtract(bigInteger2)
multiply	乘	BigInteger multiply = bigInteger.multiply(bigInteger2)
divide	除	BigInteger divide = bigInteger.divide(bigInteger2)

说明：

（1）在对BigDecimal调用 divide 方法时，如果是无限循环小数会抛出异常，可以指定精度 BigDecimal.ROUND_CEILING

System.out.println(bigDecimal.divide(bigDecimal2, BigDecimal.ROUND_CEILING))

结果：保留与除数相同精度的位数

九、日期类

1.第一代日期类

（1）介绍

Date:精确到毫秒，代表特定的瞬间。在java.util包
SimpleDateFormat:格式和解析日期的类。它允许进行格式化(日期->文本)、解析(文本->日期)和规范化.

字母	日期或时间元素	表示	示例
g	Era标志符	Text	AD
y	年	Year	1996;96
M	年中的月份	Month	July;Jul;07
w	年中的周数	Number	27
W	月份中的周数	Number	2
D	年中的天数	Number	189
d	月份中的天数	Number	10
F	月份中的星期	Number	2
E	星期中的天数	Text	Tuesday;Tue；星期三
a	Am/pm标记	Text	PM
H	一天中的小时数(0-23)	Number	0
k	一天中的小时数(1-24)	Number	24
K	am/pm中的小时数(0-11)	Number	0
h	am/pm中的小时数(1-12)	Number	12
m	小时中的分钟数	Number	30
s	分钟中的秒数	Number	55
S	毫秒数	Number	978

（2）使用

1）获取当前系统时间，默认输出的日期格式是国外的方式

Date d1 = new Date(); //获取当前系统时间
System.out.println("当前日期=" + d1);

效果：

2）创建 SimpleDateFormat对象，可以指定相应的格式

Date d1 = new Date(); //获取当前系统时间
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
String format = sdf.format(d1); // format:将日期转换成指定格式的字符串
System.out.println("当前日期=" + format);

效果：

3）通过指定毫秒数得到时间

Date d2 = new Date(9234567); 
System.out.println("d2=" + d2);

效果：

4）把一个格式化的String 转成对应的 Date

得到的Date在输出时，还是按照国外的形式，如果希望指定格式输出，需要转换

在把String -> Date ，使用的 sdf 格式需要和你给的String的格式一样，否则会抛出转换异常

String s = "1996年01月01日 10:20:30 星期一";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
Date parse = sdf.parse(s);//在输出时，还是按照国外的形式
System.out.println("parse=" + sdf.format(parse));//转换成指定形式

效果：

2.第二代日期类

（1）介绍

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

（2）使用

Calendar 是一个抽象类，并且构造器是 private，可以通过 getInstance() 来获取实例

1）获取日历对象的某个日历字段

Calendar c = Calendar.getInstance(); //创建日历类对象
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));
//如果需要按照 24小时进制来获取时间，Calendar.HOUR 改成 Calendar.HOUR_OF_DAY
System.out.println("小时：" + c.get(Calendar.HOUR));
System.out.println("分钟：" + c.get(Calendar.MINUTE));
System.out.println("秒：" + c.get(Calendar.SECOND));

效果：

2）Calender 没有专门的格式化方法，需要自己来组合显示

Calendar c = Calendar.getInstance();
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) )

效果：

3.第三代日期类

（1）前面两代日期类的不足分析

JDK1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK1.1引入Calendar类之后被弃用了。而Calendar也存在问题是：

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

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

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

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

（2）第三代日期类介绍

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

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

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

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

（3）使用

1）使用now() 返回表示当前日期时间的对象

LocalDateTime ldt = LocalDateTime.now(); //LocalDate.now();//LocalTime.now()
System.out.println(ldt);

效果：

2）得到单个日期时间的字段

LocalDateTime ldt = LocalDateTime.now();
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());

效果：

（4）DateTimeFormatter 格式日期类

使用形式：

DateTimeFormat dtf =DateTimeFormatter.ofPattern(格式);

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

示例：

LocalDateTime ldt = LocalDateTime.now();
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String format = dateTimeFormatter.format(ldt);
System.out.println("格式化的日期=" + format);

效果：

（5）Instant 时间戳

类似于Date

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

Instant——>Date：Date date =Date.from(instant);

Date——>InstantI：nstant 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();

（6）第三代日期类常用方法

这里只演示plus与minus，其他方法使用时查看API即可

1）提供 plus 和 minus方法可以对当前时间进行加或者减

LocalDateTime ldt = LocalDateTime.now();
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

//看看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));

效果：

标签

#java #开发语言