[Java知识库]包装类、String、Stringbuffer和Stringbuilder

一、包装类

含义：基本数据类型对应的类
出现原因：
Java为纯面向对象语言(万物皆对象)，而8种基本数据类型不能创建对象，破坏了Java为纯面向对象语言的特征，所以Java又给这8种基本数据类型分别匹配了对应的类，这种叫做包装里/封装类
继承关系：
基本数据类型 引用数据类型
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的包装类Interger

? 3.char的包装类Character

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

public class Test {
    public static void main(String[] args) {
        int i = 100;
        Integer integer  = Integer.valueOf(i);//装箱
        System.out.println(integer);
    }
}

装箱的底层实现方法：

package com.第三周.MyDay13;

public   class MyInterger {
     final int value;
    public  MyInterger(int value){
        this.value = value;
    }
public static class MyIntergeCache{
        static final int low = -128;
        static final int high;
        static final Integer[] cache;
        static{
            high = 127;//high值是可以改的在底层，下限是固定为-128
            int j = low;
            cache = new Integer[high-low+1];
            for (int i = 0; i <cache.length ; i++) {
                cache[i] = new Integer(j++);
            }
        }
    }
public static Integer valueOf(int i){
        if(i>=MyIntergeCache.low && i<=MyIntergeCache.high){
            return MyIntergeCache.cache[i-MyIntergeCache.high];
        }
        return new Integer(i);
}

}

IntegerCache是Integer的内部类，用来将-128——high之间的对象进行实例化
这边固定了缓存的下限，但是上限可以通过设置jdk的AutoBoxCacheMax参数调整，自动缓存区间设置为[-128,N]；

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

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

JDK1.5的新特性：自动装箱、自动拆箱

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

int a = 88;
Integer integer2 = a;//自动装箱System.out.println(integer2);

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

  Integer integer3 = new Integer(88);
        int b = integer3;//自动拆箱
        System.out.println(b);

案例：把字符串数组{“1”,“2”,“3”,“4”,“5”}转换为int数组

public class Test02 {
    public static void main(String[] args) {
        String[] ss = {"1","2","3","4"};
        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);
        }
    }
}

二、String类

String是一个不可变的类， 即一旦一个String对象被创建, 包含在这个对象中的字符序列是不可改变的, 直至该对象被销毁。

String类的常用方法：

public class TestString {
    public static void main(String[] args) {
        //将其他类型转换为字符串
        int i = 100;
        System.out.println(String.valueOf(i));
        boolean bool = true;
        System.out.println(String.valueOf(bool));
        String str = "123abc";
        str = str.concat("DEF123");//在此字符串后面追加字符串，返回新的字符串
        System.out.println(str);
        str = str.substring(2);//截取相应下标到字符串末尾，返回字符串
        System.out.println(str);
        str = str.substring(1,4);//从开始下标处(包含)截取到结束下标处(不包含)，并返回新的字符串
        System.out.println(str);
        str = str.toUpperCase();//转大写
        System.out.println(str);
        str = str.toLowerCase();//转小写
        System.out.println(str);
        str = "  123 a bcD EF 123  ";
        str = str.trim();//去除首尾空格，并返回字符串
        System.out.println(str);
        str = str.replace('2','*');//替换字符，并返回新的字符串
        System.out.println(str);
        str = str.replaceFirst("3","小龙");//替换第一个出现的字符串，并返回新的字符串
        System.out.println(str);
        str = str.replaceAll("1","sjhidhasiu");//换字符串，并返回新的字符串
        System.out.println(str);
        str = str.replaceAll(" ", "");//替换字符串，并返回新的字符串
        System.out.println(str);
        System.out.println(str.equals("sjhidhasiu*郑崴abcDEFsjhidhaSiu*3"));//区分大小写
        System.out.println(str.equalsIgnoreCase("sjhidhasiu*郑崴abcDEFsjhiDHasiu*3"));//不区分大小写
        System.out.println(str.startsWith("sasa"));//判断字符是否以某个字符串开头
        System.out.println(str.endsWith("3"));//判断字符串是否以某个字符串结尾
        System.out.println(str.indexOf("s"));//查询第一次出现这个字符串的下标
        System.out.println(str.lastIndexOf("a"));//查询最后一次出现这个字符串的下标
        System.out.println(str.charAt(4));//获取指定下标的字符串
        System.out.println(str);//底层重写了toString
    }
}

案例：完成一个邮箱格式的校验 hhy@qq.com
（1），“@”不能在第一位
（2），“.”不能在最后一位
（3），“@”和“.”中间应该有字符
（4），***@***.***

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

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入邮箱：");
        String str = scan.next();
        judgmentFormat(str);

    }
}

知识点：深入String创建对象问题

面试题1：下列代码创建几个String对象(考点：常量池中的值必须是唯一的)

String str1 = “abc”;
String str2 = “abc”;
答案：一个

面试题2：下列代码创建几个String对象(考点：常量池中的值必须是唯一的)
String str1 = new String(“abc”);//创建两个对象，堆里创建一个，常量池创建一个
String str2 = new String(“abc”);
答案：三个

String str1 = “abc”;
String str2 = “abc”;
System.out.println(str1 == str2);//true

	//两个常量字符串直接在编译时拼接
	String str3 = "ab" + "c";
	System.out.println(str3 == str1);//true	
	//两个常量字符串直接在编译时拼接
	final String s1 = "ab";
	final String s2 = "c";
	String str4 = s1+s2;
	System.out.println(str4 == str1);//true	
	//两个变量字符串拼接底层是创建StringBuilder对象
	String s3 = "ab";
	String s4 = "c";
	String str5 = s3+s4;//new StringBuilder(s3).append(s4).toString()
	System.

三、StringBuffer

StringBuffer是可变的字符序列，称为字符串缓冲区

工作原理：预先申请一块内存，存放字符序列，
如果字符序列满了，会重新改变缓存区的大小，以容纳更多的字符序列。
StringBuffer是可变对象，这个是String最大的不同

继承关系：StringBuffer extends AbstractStringBuilder

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


        StringBuffer sb = new StringBuffer(16);//底层创建字符数组，默认是16个字符
        StringBuffer a = new StringBuffer(100);//底层会自动扩容
        StringBuffer b = new StringBuffer("abc");//18字符
        /**底层实现：
         *     public StringBuffer(String str) {
         *         super(str.length() + 16);
         *         append(str);
         *     }
         */
        sb.append("DEF123");//在末尾追加字符串
        System.out.println(sb);//DEF123
        sb.insert(6,"xxx");//在指定位置插入字符串
        System.out.println(sb);//DEF123
        sb.setCharAt(3,'A');//替换指定下标的字符
        System.out.println(sb);//DEFA23xxx
        sb.replace(6,9,"你好帅");//从开始下标处(包含)替换到结束下标处(不包含)的字符串
        System.out.println(sb);//DEFA23你好帅
        sb.deleteCharAt(1);//删除指定下表的字符串
        System.out.println(sb);//DFA23你好帅
        sb.delete(5,11);//从开始下标处(包含)删除到结束下标处(不包含)的字符串
        System.out.println(sb);//DFA23
        sb.reverse();//反转字符串
        System.out.println(sb);//32AFD


    }
}

? 四、StringBuilder

StringBuffer vs StringBuilder

相同点：使用上一模一样，因为他们都继承AbstractStringBuilder

StringBuffer：线程安全的，效率低

StringBuilder：线程不安全的，效率高
案例：

package com.第三周.MyDay13;

public class Test03 {
    public static void main(String[] args) {
        //获取自1970.1.1 0:0:0到现在的毫秒数
//        long startTime = System.currentTimeMillis();
//        String str = "张老";
//        for(int i = 0;i<5000;i++){
//            str+="你好帅";
//            /*
//            底层str = str + "小可爱，皇冠给你带"
//				str = new StringBuilder(str).append("小可爱，皇冠给你带").toString();
//
//             */
//        }
//        long endTime = System.currentTimeMillis();
//        System.out.println("消耗时长：" + (endTime-startTime));//80毫秒左右
        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));//6毫秒


    }
}