Day11 API01-1 Object、String、String Builder/String Buffer

1.API

概念

API（Application Programming Interface，应用程序接口）是一些预先定义的函数方法，是一种通用功能集。

java.lang包是java的核心,包含了java基础类，包括基本Object类/Class类/String类/基本数学类等最基本的类,这个包无需导入,默认会自动导入

2.Object

Object类常用方法

Object--顶级父类--java中所有类都把Object作为超类
1）toString（）----默认实现打印的是对象的地址值
                         ----自动生成重写后的方法：打印的是对象的类型和属性值
2）hashCode()----对象的哈希码值--一串数字--用于区分不同的对象
3）equals()---------默认的是==比较，比较的是两个对象的地址值
                   ---------自动生成重写后的方法：比较的是两个对象的类型+所有属性值

练习：常用方法的使用

package cn.tedu.api;

import java.util.Objects;

/*测试顶级父类Object*/
public class TestObject {
    public static void main(String[] args) {
        //4.创建对象并给对象属性赋值查看
        Student s=new Student("超超",18);
        Student s2=new Student("超超",18);

        //6.打印测试toString（）
        //6.1打印结果1：打印的是地址值
        //System.out.println(s);//cn.tedu.api.Student@1540e19d
        //6.2打印结果2：当重写了toString（）时，打印的是对象的属性与属性值
        System.out.println(s);//Student{name='超超', age=18}

        //7.测试hashCode()
        System.out.println(s.hashCode());//356573597
        System.out.println(s2.hashCode());//1735600054

        //8.比较地址值equals()
        /*equals()的默认实现是"=="比较，比较的是两个对象的地址值
        * 如果不想比较地址值，而是比较属性值，需要重写equals（）方法*/
        //System.out.println(s.equals(s2));//false
        //比较对象的类型+属性值，需要重写equals（）
        System.out.println(s.equals(s2));//true
    }
}
//1.创建学生类
class Student{
    //2.属性--成员变量
    String name;
    int age;

    //3.生成构造方法
    //3.1生成无参构造Generate--》Constructor--》Selector None即可生成无参构造
    public Student() {
    }
    //3.2生成全参构造Generate--》Constructor--》Shift，ok

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //5.重写Object中的toString()，Generate--》toString（）--》ok
    //Generate--》toString()
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //equals（）方法重写，Generate--》equals() and 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);
    }
}

3.String

String是一个封装char[]数组的对象

String 字符串类型，使用""包裹
String底层维护了一个char[]，不可以改变数组长度

被final修饰,是常量

3.1String类两种创建方式：

1）方式一：char[] value = {'a','b','c'};
                    String s = new String(value);--没有高效效果
2）方式二：String s = “abc”；有高效的效果，由于数据会存在堆中常量池，如果第二次创建时，发现以前已经有创建过的资源，就不会再次创建了，拿来用就行
TIPS:String底层自动重写了equals()和toString(), 比较的是两个串的具体内容

package cn.tedu.api;
/*本类测试String类的用法*/
public class TestString {
    public static void main(String[] args) {
        //1.String类的创建方式1
        /*1.字符串底层维护的是一个char[]，对象存在堆中*/
        char[] value = {'a','b','c'};
        String s1 = new String(value);
        String s2 = new String(value);

        System.out.println(s1 == s2);//false,默认比较两个对象的地址值
        /*String底层也重写了equals()，比较的是两个串的具体内容，而不是地址值*/
        System.out.println(s1.equals(s2));//true

        //2.String创建方式2
        /*此种创建方式有一个高效的效果，底层也会new String（），
        但是它存在堆中的常量池中，第二次创建时，会查看之前是否创建
        如果有，找到就行，就不再创建，效率高，只有这种创建方式才有高效的效果*/
        String s= "abc";
        String ss="abc";
        System.out.println(s == ss);//true
        System.out.println(s.equals(ss));//true,重写了比较的是串的具体内容
    }
}

3.2String类常用方法

charAt( )	获取指定数组下标值所存的内容
concat( )	拼接一次字符串，注意不影响原本的字符串 想多次使用拼接，可以把它保存为一个变量
startsWith( )	判断本串是否以指定字符开头
endsWith( )	判断本串是否以指定字符结尾
length( )	字符串的长度
indexOf( )	判断当前字符在本串第一次出现时的下标
lastIndexOf( )	判断当前字符在本串最后一次出现的下标
toLowerCase( )	本串内容转为小写
toUpperCase( )	本串内容转为大写
getBytes( )	查看地址值
Arrays.toString(s.getBytes( ))	把指定串转成字节数组
Arrays.toString(s.Split(“  ” ))	利用正则表达式来分割字符串， 并查看分割后的数组内容
substring( 3); substring(1,3 );	截取指定下标值3以后的内容，包括下表3 截取子串，含头不含尾,(包含下表1,不包含下表3)
string.valueOf(10 )	把int类型转成String类型

trim()

去掉首尾空格

练习：String类常用方法的使用

package cn.tedu.api;

import java.util.Arrays;

/*本类测试String常用方法*/
public class TestString2 {
    public static void main(String[] args) {
        //1.1通过高效效果方式创建字符串
        String s ="abc";

        //1.2字符串的普通创建方式
        char[] value = {'a','b','c','d'};//静态数组初始化
        String ss = new String(value);

        //2.测试常用方法
        System.out.println(s.charAt(1));//b,获取指定数组下标值所存的内容

        System.out.println(s.concat("cxy"));//abccxy,拼接一次字符串，注意不影响原本的字符串
        System.out.println(s);//abc
        String s3 = s.concat("cxy");//多次使用拼接后的内容，可以把它保存为一个变量
        System.out.println(s3);

        System.out.println(s.startsWith("a"));//true,判断本串是否以指定字符开头
        System.out.println(s.endsWith("a"));//false,判断本串是否以指定字符结尾

        System.out.println(s == ss);//false,一个高效一个普通，比较的地址值不同
        System.out.println(s.equals(ss));//true,String重写了equals()，比较的具体内容

        System.out.println(s.length());//3,求本串的长度

        String s4 = "abcbc";
        System.out.println(s4.indexOf("b"));//1,判断当前字符在本串第一次出现的下标
        System.out.println(s4.lastIndexOf("b"));//3，判断当前字符在本串最后一次出现的下标

        System.out.println(s4.toLowerCase());//abcbc,把当前串转为小写
        System.out.println(s4.toUpperCase());//ABCBC,把当前串转为大写

        System.out.println(s.getBytes());//[B@1540e19d,查看地址值
        System.out.println(Arrays.toString(s.getBytes()));//[97, 98, 99]，把指定串转成字节数组

        String s5 = "a b c d e";
        //本方法是根据指定的内容来分割本字符串，返回值类型是String[]
        System.out.println(s5.split(" "));//[Ljava.lang.String;@677327b6,数组的地址值
        System.out.println(Arrays.toString(s5.split(" ")));//[a, b, c, d, e]，查看分割后的数组内容
        System.out.println(s5.substring(3));// c d e,从3开始截取后面的内容
        System.out.println(s5.substring(1,5));// b c,截取子串，含头不含尾

        s5 = "    abcde    ";
        System.out.println(s5.trim());//abcde，本方法用于去除首尾两端的空格

        System.out.println(String.valueOf(10));//10,把int类型转成String类型
        System.out.println("20"+10);//2010,String类型数据与int类型数据拼接
        System.out.println(String.valueOf(10)+10);//1010,int 10 转成String 10 后进行拼接
        System.out.println(10+10);//20，int + int，结果是int20

    }
}

4.StringBuilder类/StringBuffer

与拼接符加号相比，append()方法拼接的效率高，但是StringBuffer更安全

package cn.tedu.api;
/*本类用于练习字符串的拼接StringBuilder/StringBuffer*/
public class TestString {
    public static void main(String[] args) {

        String s = "abcdefghijklmnopqrstuvwxyz";

        //method(s);
        method2(s);
    }
     //创建StringBuilder/StringBuffer进行拼接的方法
    private static void method2(String s) {
        /*优化1：创建并使用可变字符序列的对象，StringBuilder/StringBuffer*/
        StringBuffer sb = new StringBuffer();
        StringBuilder sb2 = new StringBuilder();
        //3.1增加一个计时效果，记录系统当前时间作为开始时间
        long t1 = System.currentTimeMillis();

        for(int i = 1;i<=10000;i++){
            /*优化2：不再使用加号拼接，而是使用append()*/
            sb.append(s);//使用工具类对象sb拼接字符串s
            //sb2.append(s);//两个对象都可以拼接，用一个就行
        }
        //3.2记录系统当前时间作为结束时间
        long t2 = System.currentTimeMillis();
        System.out.println(s);//不会改变原串
        System.out.println(sb);//直接打印即可
        //System.out.println(sb.toString());
        //3.3打印总耗时
        System.out.println(t2-t1);

    }


    private static void method(String s) {
        String result ="";
        //计时：增加一个开始时间
        long t1 = System.currentTimeMillis();
        for(int i =1;i<=10000;i++){
            result=result.concat(s);//concat()拼接
        }
        //增加一个结束的时间
        long t2 = System.currentTimeMillis();
        System.out.println(result);
        //计时总共耗时
        System.out.println(t2-t1);
    }
}