Java学习笔记——Java语言基础（十一）（Object类、String类、StringBuffer类）

一、Object类

1.1 API

1.API（Application Programming Interface）应用程序编程接口
2.Java API：Java提供的可以直接使用的类，这些类将底层的实现封装起来。

1.2 Object

1.Object类：类层次结构的根类，所有类都直接或者间接的继承Object类
2.构造方法：public Object（） 子类的构造方法默认访问的是父类的无参构造方法

1.3 Object的hashCode()方法

1.返回对象的哈希吗值，不同对象的hashCode()一般来说不会相同

1.4 Object类的getClass()方法

1.通过getClass()方法，获取对象的真实类的全名称

hashCode()和getClass()的代码如下：

public class Test03 {
    public static void main(String[] args) {
        //Object的hashCode()方法
        Object obj1 = new Object();
        System.out.println(obj1);//java.lang.Object@1540e19d
        int o1 = obj1.hashCode();
        System.out.println(o1);//356573597
        Object obj2 = new Object();
        System.out.println(obj2);//java.lang.Object@677327b6
        int o2 = obj2.hashCode();
        System.out.println(o2);//1735600054

        //Object的getClass()方法
        Object obj3 = new Object();
        System.out.println(obj3);//java.lang.Object@14ae5a5
        Object obj4 = new Object();
        System.out.println(obj4);//java.lang.Object@7f31245a
        //比较地址值
        System.out.println(obj3==obj4);//false
        Class C3 = obj3.getClass();
        Class C4 = obj4.getClass();
        //比较类名
        System.out.println(C3);//class java.lang.Object
        System.out.println(C4);//class java.lang.Object
        System.out.println(C3==C4);//true
    }
}

1.5 Object类的toString()方法

1.返回该对象的字符串

public class Test04 {
    public static void main(String[] args) {
        Object obj = new Object();
        String s = obj.toString();
        //打印地址值
        System.out.println(s);//java.lang.Object@1540e19d
        /*没有重写toString方法
        Student student1 = new Student();
        String s1 = student1.toString();
        System.out.println(s1);//day11.Student@677327b6
        */
        //重写toString方法
        Student student = new Student("张三", 23);
        String s1 = student.toString();
        System.out.println(s1);//Student{name='张三', age=23}
    }
}
class Student{
    String name;
    int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //重写toString方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

1.6 Object类的equals()方法

1.指示其他某个对象是否与调用方法的对象相等
2.默认情况下比较的是对象的引用是否相同
3.由于比较引用没有意义，一般建议重写equal()方法。

public class Test05 {
    public static void main(String[] args) {
        //Object类的equals方法
        Object obj1 = new Object();
        Object obj2 = new Object();
        System.out.println(obj1.equals(obj2));//false
        System.out.println(obj1==obj2);//fasle
        //Student1重写equals方法
        Student1 s1 = new Student1("张三", 23);
        Student1 s2 = new Student1("张三", 24);
        Student1 s3 = new Student1("张三", 23);
        boolean b1 = s1.equals(s2);
        boolean b2 = s1.equals(s3);
        System.out.println(b1);//false
        System.out.println(b2);//true
    }
}
class Student1{
    String name;
    int age;

    public Student1() {
    }

    public Student1(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //重写eauals方法,比较的是Student里面的成员变量是否相等
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student1 student1 = (Student1) o;
        return age == student1.age &&
                Objects.equals(name, student1.name);
    }
}

1.7 Object类的clone()方法

1.clone()的权限修饰符是受保护的,在用的时候,让该类重写该方法,并把该方法的权限修饰符改为public
2.对象的浅克隆:浅克隆和深克隆，使用clone方法的克隆为浅克隆
3.如果一个对象需要调用clone方法进行克隆，那么该对象所属的类必须实现Cloneable接口。
4.Cloneable接口并没有任何的抽象方法，这种没有任何抽象的接口时一种标记接口

public class Test01 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student s1 = new Student("学生A", 23);
        System.out.println(s1);//Student{name='学生', age=23}
        //克隆一个Object类
        //CloneNotSupportedException抛出异常
        Object obj = s1.clone();
        //向下转型
        Student s2= (Student) obj;
        s2.age=30;
        s2.name="学生B";
        System.out.println(s2);//Student{name='学生B', age=30}
    }
}
class Student implements Cloneable{
    String name;
    int age;
    //重写toString方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

当一个方法的参数包含引用类型的时候，clone方法的使用如下：

public class Test02 {
    public static void main(String[] args) throws CloneNotSupportedException {
        DogFood dogfood = new DogFood("骨头");
        Dog dog1 = new Dog("一号狗", 3, dogfood);
        dog1.dogFood.name="火腿";
        System.out.println(dog1.dogFood.name);//火腿
        //克隆Dog的dog1对象
        Dog dog2 = (Dog) dog1.clone();
        dog2.dogFood.name="狗粮";
        System.out.println(dog2.dogFood.name);//狗粮
        System.out.println(dog1.dogFood.name);//狗粮
    }
}
class DogFood{
    String name;
    public DogFood(String name){
        this.name=name;
    }
}
class Dog implements Cloneable {
    String name;
    int age;
    DogFood dogFood;

    public Dog(String name, int age, DogFood dogFood) {
        this.name = name;
        this.age = age;
        this.dogFood = dogFood;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

内存图

二、String类

1.概述：字符串是由多个字符组成的一串数据，可以看成是一个字符数组
2.字符串字面值“abcde”也可以看成是一个字符串对象
3.字符串是常量，一旦被创建，就不能被改变

2.1 String类的构造方法

1.public String():空构造
2.public String(String original):把字符串常量值转成字符串
3.public String(byte[] bytes):把字节数组转成字符串
4.public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串(index:表示的是从第几个索引开始, length表示的是长度)
5.public String(char[] value):把字符数组转成字符串
6.public String(char[] value,int index,int count):把字符数组的一部分转成字符串

代码演示String的构造方法

public class Test01 {
    public static void main(String[] args) {
        //String的构造方法
        //1.String() 创建一个空的字符串
        String s = new String();
        System.out.println(s.toString());
        //2.string() 传入一个字符串
        String s1 = new String("abc");
        //输出内容是字符串的内容，String类重写了toString方法
        System.out.println(s1.toString());//abc

        //3.public String(byte[] bytes):把字节数组转成字符串
        byte[] bytes = {68, 69, 70, 71, 72, 73};
        String s2 = new String(bytes);
        System.out.println(s2.toString());//DEFGHI

        //4.public String(byte[] bytes,int index,int length)
        //转换一部分的字节数组，第二个参数是起始索引，第三个参数是长度
        String s3 = new String(bytes, 2, 2);
        System.out.println(s3.toString());//FG

        //5.把一个字符数组转换成字符串
        char[] chars={'a','b','c','字','符','数','组'};
        String s4 = new String(chars);
        System.out.println(s4.toString());//abc字符数组

        //6.把一个字符数组的一部分转换成字符串
        //第二个参数是起始索引，第三个参数是长度
        String s5 = new String(chars, 2, 4);
        System.out.println(s5.toString());//c字符数
    }
}

2.2 String类的特点

1.字符串一旦被创建就不能被改变，字符串的值是在方法区的常量池中划分空间，分配地址值
2.字符串的字面值可以作为String类的实例实现

public class Test02 {
    public static void main(String[] args) {
        //字符串字面值可以作为实例实现
        System.out.println("abcdefg".length());//7
        System.out.println("abcdefg".toString());//abcdefg
        //字符串的字面值不能被改变，修改的是字符串的指向
        String s="aaa";
        s="bbb"+"ccc";
        System.out.println(s);//bbbccc

        //定义字符串的两种方式
        String s1 = new String("hello");
        String s2="hello";
        //地址值的比较
        System.out.println(s1==s2);//false
        //String类重写了Object类的equals方法，比较的是字符串的字面内容
        System.out.println(s1.equals(s2));//true
    }
}

**补充：**字符串一旦被创建就不能被改变，字符串是常量，它们的值在创建之后就不能更改，每个字符串的创建都在字符串池中分配一个地址值，字符串根据地址值的指向不同的字符串。
“=="是一个比较运算符，可以比较基本类型，也可以比较引用类型。
比较基本类型，比较的是两个值是否相等。引用类型则是比较两个地址值是否相等
“equlas‘’方法只能比较引用类型，如果一个类没有重写Object类的equals()方法，则会比较地址值。根据不同的类决定是否需要去重写该方法
两种字符串创建方式的内存图：

2.3 String类的判断

String类的判断功能
        public boolean equals (Object obj):比较字符串的内容是否相同, 区分大小写
        public boolean equalsIgnoreCase (String str):比较字符串的内容是否相同, 忽略大小写
        public boolean contains (String str):判断字符串中是否包含传递进来的字符串
        public boolean startsWith (String str):判断字符串是否以传递进来的字符串开头
        public boolean endsWith (String str):判断字符串是否以传递进来的字符串结尾
        public boolean isEmpty ():判断字符串的内容是否为空串 ""

代码实现：

public class Test03 {
    public static void main(String[] args) {
        //区分大小写的比较
        boolean b1 = "abcd".equals("ABCD");
        System.out.println(b1);//false
        //不区分大小写的比较
        boolean b2 = "abcd".equalsIgnoreCase("ABCD");
        System.out.println(b2);//true
        //判断字符串中是否包含传递进来的字符串
        boolean b3 = "Java学习".contains("学习");
        System.out.println(b3);//true
        //判断字符串是否以传递进来的字符串开头
        boolean b4 = "Java学习".startsWith("J");
        System.out.println(b4);//true
        //判断字符串是否以传递进来的字符串结尾
        boolean b5 = "Java学习".endsWith("习");
        System.out.println(b5);//true
        //判断字符串的内容是否为空串
        boolean b6 = "abcd".isEmpty();
        System.out.println(b6);//false
    }
}

2.4 String类的获取功能

1.String类的获取功能
		public int length ():获取字符串的长度。
        public char charAt ( int index):获取指定索引位置的字符
        public int indexOf ( int ch):返回指定字符在此字符串中第一次出现处的索引。
        public int indexOf (String str):返回指定字符串在此字符串中第一次出现处的索引。
        public int indexOf ( int ch, int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
        public int indexOf (String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
        public String substring ( int start):从指定位置开始截取字符串, 默认到末尾。
        public String substring ( int start, int end):从指定位置开始到指定位置结束截取字符串

代码实现

public class Test04 {
    public static void main(String[] args) {
        //获取字符串的长度
        System.out.println("abcdefg".length());//7
        //获取指定索引位置的字符
        System.out.println("abcdefg".charAt(4));//e
        //返回指定字符在此字符串中第一次出现处的索引
        String s="abcdeabcde";
        System.out.println(s.indexOf("d"));//3
        //返回指定字符在此字符串中从指定位置后第一次出现处的索引
        //从索引为3的开始，查找第一次出现c的索引(字符)
        System.out.println(s.indexOf('c', 3));//7
        //返回指定字符串在此字符串中从指定位置后第一次出现处的索引（字符串）
        System.out.println(s.indexOf("de", 3));//3
        //从指定位置开始截取字符串, 默认到末尾
        System.out.println(s.substring(3));//deabcde
        //从指定位置开始到指定位置结束截取字符串
        System.out.println(s.substring(3, 5));//de
    }
}

练习：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数

import java.util.Scanner;
public class Test01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String s = sc.nextLine();
        int uppercaseLetter = 0;
        int lowerCaseLetters = 0;
        int number = 0;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c >= 'a' && c <= 'z') {
                lowerCaseLetters++;
            } else if (c >= 'A' && c <= 'Z') {
                uppercaseLetter++;
            } else if (c >= '0' && c <= '9') {
                number++;
            }
        }
        System.out.println("大写字母个数"+uppercaseLetter+"\n"+"小写字母个数"+lowerCaseLetters+"\n"+"数字个数"+number);
    }
}

2.5 String类的转换功能

String的转换功能：
	public byte[] getBytes():						把字符串转换为字节数组。
	public char[] toCharArray():					把字符串转换为字符数组。
	public static String valueOf( ):				String类的valueOf方法可以把任意类型的数据转成字符串
	public String toLowerCase():					把字符串转成小写。
	public String toUpperCase():					把字符串转成大写。
	public String concat(String str):		  	    把字符串拼接。

import java.util.Arrays;
public class Test02 {
    public static void main(String[] args) {
        //字符串转换为字节数组
        byte[] bytes = "ABCD".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.print(bytes[i]+" ");//65 66 67 68
        }
        //字节数组转换为字符串
        String s = new String(bytes);
        System.out.println(s);//ABCD
        //字符串为中文是，转换字节数组 UTF-8中 一个汉字占三个字节 GBK中 一个汉字占两个字节
        byte[] bytes1 = "中国".getBytes();//6
        System.out.println(bytes1.length);
        for (int i = 0; i < bytes1.length; i++) {
            System.out.print(bytes1[i]+" ");//-28 -72 -83 -27 -101 -67
        }

        //把字符串转换为字符数组
        char[] chars = "ABCD".toCharArray();
        System.out.println(Arrays.toString(chars));//[A, B, C, D]

        //静态方法valueOf() 可以把基本类型，以及字符数组，对象转换成字符串
        //int类型转换为String类型
        String s1 = String.valueOf(200);
        System.out.println(s1);//200
        char[] chars1={'a','b','c','d'};
        String s2 = String.valueOf(chars1);
        System.out.println(s2);//abcd
        //把小写转换成大写
        String s3 = s2.toUpperCase();
        System.out.println(s3);//ABCD
        //把大写转换成小写
        String s4 = s3.toLowerCase();
        System.out.println(s4);//abcd
        //concat()可以代替加号拼接字符串
        String s5 = s4.concat(s3);
        System.out.println(s5);//abcdABCD
        String concat = s1.concat(s2).concat(s3.concat(s4));
        System.out.println(concat);//200abcdABCDabcd
    }
}

2.6 String类的其他功能

1.String的替换功能
					public String replace(char old,char new)			将指定字符进行互换
					public String replace(String old,String new)		将指定字符串进行互换
2.String的去除字符串两空格
					public String trim()
3.String的按字典顺序比较两个字符串
					public int compareTo(String str)
					public int compareToIgnoreCase(String str)

public class Test03 {
    public static void main(String[] args) {
        String s1="abcdabcdabcdabcd";
        //替换单个字符
        System.out.println(s1.replace('a', 'A'));//AbcdAbcdAbcdAbcd
        //替换一个字符串
        System.out.println(s1.replace("bcd", "BCD"));//aBCDaBCDaBCDaBCD
        //去除字符串两空格
        String s2="  abcdabcdabcd   ";
        System.out.println(s2.trim());//abcdabcdabcd
        //比较两个字符串 默认按照 字典顺序来比较，返回的是字符的码表中的差值
        //当字典顺序比不出来的时候，按照长度去比较
        int i = "a".compareTo("A");
        System.out.println(i);//32
        int i1 = "a".compareToIgnoreCase("A");
        //忽略大小写的比较
        System.out.println(i1);//0
    }
}

三、StringBuffer

1.字符串是常量，一旦定义不能被改变，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。
2.StringBuffer是一个长度可变的字符容器，如果需要大量的拼接字符串，可以使用长度可变的字符容器

3.1 StringBuffer类的方法

StringBuffer的构造方法：
		public StringBuffer():   			  无参构造方法
		public StringBuffer(int capacity):    指定容量的字符串缓冲区对象
		public StringBuffer(String str):      指定字符串内容的字符串缓冲区对象
StringBuffer的方法：
		public int capacity()：					返回当前容量。
		public int length():					返回长度（字符数）
StringBuffer的添加功能：
		public StringBuffer append(String str)：  可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
		public StringBuffer insert(int offset,String str)： 在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

public class Test01 {
    public static void main(String[] args) {
        //无参构造字符串缓冲区 初始容量是16个字符
        StringBuffer stringBuffer1 = new StringBuffer();
        //指定容量的字符串缓冲区对象
        StringBuffer stringBuffer2 = new StringBuffer(100);
        //指定字符串内容的字符串缓冲区对象
        StringBuffer stringBuffer3 = new StringBuffer("abcd");
        //往容器中追加数据,返回的还是容器本身
        StringBuffer stringBuffer4 = stringBuffer1.append("abcd");
        StringBuffer stringBuffer5 = stringBuffer4.append("ABCD").append("abcd");
        //获取容器中数据的实际长度
        System.out.println(stringBuffer5.length());//12
        //获取容器中容量
        System.out.println(stringBuffer5.capacity());
        //stringBuffer5重写了toString方法 将容器内的数据转换成字符串
        System.out.println(stringBuffer5.toString());//abcdABCDabcd
        //在指定的位置加入数据，返回的还是字符串缓冲区本身
        StringBuffer stringBuffer6 = stringBuffer5.insert(5, "Z");
        System.out.println(stringBuffer6);//abcdAZBCDabcd
        //比较两个 StringBuffer对象的地址值
        System.out.println(stringBuffer5==stringBuffer6);//true
    }
}

3.2 StringBuffer类的删除、替换、反转、截取方法

StringBuffer的删除功能
		public StringBuffer deleteCharAt(int index):					删除指定位置的字符，并返回本身
		public StringBuffer delete(int start,int end):					删除从指定位置开始指定位置结束的内容，并返回本身
StringBuffer的替换功能
		public StringBuffer replace(int start,int end,String str)		从start开始到end用str替换
StringBuffer的反转功能
		public StringBuffer reverse():									字符串反转
StringBuffer的截取功能
		public String substring(int start): 							从指定位置截取到末尾
		public String substring(int start,int end):						截取从指定位置开始到结束位置，包括开始位置，不包括结束位置

public class Test02 {
    public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer("aabcd");
        System.out.println(stringBuffer);//aabcd
        //删除指定索引的单个字符
        System.out.println(stringBuffer.deleteCharAt(1));//abcd
        //删除从指定位置开始指定位置结束的内容
        System.out.println(stringBuffer.delete(1, 2));//acd
        //反转容器中的数据，返回的还是容器本身
        System.out.println(stringBuffer.reverse());//dca

        //根据首尾索引，去替换容器中的一段内容 第一个参数起始位置 第二个位数  返回的还是容器本身
        System.out.println(stringBuffer.replace(1, 1, "ABCD"));//aABCDcd
        根据首尾索引，截取一部分内容,以字符串形式返回
        System.out.println(stringBuffer.substring(2).toString());//BCDca
        System.out.println(stringBuffer.substring(1, 5).toString());//ABCD
    }
}

3.2 StringBuffer和String的相互转换

public class Test03 {
    public static void main(String[] args) {
        //String-- StringBuffer
        String str="abcd";
        //构造方法
        StringBuffer stringBuffer1 = new StringBuffer(str);
        //append方法
        StringBuffer stringBuffer2 = new StringBuffer().append(str);

        //StringBuffer---String
        //subString方法
        String string1 = stringBuffer1.substring(0);
        //toString方法
        String string2 = stringBuffer1.toString();
        //构造方法
        String string3 = new String(stringBuffer1);
    }
}

3.3 String和StringBuffer分别作为参数传递

1.形式参数：String作为参数传递 String虽然是引用类型,但是它是一个常量,所以在做传递的时候,完全可以将其看成基本数据类型数据进行传递

public class Test04 {
    public static void main(String[] args) {
        String string = new String("abcdefg");
        StringBuffer stringBuffer = new StringBuffer("努力学习");
        test(string);//
        //String 类型作为参数传递，是值传递
        System.out.println(string);//abcdefg
        //作为参数传递（引用传递，传的是地址值）形参的改变会影响实参
        test(stringBuffer);
        System.out.println(stringBuffer);//习学力努
    }

    private static void test(StringBuffer stringBuffer) {
        System.out.println(stringBuffer.reverse());//习学力努
    }

    private static void test(String string) {
        String s = string.substring(3);
        System.out.println(s);//defg
    }
}