从零开始学Java，学习笔记Day12-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_51876888/article/details/143894539

Day12

面相对象

一、包装类

理解：8种基本数据类型对应的类

出现原因：

Java为纯面对对象语言（万物皆对象）
8种基本数据类型不能new对象，破坏了Java为纯面对对象语言的特征，所以，Java又为8种基本数据类型分别匹配了对应的类
这种类叫包装类/封装类

基本数据类型	包装类	继承关系
byte	Byte	Object.Number.Byte
short	Short	Object.Number.Short
int	Integer	Object.Number.Integer
long	Long	Object.Number.Long
float	Float	Object.Number.Float
double	Double	Object.Number.Double
char	Character	Object.Character
boolean	Boolean	Object.Boolean

注意：

int 类型的包装类是Integer，char类型包装类是Character

**经验：**学习int和Integer互相转换，其余的包装类举一反三

public static void main(String[] args) {
    //手动装箱：基本数据类型-->包装类
    int num = 100;
    Integer integer = Integer.valueof(num);
    System.out.println(integer);//100
    
    //手动拆箱：包装类-->基本数据类型
    Integer integer = new Integer(100);
    int num = integer.inValue();
    System.out.println(num);
    
    //JDK1.5开始，增加来了自动装箱和自动拆箱
    
    //自动装箱：基本数据类型 -> 包装类
    int num = 100;
    Integer integer = num;
    System.out.printlnJ(integer);//100
    
    //自动拆箱：包装类 -> 基本数据类型
    Integer integer = new Integer(100);
    int num = integer;
    System.out.println(num);//100
    
    //将字符串解析成int值
    String str = "100";
    int num j= Integer.parseInt(str);
    System.out.println(num);
}

深入Integer类

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
}

⭐️Integer底层

public class MyInteger {
    
    private final int value;
    
    public MyInteger(int value) {
        this.value = value;
    }
    
    public int intValue() {
        return value;
    }
    
    public static MyInteger valueOf(int i) {
        if (i >= MyIntegerCache.low && i <= MyIntegerCache.high) {
            return MyIntegerCache.cache[i + (-MyIntegerCache.low)]
        }
        return new MyInteger(i);
    }
    
    @Override
    public String toString() {
        return String.valueOf(value);
    }
    
    //缓存类
    private static class MyIntegertCache() {
        static final int low = -128;
        static final int high = 127;
        static final MyInteger[] cache;
        
        static {
            cache = new MyInteger[high - low + 1];//256
            int j = low;
            for (int i = 0; i < cache.length; i++) {
                cache[i] = new MyInteger(j++);
            }
        }
    }
}

public class Test01 {
    public static void main(String[] args) {
        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);
    }
}

二、关于字符串的类

分类：

String
StringBuffer
StringBuilder

String 的使用

public class Test01 {
    public static void main(String[] args) {
        
        String str = "123abc";
        
        str = str.concat("DEF123");//拼接字符串，返回新字符串
        str = str.substring(2);//从指定下标处截取到字符串末尾，返回新的字符串
        str = str.substring(2, 7);//从开始下标（包含）截到结束下标（排他），返回新的字符串
        str = str.toUpperCase();//转大写，返回新字符串
        str = str.toLowerCase();//转小写，返回新字符串
        
        str = "                 123   ab   Cd EF 12   3                  ";
        
        str = str.trim();//去除首位空格，返回新的字符串
        str = str.replace('C', 'c');//替换字符，返回新的字符串
        str = str.replace("12", "66688888");//替换字符串，返回新的字符串
        str = str.replaceAll("666", "123123");//替换字符串，返回新的字符串 -- 该方法支持正则表达式
        str = str.replaceFirst("12", "xxyy");//替换第一个符合的字符串，返回新的字符串
        str = str.replaceAll(" ", "");//去除空格 - 将空格替换成空内容的字符串，返回新的字符串
        System.out.println("判断两个字符串内容是否相同（区分大小写）：" + str.equals());
        System.out.println("判断两个字符串内容是否相同（忽略大小写）：" + str.equalsIgnoreCase());
        System.out.println("判断两个字符串是否以某个字符串开头：" + str.startWith("xxx"));
        System.out.println("判断两个字符串是否以某个字符串结尾：" + str.endWith("123"));
        System.out.println("获取第一次出现字符的下标：" + str.indexOf('a'));
        System.out.println("获取第一次出现字符串的下标：" + str.indexOf("666"));
        System.out.println("获取最后一次出现字符串的下标：" + str.lastIndexOf("666"));
        System.out.println("获取指定下标上的字符：" + str.charAt(10));
        //将其他类型转换为字符串类型
		System.out.println(String.valueOf(100));//int -> String
        System.out.println(String.valueOf(123.123));//double -> String
        System.out.println(String.valueOf('a'));//char -> String
        System.out.println(String.valueOf(true));//boolean -> String
 		System.out.println(100 + "");
    }
}

StringBuffer/StringBuilder的使用

public class Test {
    public static void main(String[] args) {
        //底层：16个长度的字符数组 -- 容器
        StringBuffer sb = new StringBuffer();
        //底层：32个长度的字符数组 -- 容器
        StringBuffer sb = new StringBuffer(32);
        //底层："123abc".length() + 16个长度的字符数组 -- 容器
        StringBuffer sb = new StrngBuffer("123abc");
        sb.append("DEF123");//追加末尾字符串
        sb.insert(3, "xxxyyy");//指定下标处插入字符串
        sb.setCharAt(2, "A");//替换指定下标上的字符
        sb.deleteCharAt(2);//删除指定下标上的字符
        sb.delete(3, 7);//从开始下标处（包含）删除结束处（排他）的字符串
        sb.replace(1, 4, "唱跳rap篮球");//从开始下标处（包含）替换结束处（排他）的字符串
        sb.reverse();//反转字符串
        System.out.println(sb.toString());
    }
}

String的深入

面试题1：下列代码会创建几个String对象

答：会创建1个String对象

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

面试题2：下列代码会创建几个String对象

答：会创建3个String对象

String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(str1 == str2);//false

public class Test {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";
        System.out.println(str1 == str2);//true
        
        //注意：常量在编译时直接拼接
        String str3 = "ab" + "c";
        System.out.println(Str1 == Str3);//true
        
        //注意：常量在编译时直接拼接
        final String s1 = "ab";
        final String s2 = "c";
        String str4 = s1 + s2;
        System.out.println(str4 == str1);//true
        
        String s3 = "ab";
        String s4 = "c";
        String str5 = s3 + s4;//String str5 = (new StringBuilder(String.valueOf(s3))).append(s4).toString();
        System.out.println(str5 == str1);//false
    }
}

频繁的拼接字符串使用StringBuffer或StringBuilder

public class Test {
    public static void mainJ(String[] args) {
        //获取1970.1.1 0:0:0到现在的毫秒数
        long time = System.currenTimeMillis();
        long startTime = System.currenTimeMillis();
        String str = "蔡徐坤";
        for (int i = 0; i < 1000000; i++) {
            str += "小可爱";//str = (new StringBuilder(String.valueOf(str))).append("小可爱").toString();
            
        }
        long endTime = System.currentTimeMillis();
        System.out.println("消耗时间为：" + (endTime - startTime));
        //ps:上述方法耗时很长
        
        
        
        
        
        //使用StringBuffer
        long startTime = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        sb.append("蔡徐坤");
        for (int i = 0; i < 1000000; i++) {
            sb.append("小可爱");
        }
        long endTime = System.currentTimeMillis();
        System.out.println("消耗时间为：" + (endTime - startTime));
        //耗时极短
        
    }
}