新手小白学JAVA API Object String StringBuffer/StringBuilder

港控/mmm° 2021-09-07 19:06 230阅读 0赞

# 1 前言 #

亲爱的小伙伴萌,目前我们看到的是Java基础部分的一个新的部分API,这是个啥,又能做啥呢?  
其实可以概括成一句话:帮助我们站在巨人的肩膀上,实现更加高效的开发,那么我们来一探究竟吧~

# 2 什么是API #

API（Application Programming Interface，应用程序接口）是一些预先定义的函数。目的是提供应用程序与开发人员基于某软件可以访问的一些功能集，但又无需访问源码或理解内部工作机制的细节.  
API是一种通用功能集,有时公司会将API作为其公共开放系统,也就是公司制定自己的系统接口标准,当需要进行系统整合,自定义和程序应用等操作时,公司所有成员都可以通过该接口标准调用源代码.

> ###### Java.util包是java中的工具包,包含各种实用工具类/集合类/日期时间工具等各种常用工具包 ######
> 
> import java.util.Scanner;  
> import java.util.Arrays;
> 
> ###### java.lang包是java的核心,包含了java基础类 ######
> 
> ###### 包括基本Object类/Class类/String类/基本数学类等最基本的类,这个包无需导入,默认会自动导入 ######
> 
> import java.lang.Object;  
> import java.lang.String;  
> import java.lang.StringBuilder/StringBuffer;  
> 正则表达式  
> 包装类等等 –

那么接下来我们会学习一些常用的类,帮助大家完成"基建工程",首先第一位选手就是传说中的Object类

# 3 Object #

## 3.1概念 ##

Object类是所有Java类的祖先,也就是说我们所说的”顶级父类”  
它存在于java.lang.Object,这个包不需要我们手动导包  
需要注意的是:每个类都使用Object作为超类.所有对象(包括数组)都实现这个类的方法.  
在不明确给出超类的情况下,Java会自动把Object类作为要定义类的超类.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70]

## 3.2 常用方法介绍 ##

#### toString() ####

本方法用于返回对应对象的字符串表示

#### hashCode() ####

本方法用于返回对应对象的哈希码值  
小贴士:哈希码值的得出是通过一种算法,意在让不同的对象具有不同的哈希码值,用于区分不同的对象.  
但是有时候也存在不同对象哈希码值相同的特殊情况,我们称之为”哈希碰撞”现象

#### equals() ####

本方法用于指示其他某个对象是否与当前对象”相等”

## 3.3 练习: Object类练习 ##

创建包: cn.tedu.api  
创建类: TestObject.java

package cn.tedu.api;
    
    import java.util.Objects;
    
    /*本类用于测试顶级父类Object*/
    public class TestObject { 
        public static void main(String[] args) { 
            //4.创建对象进行测试
            Student s = new Student("海绵宝宝",3);
            Student s2 = new Student("宝宝",3);
    
            /*用于测试toString()*/
            //5.打印对象的属性值
            //重写前：cn.tedu.api.Student@1b6d3586地址值
            //重写后：对象的类型与属性值Student{name='海绵宝宝', age=3}
            System.out.println(s);
            System.out.println(s2);
    
            /*用于测试hashCode() * 本方法的作用用于返回对应对象的哈希码值 * 本方法力求不同对象尽量返回不同的哈希码值 * 我们可以大致理解成不同对象的哈希码值就是不同的*/
            //7.打印对象的哈希码值
            System.out.println(s.hashCode());
            System.out.println(s.hashCode());
            System.out.println(s2.hashCode());
            System.out.println(s2.hashCode());
    
            /*本类用于测试equals() * 本方法底层的判断逻辑是==比较，==比较比较的是左右两边的值 * 而s与s2是引用类型Student的对象，保存是两个不同的地址值 * 所以,地址值不同，equals()返回false*/
            //8.打印equlas()
            System.out.println(s.equals(s2));//false
        }
    
    }
    
    //1.创建学生类
    class Student{ 
        //2.定义属性
        String name;//姓名
        int age;//年龄
        //3.1添加无参构造与含参构造
        //右键->Generate->Constructor->select None->无参构造
        //右键->Generate->Constructor->Shift全选所有属性->OK->全参构造
        public Student() {  }
        //3.2添加无参构造与含参构造
        public Student(String name, int age) { 
            this.name = name;
            this.age = age;
        }
        //右键->Generate->toString()->OK
        //6.在Student类中添加重写的toString()
        @Override
        public String toString() { 
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
        //9.添加重写的equals()
        //右键->Generate->equals()与hashCode()->一顿next即可
        @Override
        public boolean equals(Object o) { 
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Student student = (Student) o;
            return age == student.age && Objects.equals(name, student.name);
        }
    
        @Override
        public int hashCode() { 
            return Objects.hash(name, age);
        }
    }

# 4 String #

## 4.1 特点 ##

String是一个封装char\[\]数组的对象,字符串不可变  
通过下图中的底层实现可以看出:被final修饰,是常量  
String str = “abc”; 等效于：char data\[\] = \{‘a’, ‘b’, ‘c’\};  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 1]

## 4.2 创建String对象的方式 ##

方式一:  
String(char\[\] value) 分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。  
方式二: String str = “abc”;  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 2]

1.  如果是第一次使用字符串，java会在字符串堆中常量池创建一个对象。
2.  再次使用相同的内容时，会直接访问堆中常量池中存在的对象。

## 4.3 常见方法 ##

> ### String API总结 ###
> 
> int hashCode() 返回此字符串的哈希码。  
> boolean equals(Object anObject) 将此字符串与指定的对象比较,比较的是重写后的串的具体内容  
> String toString() 返回此对象本身（它已经是一个字符串！）。

> int length() 返回此字符串的长度。  
> String toUpperCase() 所有字符都转换为大写。  
> String toLowerCase() 所有字符都转换为小写  
> boolean startsWith(String prefix) 测试此字符串是否以指定的元素开头。  
> boolean endsWith(String suffix) 测试此字符串是否以指定的字符串结束。

> char charAt(int index) 返回指定索引/下标处的 char 值/字符  
> int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。  
> int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。  
> String concat(String str) 将指定字符串连接/拼接到此字符串的结尾,注意:不会改变原串  
> String\[\] split(String regex) 根据给定元素来分隔此字符串。

> String trim() 返回去除首尾空格的字符串  
> byte\[\] getBytes() 把字符串存储到一个新的 byte 数组中  
> String substring(int beginIndex) 返回一个新子串,从指定下标处开始,包含指定下标  
> String substring(int beginIndex, int endIndex) 返回一个新子串,从执定下标开始,到结束下标为止,但不包含结束下标  
> static String valueOf(int i) 把int转成String

## 4.4 练习:String常用方法练习 ##

创建包: cn.tedu.api  
创建类: TestString.java

package cn.tedu.api;
    /*本类用于练习String类的使用*/
    public class TestString { 
        public static void main(String[] args) { 
            //1.创建String的方式一
            /*1.字符串类型底层维护的是char[]，存在堆中*/
            char[] value = { 'a','b','c'};
            String s1 = new String(value);//触发String(char[])的含参构造来创建对象
            String s11 = new String(value);//触发String(char[])的含参构造来创建对象
            //2.创建String的方式二
            String s2 = "abc";
            String s22 = "abc";
            String s3 = "ccc";
            //3.测试
            System.out.println(s1 == s2);//false，一个在堆里，一个在堆中常量池
            System.out.println(s1 == s11);//false,两个不同的对象，地址值不同
            System.out.println(s2 == s22);//true，都在堆中常量池，并且指向同一个，所以地址值相同
            System.out.println(s2 == s3);//false，都在堆中常量池，但是数据不同，指向两个地址
    
            /*Object类中equals()的默认实现是通过==来比较的。 但是String类已经重写过了继承自Object中的equals() 重写后，不再按照==比较，而是比较两个字符串的具体内容 也就是说，不论创建方式，只要是串的内容一致，equals()就返回true * */
            System.out.println(s1.equals(s2));//true
            System.out.println(s1.equals(s11));//true
            System.out.println(s2.equals(s3));//false
    
        }
    }

创建包: cn.tedu.api  
创建类: TestString2.java

package cn.tedu.api;
    
    import java.util.Arrays;
    import java.util.Locale;
    
    /*本类用于练习String类常用方法*/
    public class TestString2 { 
        public static void main(String[] args) { 
            //1.创建字符串
            String s = "abc";
    
            char[] value = { 'a','b','c'};
            String ss = new String(value);
    
            //2.测试常用方法
            System.out.println(s == ss);//false,比较的是引用类型的地址
            System.out.println(s.equals(ss));//true,String类重写后比较的是串的具体内容
    
            System.out.println(s.charAt(1));//b,获取指定下标处的字符
    
            System.out.println(s.concat("cxy"));//abccxy,用于拼接字符串
            System.out.println(s);//拼接字符串不会改变原串
            String s2 = s.concat("ccc");//将拼接的效果交给s2来保存
            System.out.println(s2);//后面可以一直使用s2,值为拼接后的效果
    
            System.out.println(s.startsWith("a"));//true,判断字符串是否以指定元素开头
            System.out.println(s.endsWith("y"));//false,判断字符串是否以指定元素结尾
    
            System.out.println(s.indexOf("b"));//1,判断指定元素第一次出现的索引
            ss = "abcbb";
            System.out.println(ss.indexOf("b"));
            System.out.println(ss.lastIndexOf("b"));//4,判断指定元素最后一次出现的索引
            System.out.println(ss.length());//5,获取字符串的长度
    
            String s3 = "a b c d e";
            System.out.println(s3.split(" "));//打印的是数组的地址值
            System.out.println(Arrays.toString(s3.split(" ")));//使用数组工具类打印
    
            String[] s33 = s3.split(" ");
            for (int i = 0; i < s33.length; i++) { //遍历拿到的数组s33
                System.out.println(s33[i]);//根据下标打印遍历到的数组中的每一个元素
            }
    
            System.out.println(ss.toUpperCase());//ABCBB,将字符串内容转为全大写
            System.out.println(ss.toLowerCase());//abcbb，将字符串内容转为全小写
    
            String s4 = "abcdefgh";
            System.out.println(s4.substring(3));//从指定下标处截取子串，[3,结束]
            System.out.println(s4.substring(1,5));//bcde,截取指定范围的子串[1,5)含头不含尾
    
            String s5 = " abcde ";
            System.out.println(s5.trim());//abcde,去除字符串两端多余的空格
    
            System.out.println(String.valueOf(10));//10,转int为String类型
            System.out.println("20"+10);//2010,String20与int10不能计算，是拼接
            System.out.println(String.valueOf(80)+10);//8010,String与int拼接
            System.out.println(10+10);//20,int+int->int
    
            byte[] b = s4.getBytes();
        }
    }

# 5 StringBuilder/StringBuffer #

## 5.1 特点 ##

1.  封装了char\[\]数组
2.  是可变的字符序列
3.  提供了一组可以对字符内容修改的方法
4.  常用append()来代替字符串做字符串连接”+”
5.  内部字符数组默认初始容量是16：super(str.length() + 16);
6.  如果大于16会尝试将扩容，新数组大小原来的变成2倍+2，容量如果还不够，直接扩充到需要的容量大小。int newCapacity = value.length \* 2 + 2;
7.  StringBuffer 1.0出道线程安全，StringBuilder1.5出道线程不安全

## 5.2 常见方法 ##

> append()

## 5.3 练习3：测试字符串连接 ##

创建包: cn.tedu. api  
创建类: TestString3.java

package cn.tedu.api;
    /*本类用于测试字符串的拼接*/
    public class TestString3 { 
        public static void main(String[] args) { 
            //需求：将26个字母拼接10000次
            String s = "abcdefghijklmnopqrstuvwxyz";
            //method1(s);//使用方式一拼接字符串
            method2(s);//使用方式二拼接字符串
        }
        //使用方式二拼接字符串
        private static void method2(String s) { 
            //1.创建工具类对象
            StringBuffer sb = new StringBuffer();
            StringBuilder sb2 = new StringBuilder();
            //5.添加一个计时的功能
            //5.1拼接之前获取系统当前时间作为开始时间
            long t1 = System.currentTimeMillis();
            //2.拼接10000次
            for (int i = 0; i < 10000; i++) { 
                //3.使用工具类对象的append()进行拼接
                //sb.append(s);
                sb2.append(s);
            }
            //5.2拼接之后获取系统当前时间作为结束时间
            long t2 = System.currentTimeMillis();
            //4.打印拼接的效果
            //System.out.println(sb);
            System.out.println(sb2);
            //5.3打印拼接总共消耗的时间
            System.out.println(t2-t1);
        }
    
        //使用方式一完成字符串的拼接
        private static void method1(String s) { 
            //1.创建一个变量用来保存拼接后的效果
            String result = "";
            //5.给程序添加一个计时的功能
            //5.1获取循环开始的系统当前时间
            long t1 = System.currentTimeMillis();
            //2.创建循环执行10000次
            for (int i = 0; i < 10000; i++) { 
                //3.进行字符串的拼接
                result = result + s;
            }
            //5.2获取循环拼接之后的系统当前时间
            long t2 = System.currentTimeMillis();
            //4.打印拼接后的效果
            System.out.println(result);
            //5.打印花费的时间
            System.out.println(t2-t1);
            System.out.println(t2);
        }
    
    }

# 6 拓展 #

## 6.1 ==和equals的区别 ##

1.当使用比较时，如果相比较的两个变量是引用类型，那么比较的是两者的物理地值（内存地址），如果相比较的两个变量都是数值类型，那么比较的是具体数值是否相等。  
2.当使用equals()方法进行比较时，比较的结果实际上取决于equals()方法的具体实现  
众所周知，任何类都继承自Object类，因此所有的类均具有Object类的特性，比如String、integer等，他们在自己的类中重写了equals()方法，此时他们进行的是数值的比较，而在Object类的默认实现中，equals()方法的底层是通过来实现的。

## 6.2 练习: ==与equals测试 ##

创建包: cn.tedu.api  
创建类: Test.java

package cn.tedu.api;
    /**本类用于测试==与equlas的区别*/
    public class Test{ 
    	public static void main(String[] args) { 
    		Person p1 = new Person("凹凸曼",16);
    		Person p2 = new Person("凹凸曼",16);
    		
    		System.out.println(p1 == p2);//false,new了两个对象,p1和p2保存的地址值不同
    		System.out.println(p1.name == p2.name);//true,name是String类型,保存在常量池中,值是同一个
    		System.out.println(p1.age == p2.age);//true,age是int基本类型,保存的值都是18
    		
    		//第一次测试:结果false,使用的是Object默认的逻辑,也是用==来比较的
    		//第二次测试:结果true,重写equals()后,就会使用子类重写后的功能,也就是说此时比较的不再是地址,而是类型&属性值
    		System.out.println(p1.equals(p2));
    	}
    }
    
    //1.创建Person类
    class Person { 
    	String name;
    	int age;
    	
    	public Person() { 
    		System.out.println("我是手动添加的无参构造");
    	}
    	public Person(String name, int age) { 
    		super();
    		this.name = name;
    		this.age = age;
    	}
    	//需求:比较两个对象的属性值,如果属性值都一样,就是"同一个对象",要求equals返回true
    	@Override
    	public boolean equals(Object obj) { 
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Person other = (Person) obj;
    		if (age != other.age)
    			return false;
    		if (name == null) { 
    			if (other.name != null)
    				return false;
    		} else if (!name.equals(other.name))
    			return false;
    		return true;
    	}
    	
    }

## 6.3 StringBuilder和StringBuffer的区别 ##

1.在线程安全上 :  
–StringBuffer是旧版本就提供的，线程安全的。@since JDK1.0  
–StringBuilder是jdk1.5后产生，线程不安全的。@since 1.5  
2. 在执行效率上，StringBuilder > StringBuffer > String  
3.源码体现：本质上都是在调用父类抽象类AbstractStringBuilder来干活，只不过Buffer把代码加了同步关键字，使得程序可以保证线程安全问题。  
![在这里插入图片描述][20210515223522731.jpg]  
![在这里插入图片描述][2021051522353555.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70]: /images/20210827/a0e5745217af47aab635baac208b237c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 1]: /images/20210827/9c111588ca9b4a2fb67d536d83208aca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 2]: /images/20210827/431ca398fe7e497daee3778fac200771.png
[20210515223522731.jpg]: /images/20210827/2c3f46786d9a422585338e4964d8829c.png
[2021051522353555.png]: /images/20210827/068bbe37406b4a4ea20b2f21c843922d.png