CGB2107 2021.8.12 day10 笔记

API

1.概念

预先设好的函数/接口

2.Object   “顶级父类”

1）每个类都使用Object做超类，Java中的所有类都直接或间接继承Object

2）如果一个类没有明确指明父类，那么这个类会默认继承Object类

3）java.lang包是Java核心包，无需导包直接使用

3.常用方法：

1）toString：本方法用于返回对应对象的字符串

                     重写之前打印的是地址值

                     重写之后的效果取决于如何写

2）hashCode() 打印对象的哈希码值

System.out.println(a.hashCode());

本方法的作用：用于返回对应对象的哈希码值

①本方法力求不同对象尽量返回不同的哈希码值

②我们可以大致理解成不同对象的哈希码值就是不同的

③hashCode()与equals() 保持一致，要重写都重写

3）equals() 

作用：比较当前对象与参数对象是否“相等”

本方法底层的判断逻辑是==比较，==比较 比较的是左右两边的值（地址值）

重写之前：比较的是通过==比较   比较的是值 

                  如果是引用类型（比如自定义类Student），比较的为对象名，也就是引用类型变量保存的地址值

                  如果是基本类型，那么直接比较的是基本类型保存的数据值

重写之后：效果取决于如何写

package cn.tedu.api;

import java.util.Objects;

//本类用于测试顶级父类Object
public class TestObject {
    public static void main(String[] args) {
        Student a=new Student("海绵宝宝",3);
        Student b=new Student("海绵宝宝",3);
        //打印对象的属性值
        //重写后：对象的类型与属性值
        /*用于测试toString()*/
        System.out.println(a);
        System.out.println(b);
        /*用于测试hashCode()  打印对象的哈希码值*/
        /*本方法的作用：用于返回对应对象的哈希码值
        * 本方法力求不同对象尽量返回不同的哈希码值
        * 我们可以大致理解成不同对象的哈希码值就是不同的  十进制*/
        System.out.println(a.hashCode());
        System.out.println(b.hashCode());
        System.out.println(b.hashCode());
        /*用于测试equals()
        * 本方法底层的判断逻辑是==比较，==比较 比较的是左右两边的值
        * a与b是引用类型Student的对象，保存的是两个不同的地址值
        * 所以equals()返回false*/
        System.out.println(a.equals(b));


    }
}
class Student{
    String name;
    int age;

    public Student() {//使用快捷键生成无参构造 generate→constructor→select none
    }
    //使用快捷键生成全参构造
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //在Student类中添加重写的toString() 快捷键 generate→toString()
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //添加重写的equals() generate→equals()与hashCode()
    @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);
    }
}

---

String

1.特点

底层是char类型的数组   

String str = “abc”; 等效于：char data[] = {‘a’, ‘b’, ‘c’};

2.创建String的方式

1）创建char[]

char[] value={'a','b','c'};
        String s1=new String(value);

2）String str = “abc”;  高效

有高效的效果！！！！因为数据在堆中的常量池

Object类中equals()的默认实现是通过==来比较的

 但是String重写了Object当中的equals()， 重写后不再按照==比较而是比较两个字符串的具体内容 也就是说，不论创建方式，只要是串的内容一致，equals()就返回true

测试：

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";//s2已创建在常量池中 s22不用再创建
        String s3="grg";
        System.out.println(s1==s2);//F  一个在堆中，一个在堆中常量池里
        System.out.println(s1==s11);//F 两个不同的对象，地址值不同
        System.out.println(s2==s22);//T  都在堆中常量池，并且指向同一个，所以地址值相同
        System.out.println(s2==s3);//F 都在堆中常量值，但是数据不同，指向两个地址
        /*Object类中equals()的默认实现是通过==来比较的
        * 但是String重写了Object当中的equals()，
        * 重写后不再按照==比较而是比较两个字符串的具体内容
        * 也就是说，不论创建方式，只要是串的内容一致，equals()就返回true*/
        System.out.println(s1.equals(s2));//T
        System.out.println(s1.equals(s11));//T
        System.out.println(s1.equals(s3));//F

    }
}

3.String类中常用的方法

1）charAt(x)   获取指定下标处的字符

2）concat("xxx")  拼接字符串

3）startsWith()  判定字符串是否以指定元素开头

4）endsWith()  判定字符串是否以指定元素结尾

5）indexOf()   判定指定元素第一次出现的索引

6）lastindexOf()   判定指定元素最后一次出现的索引

7）length()  获取字符串的长度     

      注意：数组的length是属性不是方法

8）split() 按照指定规则分割

9）toUpperCase()  把指定字符串变成全大写字母

10）toLowerCase()   把指定字符串变成全小写字母

11）substring(3)  从指定下标处截取子串  [3,结束]

       substring(1,5)  从指定下标处截取子串  [1,5)

12)  trim()  去除字符串两端多余的空格

13）String.valueOf()  转其他类型为String类型

测试：

package cn.tedu.api;

import java.util.Arrays;
import java.util.Locale;

//本类用于练习String常用方法
public class TestString2 {
    public static void main(String[] args) {
        String s="abc";
        char[] value={'a','b','c'};
        String ss=new String(value);
        System.out.println(s==ss);//F
        System.out.println(s.equals(ss));//T
        System.out.println(s.charAt(1));//b,获取指定下标处的字符
        System.out.println(s.concat("ccc"));//abcccc,用于拼接字符串
        System.out.println(s);//拼接字符串不会改变原串
        String s2=s.concat("23");
        System.out.println(s2);
        System.out.println(s.startsWith("a"));
        System.out.println(s.startsWith("y"));
        System.out.println(s.endsWith("c"));
        System.out.println(s.indexOf("b"));
        ss="abbbbb";
        System.out.println(ss.lastIndexOf("b"));
        System.out.println(ss.length());

        String s3="a b c d e";
        System.out.println(s3);
        System.out.println(s3.split(" "));//打印的是地址值
        System.out.println(Arrays.toString(s3.split(" ")));
        String[] s1 = s3.split(" ");
        System.out.println(Arrays.toString(s1));
        for (int i = 0; i < s1.length; i++) {
            System.out.println(s1[i]);
        }
        System.out.println(ss.toUpperCase());
        System.out.println(ss.toLowerCase());
        String s4="abcdefg";
        System.out.println(s4.substring(3));
        System.out.println(s4.substring(1,5));
        String s5="   abcde   vv   ";
        System.out.println(s5.trim());
        System.out.println(String.valueOf(10)+10);


    }

}

---

4.StringBuilder/StringBuffer

拼接字符串

前提：String类型的数据使用+拼接效率比较低

使用append()方法

练习：

package cn.tedu.api;
//本类用于测试字符串的拼接
public class TestString3 {
    public static void main(String[] args) {
        String a="abcdefghijklmnopqrstuvwxyz";
//        method1(a);
        method2(a);
    }
        //使用方式二拼接字符串
    private static void method2(String a) {
        //1.创建工具类对象
        StringBuffer sb=new StringBuffer();
        StringBuilder sb2=new StringBuilder();
        //2.拼接一万次
        long t1=System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            sb.append(a);
        }
        System.out.println(sb);
        long t2=System.currentTimeMillis();
        System.out.println(t2-t1);
    }


    //使用方法一完成字符串的拼接
    private static void method1(String a) {
        //1.创建一个变量用来保存拼接后的效果
        String result="";
        //2.创建循环执行10000次
        //5.给程序添加一个计时的功能
        //5.1获取循环开始的系统当前时间
        long t1=System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            //3.进行字符串的拼接
            result=result+a;
        }
        //5.2获取循环拼接之后的系统当前时间
        long t2=System.currentTimeMillis();
        //4.打印拼接后的效果
        System.out.println(result);
        //6.打印花费的时间
        System.out.println(t2-t1);
    }
}

5.正则表达式Regex

String类型的

作用：我们指定的规则

package cn.tedu.api;

import java.util.Scanner;

//本类用于测试正则表达式
//提示并接收用户输入的身份证号，并将判断结果输出
public class TestRegex {
    public static void main(String[] args) {
        System.out.println("请输入身份证号：");
        String input=new Scanner(System.in).nextLine();
        //找规律
        String regex="[0-9]{17}[0-9X]";
        //判断用户输入的数据是否符合
        /*input是我们接收到的数据，regex是我们定义的正则表达式，也就是要匹配的规则
        * maches()用来判断input数据是否符合regex定义的规则*/
        if (input.matches(regex)) {
            System.out.println("恭喜您");
        }else{
            System.out.println("不正确");
        }

    }
}

拓展：单个\在java中有特殊含义，认为这是一个转义符号

6.包装类

掌握基本类型与包装类型的对应关系

把基本类型进行包装，提供更加完善的功能。
基本类型是没有任何功能的,只是一个变量,只能存值,而包装类可以有更加丰富的功能

 Integer

有一个高效的效果，Integer   数据在（-128~127）范围内，valueOf(),相同的数据只会存一次，后续再存都是使用之前存过的数据     （三个条件）

parseInt()、parseDouble()......

parseInt()作用为把String类型数据转为int

......

7.自动装箱、自动拆箱

7.1自动装箱：

编译器会自动把基本类型int5，包装成包装类型Integer ，然后交给Integer类型的引用类型变量i3来保存

自动装箱底层发生的代码：Integer.valueOf(5)

valueOf()的方向：int→Integer

Integer i3=5;

7.2自动拆箱：

编译器会自动把包装类型的i1拆掉“箱子”，变为基本类型数据127 ，然后交给基本类型int的变量i4保存

自动拆箱底层发生的代码：i1.intValue();

intValue()的方向：Integer→int

练习：

package cn.tedu.api;
//本类用于测试自动装箱、自动拆箱
public class TestNumber2 {
    public static void main(String[] args) {
        //1.定义包装类型的数据
        Integer i1=new Integer(127);
        Integer i2=Integer.valueOf(127);

        //2.现在的方式：
        /*1.自动装箱：编译器会自动把基本类型int5，包装成包装类型Integer
        * 然后交给Integer类型的引用类型变量i3来保存
        * 自动装箱底层发生的代码：Integer.valueOf(5)
        * valueOf()的方向：int→Integer*/
        Integer i3=5;//不会报错，这个现象是自动装箱
        /*2.自动拆箱：编译器会自动把包装类型的i1拆掉“箱子”，变为基本类型数据127
        * 然后交给基本类型int的变量i4保存
        * 自动拆箱底层发生的代码：i1.intValue();
        * intValue()的方向：Integer→int*/
        int i4=i1;//不会报错，这个现象是自动拆箱

    }
}