Chp11-常用类

Object

• 最大父类，也称为祖宗类。所有类都直接或间接的继承自Object

常用方法

1. Class getClass():获取引用的实际对象类型

	Animal a1 = new Dog();
           Animal a2 = new Cat();
           Dog dog = new Dog();
           //获取实际对象类型
           System.out.println(a1.getClass());//com.by.entity.Dog
           System.out.println(a2.getClass());//com.by.entity.Cat
           //判断a1和a2是否相同
           System.out.println(a1.getClass() == a2.getClass());//f
           System.out.println(a1.getClass() == dog.getClass());//t

2. int hashCode ():获取当前对象的哈希码值

• 重写原因：该方法默认关注对象地址，地址不同则哈希码值必定一致，所以需要对其重写
• 重写规则：
  整形：直接相加
  小数类型：强转int后相加
  引用类型：属性名.hashCide ()相加
  类库中的引用类型：该方法已经提供过重写，所以直接调用方法即可
  自定义的引用类型：需要先将自定义类型的该方法重写，在进行调用

3. boolean equals（Object o）：判断当前对象于参数对象是否相同

• 重写原因：该方法默认比较对象地址，但是在开发过程中，某些情况下需要比较双方内容，所以需要提供重写
• 重写规则

 public boolean equals(Object o) {
             //自反性
             if (this == o) {
                 return true;//自己和自己比,一定相同
             }
             //非空判断 和 类型比较
             if (o == null || this.getClass()!=o.getClass()) {
                 return false;//与null值比或者实际对象类型不一致,一定不同
             }
             //类型强转
             当前类名 引用名 = (当前类名) o;
             //比较属性值
            return 让当前对象的属性与引用名的属性进行比较,多个属性值之间的比较&&连接;
         }

• 比较属性值：
  基本类型： ==直接比较
  引用类型：
  类库中的引用类型：对equals已经提供过重写，所以可以直接调用
  自定义的引用类型：对自定义类型中的equals也进行重写，然后调用

- 比较属性值:
       1. 基本类型: ==直接比较
       2. 引用类型:
          - 类库中的引用类型: 对equals已经提供过重写,所以可以直接调用
          - 自定义的引用类型: 对自定义类型中的equals也进行重写,然后调用

     ~~~java
     package com.by.entity;
     
     
     public class Student {
         private String name;
         private int age;
         private double score;
         private Teacher tea;
     
     
         @Override
         public int hashCode() {
             return age+(int)score+name.hashCode()+ tea.hashCode();
         }
     
         public boolean equals(Object o) {//Object o=new Student();
             //自反性
             if (this == o) {
                 return true;//自己和自己比,一定相同
             }
             //非空判断 和 类型比较
             if (o == null || this.getClass()!=o.getClass()) {
                 return false;//与null值比或者实际对象类型不一致,一定不同
             }
             //类型强转
             Student s = (Student) o;
             //比较属性值
            return this.age==s.age && this.score==s.score && this.name.equals(s.name) && this.tea.equals(s.tea);
     
         }
     
     //省略getter\setter\构造
     }

package com.by.entity;
     
     public class Teacher {
         private String name;
     
         public int hashCode(){
             return name.hashCode();
         }
     
         public boolean equals(Object o) {
             //自反性
             if (this == o) {
                 return true;
             }
             //非空判断+类型比较
             if (o == null || this.getClass() != o.getClass()) {
                 return false;
             }
             //类型强转
             Teacher t = (Teacher) o;
             //属性值比较
             return this.name.equals(t.name);
         }
         
     //省略getter\setter\构造
     
     }

4. String toString(): 用雷放回当前对象的信息

• 重写原因： 该方法默认获取对象地址返回，但是实际开发中，通常查看的是对对象的内容，所以需要重写
• 重写规则：根据查看需求拼接属性值返回即可
• 使用
• 直接查看引用时可以自动调用

5. void finalize（）：用来进行垃圾回收

• 垃圾回收机制：当内存满到不足以支撑新对象的创建时，虚拟机会调用垃圾对象的该方法对其进行回收销毁，以此来释放空间
• 垃圾对象判断标准：没有任何引用指向的对象（零引用机制）
• 手动回收垃圾：可以借助垃圾回收期GC，通过在代码中书写System.gc()来实现手动的垃圾回收

包装类

作用为将八大基本类型包装为引用类型

byte	short	int	long	float	double	char	boolean
Byte	Short	Integer	Long	Float	Double	Character	Boolean

基本类型与包装类型

基转包

1. 利用构造

包装类型 引用名=new 包装类名(基本类型);

2. 利用valueof

包装类型 引用名=包装类名.valueOf(基本类型);

包转基

1. 利用xxxValue

基本类型 变量名=包装类型引用名.xxxValue();
   注:xxx对应的是基本类型名

自动转换

• JDK5.0之后，为了方便操作，提供了自动封箱与拆箱，使得基本类型与包装类型之间可以自动转换
• 封箱：基本类型转包装类型
• 拆箱：包装类型转基本类型

		int a1=10;
        //1.构造
        Integer i1 = new Integer(a1);
        //2. valueOf
        Integer i2 = Integer.valueOf(a1);
        //包转基
        int a2 = i2.intValue();
        //自动转换
        Integer i3 = a1;
        int a3 = i3;

基本类型与String

基转String

1. 字符串拼接

String 引用名=基本类型+"";
   String 引用名=""+基本类型;

2. 利用valueof

 String 引用名=String.valueOf(基本类型);

String转基

1. 利用parseXxx方法

基本类型 变量名=对应的包装类名.parseXxx(String类型);
   注:Xxx对应的是基本类型名,首字母大写

必须包装String中的数据是基本类型能够盛放的数据,否则执行时会触发NumberFormatException数据类型转换异常

	int a1 = 100;
        //字符串拼接
        String s1 = a1 + "abc";
        String s2 = "" + a1;
		String s3=String.valueOf(a1);
        //String转基
        int a2 = Integer.parseInt(s2);
       // int a3 = Integer.parseInt(s1);//100abc 报错

包装类型与String

包转String

1. 字符串拼接

String 引用名=包装类型+"";
   String 引用名=""+包装类型;

2. 利用toString

 String 引用名=包装类型引用名.toString();

String 转包

与基转包一致

必须保证String的值为包装类型能够盛放的值

Integer i1 = 100;
        //字符串拼接
        String s1 = i1 + "qwe";
        String s2 = "" + i1;
        //toString
        String s3 = i1.toString();
        //String转包
        Integer i2 = new Integer(s2);
        Integer i3 = Integer.valueOf(s3);

       // Integer i4 = new Integer(s1); 报错

### 整数缓冲区
官方认定-129—127是最常用的256个数字，为了减少包装类型使用反复数字带来的空间浪费，所以在方法区中设立了整数缓冲区，用来存放这256个数字，当包装类型使用的数字在此范围内，则直接引用缓冲区地址，不再额外开辟对象空间，以此达到节省空间的目的
>==比较引用类型地址时，优先使用堆中的对象地址
~~~java
	Integer i1 = 200;
        Integer i2 = 200;
        System.out.println(i1 == i2);//f

        Integer i3 = 100;
        Integer i4 = 100;
        System.out.println(i3 == i4);//t

        Integer i5 = new Integer(100);
        Integer i6 = new Integer(100);
        System.out.println(i5 == i6);//f


        System.out.println(i3 == i5);//f

String

• 特点：是一个内存中常量，在内存中值一旦确定则不可更改

	String s1 = "abc";
        String s2 = s1;

        s2 = "edf";

        System.out.println("s1: "+s1);//abc
        System.out.println("s2: "+s2);//edf

创建

1. 双引号直接赋值

String 引用名="值";

2. 利用构造

String 引用名=new String("值");

串池

全程字符串常量池，由于String是实际开发中使用频繁最高的数据类型，且开发过程中对一个字符串的复用率远远高于对其的更改频率，为了减少字符串重复使用带来的空间浪费，所以在方法区中设立了串池，保证相同字符串内容只会占用一块串池空间，以此来减少空间浪费，节约空间资源

区别

1. 第一种创建方式：当创建时，会先去串池中寻找对应字符串内容，如果存在，则引用直接指向，如果不存在，则现在串池中创建对应字符串内容然后引用指向
2. 第二种创建方式：无论如何都会开辟对象空间，如果串池中存在对应内容，则对象空间直接存放对应串池地址，如果串池中不存在对应内容，则现在串池中创建，再让对象空间存放对应串池地址

String s1 = "abc";
        String s2 = "abc";

        String s3 = new String("edf");
        String s4 = new String("edf");

        System.out.println(s1 == s2);//t
        System.out.println(s3 == s4);//f

        String s5 = new String("abc");
        System.out.println(s1 == s5);//f

可变长字符串

1. StringBuffer：JDK1.0 线程安全，效率低
2. StringBuilder：JDK5.0 线性不安全，效率高

特点

1. 必须通过构造创建
2. 无法使用串池
3. 内容操作必须调用对应方法实现

//拼接26个大写字母并输出
        StringBuilder sb = new StringBuilder();
        for (char c = 'A'; c <= 'Z'; c++) {
            //将当前遍历内容追加至可变长字符串末尾
            sb.append(c);
        }
        System.out.println(sb);
        //将可变长字符串转变为String类型
        String s = sb.toString();

> 由于字符串的复用率高于更改频率,所以使用更简单且能用串池的String应用场景要远远多于可变长字符串
### 常用方法
- `String引用名.方法名(实参列表)`
1. **char  charAt(下标): 获取指定下标位置的字符**
2. **boolean  contains(字符串): 判断当前字符串中是否包含指定内容**
3. boolean  endsWith(字符串): 判断字符串是否以指定内容结尾
4. boolean startsWith(字符串): 判断字符串是否以指定内容开头
5. **boolean equals(字符串): 判断与指定字符串内容是否相同, 区分大小写**
6. boolean equalsIgnoreCase(字符串): 判断与指定字符串内容是否相同, 不区分大小写
7. byte[] getBytes(): 以byte数组的形式返回字符串内容
8. char[] toCharArray(): 以char数组的形式返回字符串内容
9. **下标  indexOf(字符串): 获取指定字符串第一次出现的下标, 不存在返回-1**
10. 下标 lastIndexOf(字符串): 获取指定字符串最后一次出现的下标, 不存在返回-1
11. boolean isEmpty(): 判断字符串内容是否为空,无法判比null值
12. **int length(): 获取字符串长度**
13. 新字符串 replace(旧字符串,新字符串): 将符合条件的旧字符串替换为新字符串内容
14. **String[] split(分隔符): 对字符串根据分隔符进行分割, 不保留分隔符**
15. **新字符串  substring(下标): 将原字符串从指定下标位置截取至末尾**
16. **新字符串  substring(起始下标,结束下标): 将原字符串从起始下标截取至结束下标前一位**
17. 新字符串 toLowerCase(): 转全小写
18. 新新字符串 toUpperCase(): 转全大写
19. 新字符串 trim(): 去除前后空格
~~~java
package com.by.test.string;

public class Test4 {
    public static void main(String[] args) {
        String s = "hello";
        //char  charAt(下标): 获取指定下标位置的字符
        System.out.println(s.charAt(2));//l
        //boolean  contains(字符串): 判断当前字符串中是否包含指定内容
        System.out.println(s.contains("el"));//t
        System.out.println(s.contains("eo"));//f
        //boolean  endsWith(字符串): 判断字符串是否以指定内容结尾
        System.out.println(s.endsWith("o"));//t
        System.out.println(s.endsWith("hello"));//t
        //boolean startsWith(字符串): 判断字符串是否以指定内容开头
        System.out.println(s.startsWith("h"));//t
        //boolean equals(字符串): 判断与指定字符串内容是否相同, 区分大小写
        System.out.println(s.equals("hello"));//t
        System.out.println(s.equals("HeLLo"));//f
        //boolean equalsIgnoreCase(字符串): 判断与指定字符串内容是否相同, 不区分大小写
        System.out.println(s.equalsIgnoreCase("HELLO"));//t
        //byte[] getBytes(): 以byte数组的形式返回字符内容
        byte[] bs = s.getBytes();
        for (int i = 0; i < bs.length; i++) {
            System.out.print((char) bs[i]+"  ");
        }
        System.out.println();
        //char[] toCharArray(): 以char数组的形式返回字符串内容
        char[] cs = s.toCharArray();
        for (int i = 0; i < cs.length; i++) {
            System.out.print(cs[i]+"  ");
        }
        System.out.println();
        //下标  indexOf(字符串): 获取指定字符串第一次出现的下标, 不存在返回-1
        System.out.println(s.indexOf("l"));//2
        //下标 lastIndexOf(字符串): 获取指定字符串最后一次出现的下标, 不存在返回-1
        System.out.println(s.lastIndexOf("l"));//3
        //boolean isEmpty(): 判断字符串内容是否为空,无法判比null值
        System.out.println(s.isEmpty());//f
        String s2 = "";
        System.out.println(s2.isEmpty());//t
        String s3 = " ";
        System.out.println(s3.isEmpty());//f
        String s4 = null;
        //System.out.println(s4.isEmpty()); 空指针
        //int length(): 获取字符串长度
        System.out.println(s.length());//5
        //新字符串 replace(旧字符串,新字符串): 将符合条件的旧字符串替换为新字符串内容
        System.out.println(s.replace("l", "m"));//hemml
        //String[] split(分隔符): 对字符串根据分隔符进行分割, 不保留分隔符
        String str = "2000-01-01";
        //通过-进行分割
        String[] ss = str.split("-");//[2000 01 01]
        for (int i = 0; i < ss.length; i++) {
            System.out.print(ss[i]+"  ");
        }
        System.out.println();
        //直接分割
        String[] ss2 = str.split("");
        for (int i = 0; i < ss2.length; i++) {
            System.out.print(ss2[i]+"  ");
        }
        System.out.println();
        //新字符串  substring(下标): 将原字符串从指定下标位置截取至末尾
        String s5 = "abcdefg";
        System.out.println(s5.substring(3));//edfg
        //新字符串  substring(起始下标,结束下标): 将原字符串从起始下标截取至结束下标前一位
        System.out.println(s5.substring(1, 6));//bcdef
        //新字符串 toLowerCase(): 转全小写
        String s6 = "ABCD";
        System.out.println(s6.toLowerCase());//abcd
        //新新字符串 toUpperCase(): 转全大写
        System.out.println(s5.toUpperCase());//ABCDEFG
        //新字符串 trim(): 去除前后空格
        String s7 = "   a b  c   ";
        System.out.println(s7.trim());//a b  c
    }
}

今日掌握

1. getClass方法和instanceof的区别
2. equals方法的重写规则
3. 自动封箱和拆箱的概念
4. String转基本类型的写法
5. 串池的概念
6. String的两种创建方式及区别
7. String的重点常用方法