2022.3.27 学习韩顺平老师java基础

例如：

学习java包装类学习java String类

提示：这里统计学习计划的总量

例如：

1.1 包装类的分类

1.2 包装类和基本数据的转换

1) jdk5前的手动装箱和拆箱方式，装箱:基本类型->包装类型，反之，拆箱 
2) jdk5以后(含jdk5)的自动装箱和拆箱方式 
3)自动装箱底层调用的是valueOf方法， 比如Integer.valueOf() 
4)其它包装类的用法类似.

代码实现:

public class Integer01 {
    public static void main(String[] args) {
        //演示int<---->Integer 的装箱和拆箱
        //jdk5以前是手动装箱和拆箱
        //手动装箱 int->Integer
        int n1 = 0;
        Integer integer = Integer.valueOf(n1);
        Integer integer1 = new Integer(n1);

        //手动拆箱 Integer->int
        int n2 = integer.intValue();

        //jdk5以后,自动装箱和拆箱
        int n3 = 100;
        Integer integer2 = n3;
        int i = integer2;
    }
}

1.3 常见面试题:

public class Exercise01 {
    public static void main(String[] args) {
        //下面的代码是否正确，为什么?
        Double d = 100d; //ok,自动装箱Double.valueOf(100d);
        Float f = 1.5f; //ok,自动装箱Float.valueOf(1.5f);
        //如下两个题目输出结果相同吗?各是什么?
        Object obj1 = true ? new Integer(1) : new Double(2.0);//三元运算符[是一个整体] 一真大师
        System.out.println(obj1);//什么? 1.0
        Object obj2;
        if (true) {
            obj2 = new Integer(1);
        } else {
            obj2 = new Double(2.0);
        }
        System.out.println(obj2);//1
        //输出什么? 1,分别计算
    }
}

1.4 包装类型和 String 类型的相互转换
以Integer和String为例，代码如下:

public class WrapperVSString {
    public static void main(String[] args) {
        //包装类型和String类型的互相转换
        //包装类型----->String
        Integer i = 12;
        //第一种方式
        String srt = i + " ";//字符串拼接 但是此时的i本身开始Integee类型
        //第二种方式
        String s = String.valueOf(i);//自动装箱
        //第三种方式
        String s1 = i.toString();//

        //String类型------>包装类
        String stu="1234";
        int i1 = Integer.parseInt(stu);//自动装箱
        Integer integer = new Integer(stu);//构造器

    }
}

1.5 Integer 类和 Character 类的常用方法

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.6 Integer 类面试题

public static void main(String[] args) {
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j); //False

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
}

13.1.7 Intege 类面试题总结

//示例一
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

2.1 String 类的理解和创建对象

1) String对象用于保仔子符串，也就是一组字符序列  
2)字符串常量对象是用双引号括起的字符序列。例如: "你好”、"12.97"、 "boy"等 3)字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节。 
4) String类较常用构造器(其它看手册): 
 String s1 = new StringO;
 String s2 = new String(String original); 
 String s3 = new String(charD a);  
 Strina S4 = new Strinalcharl a int sta rtlndex int count)

2.2 创建 String 对象的两种方法

1)方式一:直接赋值Strings = “hello”
2)方式二:调用构造器String s = new String(“hello”);
方式一:先从常量池查看是否有"hello"数据空间，如果有，直接指向;如果 没有则重新创建，然后指向。s最终指向的是常量池的空间地址
方式二:先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间。 如果常量池没有"hello",重新创建，如果有，直接通过value指向。最终指向 的是堆中的空间地址,

画出两种方式的内存分布图
------取之韩顺平老师 自用

2.3 String常见题目

//题目一
Stringa = "abc";
Stringb =" abc";
System.out.println(a.equals(b));//T
System.out.println(a= =b); //T
//题目二
String a = new String(" abc");
String b =new String(" abc );
System.out.println(a.equals(b))://T
System.out.println(a==b); //F

//题目三
String a = "hello"; //a指向常量池的"hello"
String b =new String("hello");//b指向堆中对象
System.out.println(a.equals(b)); //T
System.out.println(a==b); //F
System.out.println(a= =b.intern(); //T //intern方法自己先查看API
System.out.println(b= =b.intern(); //F
知识点:
当调用 intern方法时，如果池已经包含一 个等于此String对象的字符串(用cunalslabieet 方法确定)，则返回池中的字符串。
否则，将此String对象添加到池中，并返回此String对象的引用
b.intern()方法最终返回的是常量池的地址(对象)

//题目四
String s1 = "hello"; //指向常量池”hello"
String s2 = "java"; //指向常量池”java
String s4 = "java";//指向常量池”java'
String s3 = new String("java");//指向堆中对象
System.out.println(s2 == s3); // F
System.out.println(s2 == s4); //T
System.out.println(s2.equals(s3));//T
System.out.println(s1 == s2); //F

Person p1 = new Person(;
p1.name = "hspedu";
Person p2 = new Person();
p2.name = "hspedu"; 
System.out.println(p1.name.equals(p2.name));//比较内容: True
System.out.println(p1.name == p2.name); //T
System.out.println(p1.name == "hspedu"); //T
String s1 = new String("bcde");
String s2 = new String("bcde");
System.out.println(s1==s2); //False
//请画出内存布局图

图片取之韩顺平老师 自用

3.1 说明

String是一 个final类， 代表不可变的字符序列
2)字符串是不可变的。一个字符串对象-旦被分配，其内容是不可变的.
String s1 = “hello”; s1 =“haha”; //创建了2个对象.

3.2 面试题

//题1
1) String是一 个final类， 代表不可变的字符序列
2)字符串是不可变的。一个字符串对象-旦被分配，其内容是不可变的.
1.以下语句创建了几个对象?画出内存布局图。
String s1 = "hello";
s1 ="haha"; 
//创建了2个对象.

//题2 
String a = "hello"; //创建a对象
String b ="abc";//创建b对象
String c=a+ b;创建了几个对象?画出内存图?
//关键就是要分析 Stringc= a+ b;到底是如何执行的
//-共有3对象，如图。
小结:底层是StringBuilder sb = new StringBuilder(; sb.append(a);
sb.append(b); sb是在堆中，并且append是在原来字符串的基础 上追加的.
重要规则， Stringc1 = "ab" + "cd"; 常量相加，看的是池。Stringc1 = a
+b ;变量相加，是在堆中
学习思路-定尽量看源码学习。

//题3 
下面代码输出什么，并说明原因.
String s1 = "hello"; //s1指向池中的"hello"
String s2 = "java"; / s2指向池中的"java"
String s5 = "hellojava"; //s5指向池中的"hellojava'
String s6 = (s1 + s2).intern();//s6指向池中的 "hellojava'
System.out.println(s5 == s6); //T
System.out.println(s5.equals(s6))://T

下列程序运行的结果是什么，尝试画出内存布局图? 
public class Test1 {
String str = new String("hsp");
final char[]ch={ j，'a' 'v' 'a'};
public void change(String str, char ch[]) {
str = "java";
ch[O] = 'h;
}
public static void main(StringD] args) {
Test1 ex = new Test1();
ex.change(ex.str, ex.ch);
System. out.print(ex.str +
and ");
System.out.println(ex.ch);
} 

内存布局图

图片取之韩顺平老师java基础 自用

3.4 String 类的常见方法

equals //区分大小写，判断内容是否相等
equalslgnoreCase //忽略大小写的判断内容是否相等
length //获取字符的个数，字符串的长度
indexOf //获取字符在字符串中第1次出现的索引,索引从开始，如果找不到，返回-1
lastIndexOf //获取字符在字符串中最后1次出现的索引,索引从开始，如找不到，返回-1 substring //截取指定范围的子串
trim //去前后空格 charAt:获取某索引处的字符，注意不能使用Str[index]这种方式

代码实现:

public static void main(String[] args) {
        //1. equals 前面已经讲过了. 比较内容是否相同，区分大小写
        String str1="jack";
        String str2="Jack";
        System.out.println(str1.equals(str2));//输出false
        // 2.equalsIgnoreCase 忽略大小写的判断内容是否相等
        System.out.println(str1.equalsIgnoreCase(str2));//输出true
        // 3.length 获取字符的个数，字符串的长度
        System.out.println(str1.length());//输出4
        /// 4.indexOf 获取字符在字符串对象中第一次出现的索引，索引从 0 开始，如果找不到，返回-1
        String index="qwe@eqweq@dd";
        System.out.println(index.indexOf("@"));//输出3
        System.out.println(index.indexOf("qwe"));//输出0
        // 5.lastIndexOf 获取字符在字符串中最后一次出现的索引，索引从 0 开始，如果找不到，返回-1
        System.out.println(index.lastIndexOf("@"));//输出9
        // 6.substring 截取指定范围的子串
        String sub ="hello,world";
        System.out.println(sub.substring(5));//下面 sub.substring(5) 从索引 5 开始截取后面所有的内容
        //name.substring(0,5)表示从索引 0 开始截取，截取到索引 5-1=4 位置
        System.out.println(sub.substring(0,5));

    }

第二部分：

public static void main(String[] args) {
        // 1.toUpperCase 转换成大写
        String s= "hello";
        System.out.println(s.toUpperCase());

        // 2.toLowerCase 转换为小写
        System.out.println(s.toUpperCase());

        // 3.concat
        String s1="宝玉";
        System.out.println(s1.concat("and").concat("黛玉"));

        // 4.replace 替换字符串中的字符
        s1="宝玉 and 林黛玉 林黛玉 宝玉";
        String s11=s1.replace("林黛玉","薛宝钗");
        System.out.println(s1);//这里原来的s1并不会改变，可以新定义一个变量来接收变化后的字符串
        System.out.println(s11);

        // 5.split 分割字符串, 对于某些分割字符，我们需要 转义比如 | \等
        String poem="锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
        // (1). 以 , 为标准对 poem 进行分割 , 返回一个数组
        // (2). 在对字符串进行分割时，如果有特殊字符，需要加入 转义符
        String[] split = poem.split(",");
        s1="E:\aaa\bbb";
        split=s1.split("\\");
        System.out.println("==========分割后的字符串=========");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }

        // 6.toCharArray 转换成字符数组
        s="happy";
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }

        // 7.compareTo 比较两个字符串的大小，如果前者大，则返回正数，后者大，则返回负数，如果相等，返回0
        // (1) 如果长度相同，并且每个字符也相同，就返回 0
        // (2) 如果长度相同或者不相同，但是在进行比较时，可以区分大小
        // 就返回 if (c1 != c2) {
        // return c1 - c2;
        // }
        // (3) 如果前面的部分都相同，就返回 str1.len - str2.len
        String str1="jcak";
        String str2="jack";
        System.out.println(str1.compareTo(str2)); //返回值是 'c' - 'a' = 2 的值

        // 8.format 格式字符
        
        String name ="john";
        int age = 18;
        double score =87.5;
        char gender ='男';
        //将所有的信息都拼接在一个字符串.
        String info =
        "我的姓名是" + name + "年龄是" + age + ",成绩是" + score + "性别是" + gender + "。希望大家喜欢我！";
        System.out.println(info);
        //1. %s , %d , %.2f %c 称为占位符
        //2. 这些占位符由后面变量来替换
        //3. %s 表示后面由 字符串来替换
        //4. %d 是整数来替换
        //5. %.2f 表示使用小数来替换，替换后，只会保留小数点两位, 并且进行四舍五入的处理
        //6. %c 使用 char 类型来替换
        String strinfo="我的名字是%s,年龄是%d,成绩是%.2f,性别是%c";
        String info2=String.format(strinfo,name,age,score,gender);
        System.out.println(info2);
    }