包装类（String、StringBuffer、StringBuilder) 重点

包装类（Wrapper Class）是Java中的一个重要概念，它们是用于将基本数据类型（如int, char, double等）封装成对象的类。使用包装类的主要目的是为了能够更好地与Java的集合框架（如ArrayList、HashMap等）进行交互，因为集合只能存储对象而不能直接存储基本数据类型。

Java中主要的包装类有：

1. Integer：用于封装int类型。
2. Character：用于封装char类型。
3. Double：用于封装double类型。
4. Float：用于封装float类型。
5. Long：用于封装long类型。
6. Short：用于封装short类型。
7. Byte：用于封装byte类型。
8. Boolean：用于封装boolean类型。

包装类提供了一些有用的方法，比如可以将字符串转换为相应的基本数据类型，或者获取基本数据类型的最大值和最小值等。同时，Java的自动装箱（autoboxing）和拆箱（unboxing）特性使得在基本数据类型和包装类之间的转换变得更加方便。例如，可以直接将一个int赋值给Integer对象，Java会自动完成这个转换。

包装类的继承关系

案例演示（JDK5之前）：手动装箱

       //基本类型---->包装类型 （手动装箱）
        int i=10;
        //方法一
        Integer i1=new Integer(i);
        //方法二
        Integer i2=Integer.valueOf(i);
        
        //包装类型---->基本类型 （手动装箱）    
        Integer j=new Integer(99);
        int j1=j.intValue();

JDK5之后：自动装箱

       //基本类型---->包装类型
        int i=10;
        Integer i1=i;    //底层仍然是 Integer.ValueOf(i)方法

        //包装类型---->基本类型
        Integer j=new Integer(99);
        int j1=j;  //底层仍然是 intValue()方法

  //判断是否是数字
        System.out.println(Character.isDigit('a'));  //F
        System.out.println(Character.isDigit('1'));  //T
        //判断是不是字母
        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'));

Integer 的 valueOf 方法底层源码分析：

如果传入的参数在 low 和 high 之间（-128 到127）就直接返回该值；否则需要创建一个 Integer 对象（new Integer(xx) ).

例题练习：

x 不等于 y，因为超过范围，需要创建一个对象。

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  startIndex, int  count);

可串行化：可以在网络传输

说明：

1、String 是 final 类，不能被其他类继承

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

3、一定注意： value 是一个 final 类型，不可以修改

String 类的创建 

两种创建String 对象的区别

方法一：直接赋值 

String s="good" ;

方法二：调用构造器 

String  s=new String("good") ;

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

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

a 、b 都是指向常量池。

字符串的特性

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

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

String 的一些常用方法：

  String S = "西游记,红楼梦,水浒传,三国演义";
        String[] strings = S.split(",");
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }

测试结果为（以逗号为分隔符）：

6、toCharArray 转化成字符组

 String S = "happy";
        char[] strings = S.toCharArray();
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }

测试结果为：

7、compareTo 比较两个字符串的大小，如果前者大，则返回正数，后者大，则返回负数，如果相等，返回0.

String S = "happy";  
        String s="llx";
            System.out.println(S.compareTo(s));

测试结果为：

分析：

调试看底层源码：

底层方法会判断两个字符串是不是相等，显然不相等，会一个一个匹配， "happy" 第一个为 h,转化为数值是 104；" llx " 第一个是 l ,数值为 108；不相等，所以返回 c1 - c2;即104 -108= -4；所以输出结果为 -4。

 

--------------------------------------------------------------------------------------------------------------------------------

StringBuffer 代表可变的字符序列，可以对字符串内容进行增删。很多方法和String相同，但是StringBuffer是可变长度的。

StringBuffer 是一个容器

构造方法：

 String 和 StringBuffer 相互转换

StringBuffer 常用方法： 

演示一个：

  StringBuffer S = new StringBuffer("Tom");  //长度为5
        // 增 ：append
        S.append("说英语");
        System.out.println(S);

增后的结果为：

练习题：

价格转换：

 String price="1561611.15616";
        StringBuffer s=new StringBuffer(price);
        //找到小数点的索引，然后在该位置的前3位，插入逗号即可
        for (int i = s.lastIndexOf(".");i>0 ; i-=3) {
            s=s.insert(i,",");
        }
        System.out.println(s);

 结果为：

StringBuffer 类