java包装类和String类（StringBuffer和StringBuilder）

包装类
含义:

基本数据类型对应的类

1.出现原因：
Java为纯面向对象语言(万物皆对象)，而8种基本数据类型不能创建对象，破坏了Java为纯面向对象语言的特征，所以Java又给这8种基本数据类型分别匹配了对应的类，这种叫做包装里/封装类

2.继承关系：
基本数据类型 引用数据类型

byte Byte extends Number extends Object
short Short extends Number extends Object
int Integer extends Number extends Object
long Long extends Number extends Object
float Float extends Number extends Object
double Double extends Number extends Object
char Character extends Object
boolean Boolean extends Object

注意：
1.数值型都继承Number

2.int的包装类Integer

3.char的包装类Character

装箱：

int i = 100;
Integer integer = Integer.valueOf(i);//装箱
System.out.println(integer);  

         
自动装箱：
基本数据类型 -> 包装类

int i = 100;
Integer integer = i;//自动装箱（底层实现：Integer.valueOf(i);）
System.out.println(integer);

拆箱：

Integer integer = new Integer(100);
int i = integer.intValue();//拆箱
System.out.println(i);//100

自动拆箱：
包装类 -> 基本数据类型

Integer integer = new Integer(100);
int i = integer;//自动拆箱（底层实现：integer.intValue();）
System.out.println(i);

需求：

public class Test {
    
    public static void main(String[] args) {
        
        String[] ss = {"1","2","3","4","5"};
        
        int[] is = new int[ss.length];
        
        for (int i = 0; i < is.length; i++) {
            //1.将String转换为Integer对象
            //2.Integer对象自动拆箱成int数据
            int num = Integer.valueOf(ss[i]);
            
            is[i] = num;
        }
        
        for (int element : is) {
            System.out.println(element);
        }
    }
}

深入包装类底层：
经典例题：

Integer integer1 = Integer.valueOf(100);
Integer integer2 = Integer.valueOf(100);
System.out.println(integer1 == integer2);//true
                
Integer integer3 = Integer.valueOf(200);
Integer integer4 = Integer.valueOf(200);
System.out.println(integer3 == integer4);//false
/*
Integer底层有个缓存类，缓存类中有个数组，存储了-128~127的Integer对象
Integer.valueOf(num)底层会判断num是否在-128~127这个区间，如果在内就从缓存数组中获取数据，如果不在这个区间就new对象
*/

解析：

package com.dream.package_class;

public class Test03 {

    public static void main(String[] args) {

        Integer integer1 = Integer.valueOf(100);
        Integer integer2 = Integer.valueOf(100);
        System.out.println(integer1 == integer2);//true
        
        Integer integer3 = Integer.valueOf(200);
        Integer integer4 = Integer.valueOf(200);
        System.out.println(integer3 == integer4);//false
        
        System.out.println(integer1);
        System.out.println(integer2);
        System.out.println(integer3);
        System.out.println(integer4);
        
        System.out.println("-------------");
        
        MyInteger myInteger1 = MyInteger.valueOf(100);
        MyInteger myInteger2 = MyInteger.valueOf(100);
        System.out.println(myInteger1 == myInteger2);//true
        
        MyInteger myInteger3 = MyInteger.valueOf(200);
        MyInteger myInteger4 = MyInteger.valueOf(200);
        System.out.println(myInteger3 == myInteger4);//false
        
        System.out.println(myInteger1);
        System.out.println(myInteger2);
        System.out.println(myInteger3);
        System.out.println(myInteger4);
    }
}

package com.dream.package_class;

public class MyInteger {
    
    private int value;

    public MyInteger(int value) {
        this.value = value;
    }
    
    public static MyInteger valueOf(int i){
        if(i >= MyIntegerCache.low && i <= MyIntegerCache.high){
            return MyIntegerCache.cache[i - MyIntegerCache.low];
        }
        return new MyInteger(i);
    }
    
    //MyInteger的缓冲类
    private static class MyIntegerCache{
        
        private static final int low = -128;
        private static final int high = 127;
        private static final MyInteger[] cache; 
        
        static{
            //初始化缓冲数组
            cache = new MyInteger[high - low + 1];
            int j = low;
            for (int i = 0; i < cache.length; i++) {
                cache[i] = new MyInteger(j++);
            }
        }
    }
    
    @Override
    public String toString() {
        return Integer.toString(value);
    }
}

应用场景：
集合(类似数组的容器)，但是集合只能存引用数据类型，

如果想存储基本数据类型，就可以把基本数据类型转换为对应的包装类对象

String类的常用方法
注意：
String是一个不可变的类， 即一旦一个String对象被创建, 包含在这个对象中的字符序列是不可改变的, 直至该对象被销毁。代码实现：

public class Strings {

    public static void main(String[] args) {
        String s3 = new String("abc");
        String s1 = "abc";
        String s2 = "abc";
        String s4 = "Helloworld";
        System.out.println(s1 == s2);//true 存储在地址池中，地址相同
        System.out.println(s1 == s3);//false s3 新创建的字符对象 存储在堆中
        System.out.println(s1.charAt(0));//获取字符串中的下标字符
        System.out.println(s3.contains("b"));//判断字符串中是否存在指定的字符，存在就返回true
        char[] array = s1.toCharArray();//将字符串转化为数组或指定字符组
        for(int i=0;i<array.length;i++){
            array[i] = 'A';
            System.out.println(array[i]);
        } 
        //查找字符串中字符首次出现的位置下标，与charAt方法功能相反
        System.out.println(s1.indexOf('c'));//2
        System.out.println(s4.lastIndexOf('l'));//查找字符串中字符最后一次出现的位置 8
        
        System.out.println(s4.indexOf('l',4));//8,从第四个小标开始查找‘l’首次出现的位置
        String s5 = "   Hello   world    ";
        System.out.println(s5);
        System.out.println(s5.trim());//去掉字符串中前后的空格
        String s6 = "helloworld";
        System.out.println(s6.toUpperCase());//将小写转换为大写 HELLOWORLD
        String filename = "Helloworld.java";
        System.out.println(filename.endsWith(".java"));//验证filename是否以.java结尾
        System.out.println(filename.startsWith("Hello"));//验证filename是否以Hello 开头
        System.out.println(s5.replace(" ", "#"));//###Hello###world#### 字符替换
        String s7 = "我，爱，你";
        String[] strs = s7.split("，");//根据“，”做拆分
        for(int i=0;i<strs.length;i++){
            System.out.println(strs[i]);
        }
        System.out.println(s4.substring(3,8));//截取字符串从下标3 到 8
    }
} 

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

        //将其他类型转换为字符串
        
        int i = 100;
        System.out.println(String.valueOf(i));
        
        boolean bool = true;
        System.out.println(String.valueOf(bool));
        
    }
}

需求：

package com.dream.string_class;

public class Test03 {
    
    public static void main(String[] args) {
        /** 
         *  练习：完成一个邮箱格式的校验 hhy@qq.com
            （1），“@”不能在第一位
            （2），“.”不能在最后一位
            （3），“@”和“.”中间应该有字符
            （4），***@***.***
         */
        
        String email = "hhy@qq.com";
        
        int index1 = email.indexOf("@");
        int index2 = email.indexOf(".");
        
        if(index1 == 0 || index2 == email.length()-1 || (index2-index1)<=1){
            System.out.println("邮箱格式错误");
        }
    }
}

StringBuffer和StringBuilder
StringBuffer/StringBuilder代表可变的字符序列

StringBuffer/StringBuilder称为字符串缓冲区

工作原理:
预先申请一块内存，存放字符序列，

如果字符序列满了，会重新改变缓存区的大小，以容纳更多的字符序列。

StringBuffer/StringBuilder是可变对象，这个是String最大的不同

继承关系：
StringBuffer /StringBuilder extends AbstractStringBuilder

代码实现：

public class Test01 {
    
    public static void main(String[] args) {
        
        //默认字符串缓冲区：16个字符
        //StringBuffer sb = new StringBuffer();
        
        //自定义字符串缓冲区：100个字符
        //StringBuffer sb = new StringBuffer(100);
    
        //自定义字符串缓冲区："123abc".length() + 16 : 22个字符
        StringBuffer sb = new StringBuffer("123abc");
    
        sb.append("DEF123");//在末尾追加字符串
        sb.insert(6, "xxx");//在指定下标处插入字符串
        sb.setCharAt(3, 'A');//替换指定下标上的字符
        sb.replace(6, 9, "我爱你");//从开始下标处(包含)替换到结束下标处(不包含)的字符串
        
        sb.deleteCharAt(1);//删除指定下标上的字符
        sb.delete(5, 11);//从开始下标处(包含)删除到结束下标处(不包含)的字符串
        sb.reverse();//反转字符串
        
        //321FEDcbA31
        System.out.println(sb);

    }
}

StringBuffer和StringBuilder区别：
相同点：使用上一模一样，因为他们都继承AbstractStringBuilder
StringBuffer：线程安全的，效率低
StringBuilder：线程不安全的，效率高

解决字符串频繁拼接问题：
经验：频繁的拼接字符串请使用StringBuilder或StringBuffer
 

public class Test02 {

    public static void main(String[] args) {
        //        long startTime = System.currentTimeMillis();
        //        String str = "左";
        //        for (int i = 0; i < 50000; i++) {
        //            str += "好好学习，天天向上";
        //            //str = str + "好好学习，天天向上"
        //            //str = new StringBuilder(str).append("好好学习，天天向上").toString();
        //        }
        //        long endTime = System.currentTimeMillis();
        //        System.out.println("消耗时长：" + (endTime-startTime));//5746



        long startTime = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder("左");
        for (int i = 0; i < 50000; i++) {
            sb.append("好好学习，天天向上");
            }
        long endTime = System.currentTimeMillis();
        System.out.println("消耗时长：" + (endTime-startTime));//5
    }
}