针对8种基本数据类型相应的引用类型—包装类
有了类的特点，就可以调用类的方法。
如图：
| 基本数据类型 | 包装类 |
|---|---|
| boolean | Boolean |
| char | Character |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
- 继承体系图：
public class Integer01 {
public static void main(String[] args) {
//演示int 《--》Integer 的装箱和拆箱
//jdk5前是手动装箱和拆箱
//手动装箱
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.ValuesOf(n2);
//自动拆箱 Integer <--> int
int n3 = integer2; //底层使用的是intValue();
}
}
1.1.3课堂测试题
1.1.4包装类型和 String 类型的相互转换
public class WrapperVSString {
public static void main(String[] args) {
//包装类（Integer）-->String
Integer i1 = 100;//自动装箱
//方式1
String str1 = i1 + "";
//方式2
String str2 = i1.toString();
//方式3
String str3 = String.valueOf(i1);
//String ->包装类（Integer）
String str4 = "123";
Integer i2 = Integer.parseInt(str4);//使用到自动装箱
Integer integer = new Integer(str4);//构造器
System.out.println("ok");
}
}
1.1.5Integer 类和 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'));//转成小写
}
}
1.1.6练习题：
代码演示：
public class WrapperExcrsise02 {
public static void main(String[] args) {
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j); //False
// 所以，这里主要是看范围 -128 ~ 127 就是直接返回
//
Integer m = 1; //底层 Integer.valueOf(1); -> 阅读源码
Integer n = 1;//底层 Integer.valueOf(1);
System.out.println(m == n); //T
// 所以，这里主要是看范围 -128 ~ 127 就是直接返回
// ，否则，就 new Integer(xx);
Integer x = 128;//底层 Integer.valueOf(1);
Integer y = 128;//底层 Integer.valueOf(1);
System.out.println(x == y);//False
}
}
代码演示：
public class WrapperExercise03 {
public static void main(String[] args) {
public static void main (String[]args){
//示例一
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2);//F
// 示例二
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3 == i4);//F
// 示例三
Integer i5 = 127;//底层Integer.valueOf(127) ;
Integer i6 = 127;//-128~127
System.out.println(i5 == i6); //T
// 示例四
Integer i7 = 128;
Integer i8 = 128;
System.out.println(i7 == i8);//F
// 示例五
Integer i9 = 127; //Integer.valueOf(127)
Integer i10 = new Integer(127);
System.out.println(i9 == i10);//F
// 示例六
Integer i11=127;
int i12=127; //只有有基本数据类型，判断的是
// 值是否相同
System.out.println(i11==i12); //T
// 示例七
/Integer i13=128;
int i14=128;
System.out.println(i13==i14);//T
}
}
}
1.2 String
1.2.1String类的理解和创建对象
代码演示：
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 有属性 public final char value[];用于存放字符串内容
//8.一定要注意：value是final类型 ，复制后就不能更改（）：即value不能指向新的地址，
// 但是单个字符内容是可以变化
String name = "jack";
name = "tom";
final char[] value = {'a','b','c'};
char[] v2 = {'t','o'};
value[0] = 'd';
//value = v2; 会报错，不可以修改value的地址
}
}
1.2.2 创建 String 对象的两种方式
1.2.3 两种创建 String 对象的区别
1.2.4 课堂测试
对应示意图：
重要
1.2.5 字符串的特性代码演示：
public class StringExercise08 {
public static void main(String[] args) {
String a = "hello"; //创建a对象
String b = "abc"; //创建b对象
//解读
//1.先创建一个 StringBuilder sb = StringBuilder（）；
//2.执行 sb.append("hello");
//3.sb.append("abc");
//4.String c = sb.toString()
//其实最后 c 指向堆中对象（String） value[] ->池中"helloabc"
String c = a+b;
}
}
代码演示：
public class StringExercise10 {
public static void main(String[] args) {
Test1 ex = new Test1();
ex.change(ex.str, ex.ch);
System.out.println(ex.str + "and");
System.out.println(ex.ch);
}
}
class Test1{
String str = new String("hsp");
final char[] ch = {'j','a','v','a'};
public void change(String str ,char ch[]){
str = "java";
ch[0] = 'h';
}
}
在调用方法时，这里str传入的是对象地址值，ch[]也是。str是指向堆中的地址值，里面维护了一个value属性。value指向常量池中new对象时创建的字符串“hsp”
进入方法时，传值时这里是形参str指向实参ex.str指向的地址值，所以这里的形参指向的是堆中的拥有value属性的空间，这个空间指向的是常量池中的hsp。传值时形参ch[]也是和str一样的道理，也指向堆中数组的地址值。
进入方法， 形参str的指向改变，从指向堆中的地址，改为指向常量池中的“java”，ch[0]=‘h’，改变了数组中下标为0的字符的值，实质上改变了数组内的数值。change（）方法结束后，从栈中退出，所有东西回收。继续执行main方法，sout（ex.str +“and”）这里的str还是Test1中的属性，指向的还是以前的地址，所以这里输出的时hsp。sout（ex.ch）这里还是Test1中的属性，指向的堆中的数组，现在数组的值为hava。所以输出hspand hava
记住：在传递地址值时，形参改变，实参不改变。
1.3 String 类的常见方法 1.3.1 说明 1.3.2 String 类的常见方法一览第一组：
| 方法名 | 描述 |
|---|---|
| equals | 区分大小写，判断内容是否相等 |
| equalslgnoreCase | 忽略大小写，判断内容是否相等 |
| length | 获取字符的个数，字符串的长度 |
| indexOf | 获取字符在字符串中第一次出现的索引，索引从0开始，如果找不到返回-1。 |
| lastIndexOf | 获取字符在字符串中最后一次出现的索引，索引从0开始，如果找不到返回-1。 |
| sybstring | 截取指定范围的字串 |
| trim | 去前后空格 |
| charAt | 获取某索引处的字符，注意不能使用Str[index]这种方式 |
代码演示：
public class StringMethod01 {
@SuppressWarnings({"all"})//抑制所有警告
public static void main(String[] args) {
//1. equals 前面已经讲过了. 比较内容是否相同，区分大小写
String str1 = "hello";
String str2 = "Hello";
System.out.println(str1.equals(str2));
// 2.equalsIgnoreCase 忽略大小写的判断内容是否相等
String username = "johN";
if ("john".equalsIgnoreCase(username)) {
System.out.println("Success!");
} else {
System.out.println("Failure!");
}
// 3.length 获取字符的个数，字符串的长度
System.out.println("韩顺平".length());
// 4.indexOf 获取字符在字符串对象中第一次出现的索引，索引从 0 开始，如果找不到，返回-1
String s1 = "wer@terwe@g";
int index = s1.indexOf('@');
System.out.println(index);//3
System.out.println("weIndex=" + s1.indexOf("we"));//0
// 5.lastIndexOf 获取字符在字符串中最后一次出现的索引，索引从 0 开始，如果找不到，返回-1
s1 = "wer@terwe@g@";
index = s1.lastIndexOf('@');
System.out.println(index);//11
System.out.println("ter 的位置=" + s1.lastIndexOf("ter"));//4
// 6.substring 截取指定范围的子串
String name = "hello,张三123"; //下面
// name.substring(6) 从索引 6 开始截取后面所有的内容
System.out.println(name.substring(6));//截取后面的字符
//name.substring(0,5)表示从索引 0 开始截取，截取到索引 5-1=4 位置
System.out.println(name.substring(2,5));//llo 左闭右开
}
}
第二组：
代码演示：
public class StringMethod02 {
public static void main(String[] args) {
// 1.toUpperCase 转换成大写
String s = "heLLo";
System.out.println(s.toUpperCase());//HELLO
//2.toLowerCase 转成小写
System.out.println(s.toLowerCase());//hello
//3.concat拼接字符串
String s1 = "宝玉";
s1 = s1.concat("你好").concat("芜湖");
System.out.println(s1);//宝玉你好芜湖
//4.replace 替换字符串中的字符
s1 = "宝玉 and 林黛玉 林黛玉 林黛玉 林黛玉";
//在s1中将所有的 林黛玉 换成 薛宝钗
s1.replace("林黛玉", "薛宝钗");
//老韩解读: s1.replace() 方法执行后，返回的结果才是替换过的.
//注意对 s1 没有任何影响
s1 = s1.replace("林黛玉", "薛宝钗");
System.out.println(s1);
// 5.split 分割字符串, 对于某些分割字符，我们需要 转义比如 | \等
String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
//老韩解读：
// (1). 以 , 为标准对 poem 进行分割 , 返回一个数组
String[] split = poem.split(",");
for (int i = 0; i < split.length; i++) {
System.out.println(split[i]);
}
// (2). 在对字符串进行分割时，如果有特殊字符，需要加入 转义符
System.out.println("====================");
poem = "E:\aaa\bbb";
split = poem.split("\\");
for (int i = 0; i < split.length; i++) {
System.out.println(split[i]);
}
//6.toCharArray 转换字符数组
s = "happy";
char[] chs = s.toCharArray();
for (int i = 0; i < chs.length; i++) {
System.out.print(chs[i] + "t");//h a p p y
}
// 7.compareTo 比较两个字符串的大小，如果前者大，
// 则返回正数，后者大，则返回负数，如果相等，返回 0
// 老韩解读
// (1) 如果长度相同，并且每个字符也相同，就返回 0
// (2) 如果长度相同或者不相同，但是在进行比较时，可以区分大小
// 就返回 if (c1 != c2) {
// return c1 - c2; // }
// (3) 如果前面的部分都相同，就返回 str1.len - str2.len
String a = "aaah";
String b = "aaa";
System.out.println(a.compareTo(b));//1
// 8.format 格式字符串
String name = "john";
int age = 10;
double score = 56.857;
char gender = '男';
//将所有的信息拼接到一个字符串
String info = "我的姓名是" + name + "年龄是" + age + ",成绩是" + score + "性别是" + gender + "。希望大家喜欢我！ ";
//老韩解读 //1. %s , %d , %.2f %c 称为占位符
// 2. 这些占位符由后面变量来替换
// 3. %s 表示后面由 字符串来替换
// 4. %d 是整数来替换
// 5. %.2f 表示使用小数来替换，替换后，只会保留小数点两位, 并且进行四舍五入的处理
// 6. %c 使用 char 类型来替换
String formatStr = "我的姓名是%s 年龄是%d，成绩是%.2f 性别是%c.希望大家喜欢我！";
String info2 = String.format(formatStr,name,age,score,gender);
System.out.println(info2);//我的姓名是john 年龄是10，成绩是56.86 性别是男.希望大家喜欢我！
}
}
1.4 StringBuffer 类
1.4.1基本介绍
代码演示：
public class StringBuffer01 {
public static void main(String[] args) {
//1.StringBuffer 的直接父类是 AbstractStringBuffer
//2.StringBuffer 实现了Serializable ,即StringBuffer对象可以串行化
//3.在父类中 AbstractStringBuffer 有属性 char[] value,不是final
// 该value数组存放 字符串类容，应是存放在堆中的。
//4.StringBuffer是一个final类，不能被继承
//5.因为StringBuffer 字符串内容是存在 char[] value,所以在变化（增加删除）
// 不用每次都更换地址（即不是每次都创建新对象），所以效率高于String
StringBuffer hsp = new StringBuffer("hsp");
}
}
String VS StringBuffer
StringBuffer的构造器
public class StringBuffer02 {
public static void main(String[] args) {
//构造器的使用
//1.创建一个大小为16的 char[],用于存放字符内容
StringBuffer stringBuffer1 = new StringBuffer();
//2.通过构造器指定char[]大小
StringBuffer stringBuffer2 = new StringBuffer(100); //cahr[100]
//3. 通过 给一个String 创建一个 StringBuffer,char[] 大小就是str.length() +16
StringBuffer stringBuffer3 = new StringBuffer("hello");
}
}
1.4.2 String 和 StringBuffer 相互转换
public class StringAndStringBuffer {
public static void main(String[] args) {
//看String——>StringBuffer
String str = "hello Tom";
//方式一，使用构造器
//注意：返回的才是 StringBuffer 对象，对str 本身没有影响
StringBuffer stringBuffer = new StringBuffer(str);
//方式2使用的是append方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer.append(str);
//看看 StringBuffer-->String
StringBuffer stringBuffer2 = new StringBuffer("hsp");
//方式一：使用 StringBuffer 提供的 toString方法
String s = stringBuffer2.toString();
//方式二：使用构造器
String s1 = new String(stringBuffer2);
}
}
1.4.3 StringBuffer 类常见方法
代码演示：
public class StringBufferMethod01 {
public static void main(String[] args) {
StringBuffer s = new StringBuffer("hello");
//1.增
s.append(',');// "hello,"
s.append("张三丰");//"hello,张三丰
s.append("赵敏").append(100).append(true).append(10.5);//"hello,张三丰赵敏 100true10.5"
s.append("你好").append("world").append(100.2);
System.out.println(s); //"hello,张三丰赵敏 100true10.5
//2.删
s.delete(11,14);
System.out.println(s); //hello,张三丰赵敏100t10.5你好world100.2
s.delete(0,10);
System.out.println(s);//敏100t10.5你好world100.2
//3.改
// 老韩解读，使用 周芷若 替换 索引 9-11 的字符 [9,11)
s.replace(9,11,"周芷若");
System.out.println(s);//敏true10.5周芷若world100.2
//4.查找指定的子串在字符串第一次出现的索引，如果找不到返回-1
int indexOf = s.indexOf("周芷若");
System.out.println(indexOf); //9
//5.插入
//老韩解读，在索引为 9 的位置插入 "赵敏",原来索引为 9 的内容自动后移
s.insert(9,"周敏");
System.out.println(s);//敏true10.5周敏周芷若world100.2
}
}
1.4.4 StringBuffer 类课堂测试题
public class StringBufferExcrsice01 {
public static void main(String[] args) {
String str = null;
StringBuffer sb = new StringBuffer();
sb.append(str);//这里传入null值，需要看源码,底层调用的是AbstractStringBuilder，的 appendNull
System.out.println(sb.length());//4
System.out.println(sb);//null
//下面的构造器，会抛出 NullpointerException
StringBuffer sb1 = new StringBuffer(str);//看底层源码 super(str.length() + 16);
System.out.println(sb1);//NullpointerException
}
}
代码演示：
public class StringBufferExercise02 {
public static void main(String[] args) {
String price = "12223456.78";
StringBuffer sb = new StringBuffer(price);
//先完成一个简单的实现123，456.78
//找到小数点的索引，然后在该位置的前三位，插入，即可
//int i = sb.lastIndexOf(".");
//sb = sb.insert(i-3,",");
//System.out.println(sb);
for (int j = sb.lastIndexOf(".") - 3; j > 0; j-=3) { //先减 再加，号
sb = sb.insert(j,",");
}
System.out.println(sb);
}
}
1.5 StringBuilder类
1.5.1 基本介绍
StringBuffer
//1. StringBuffer 的直接父类 是 AbstractStringBuilder //2. StringBuffer 实现了 Serializable, 即 StringBuffer 的对象可以串行化 //3. 在父类中 AbstractStringBuilder 有属性 char[] value,不是 final 该 value 数组存放 字符串内容，引出存放在堆中的 //4. StringBuffer 是一个 final 类，不能被继承 //5. 因为 StringBuffer 字符内容是存在 char[] value, 所有在变化(增加/删除)不用每次都更换地址(即不是每次创建新对象)， 所以效率高于 String
StringBuilder
//1. StringBuilder 继承 AbstractStringBuilder 类 //2. 实现了 Serializable ,说明 StringBuilder 对象是可以串行化(对象可以网络传输,可以保存到文件) //3. StringBuilder 是 final 类, 不能被继承 //4. StringBuilder 对象字符序列仍然是存放在其父类 AbstractStringBuilder 的 char[] value; 因此，字符序列是堆中 //5. StringBuilder 的方法，没有做互斥的处理,即没有 synchronized 关键字,因此在单线程的情况下使用 StringBuilder1.5.2 StringBuilder 常用方法 1.5.3 String、StringBuffer 和 StringBuilder 的比较
StringBuffer 和StringBuilder 非常的类似，均代表可变的字符序列，而且方法也一样
String不可变字符序列，效率低但是复用率高。
StringBuffer 可变字符序列、效率较高（增删），线程安全。
StringBuilder 可变字符序列、效率最高、线程不安全
String使用说明：
String s = “a”; //创建了一个字符
s +=“b”; //实际上原来的"a"字符串已经丢弃了，现在有产生一个字符串 s+“b”(也就是"ab"),如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能。
结论=>如果我们对String做大量的修改，不要使用String。
StringVsStringBufferVsStringBuilder效率 ： StringBuilder > StringBuffer > String
代码演示：
public class StringVsStringBufferVsStringBuilder {
public static void main(String[] args) {
long startTime = 0L;
long endTime = 0L;
//StringBuffer
StringBuffer buffer = new StringBuffer("");
startTime = System.currentTimeMillis();
for (int i = 0; i < 80000; i++) {//StringBuffer 拼接 20000 次
buffer.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println("StringBuffer 的执行时间：" + (endTime - startTime));
//StringBuilder
StringBuilder builder = new StringBuilder("");
startTime = System.currentTimeMillis();
for (int i = 0; i < 80000; i++) {//StringBuilder 拼接 20000 次 第 566页
builder.append(String.valueOf(i));
}
endTime = System.currentTimeMillis();
System.out.println("StringBuilder 的执行时间：" + (endTime - startTime));
//String
String text = "";
startTime = System.currentTimeMillis();
for (int i = 0; i < 80000; i++) {//String 拼接 20000
text = text + i;
}
endTime = System.currentTimeMillis();
System.out.println("String 的执行时间：" + (endTime - startTime));
}
}
1.5.4 String、StringBuffer 和 StringBuilder 的选择
使用的原则、结论：
- 如果字符串存在大量的修改操作，一般使用StringBuffer 和 StringBuilder如果字符串存在大量的修改操作，并在单线程的情况下，使用StringBuilder如果字符串存在大量的修改操作，并在多线程的情况下，使用StringBuffer如果我们字符串很少修改，被多个对象引用，使用String，比如配置信息等
StringBuffer 和 StringBuilder的方法使用一样。
我亦无他，惟手熟尔
