Day09

Java学习

常用类

Object类

• 超类、基类，所有类的直接或间接父类，位于继承数的最顶层

1. getClass()方法

• 返回引用中存储的实际对象类型
• 通常用于判断两个引用中实际存储对象类型是否一致
• Class<? extends 类名>

public class Test {
    public static void main(String[] args) {
        Test t1 = new Test();
        Class<? extends Test> c1 = t1.getClass();
        //getClass()：返回引用中存储的实际对象类型

        System.out.println(c1);

        //用于比较两个引用中实际存储对象类型是否一致
        Test t2 = new Test();
        Class<? extends Test> c2 = t2.getClass();

        if(c1 == c2){
            System.out.println("存储对象类型相同");
        }else{
            System.out.println("不同");
        }
    }
}

2. hashCode()方法

• 返回该对象的哈希码值
• 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
• 一般情况下相同对象放回相同哈希码

//hashCode()方法
System.out.println(t1.hashCode());//856419764
System.out.println(t2.hashCode());//621009875

//因为t1和t2 new了两个不同的空间，地址不一样，因此hashCod也不一样


Test t3 = t1;//t3指向了t1的地址，两个一样
System.out.println(t3.hashCode());//856419764

3.equals()方法

• 比较两个对象地址是否相同
• 可进行重写，比较两个对象的内容是否相同

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();

        s1.setName("yjj");  s1.setAge(3);
        s2.setName("yjj");  s2.setAge(3);
        
        //重写前比较的是地址，所以为false
        //重写后比较的是值，结果为true
        System.out.println(s1.equals(s2));
    }
}
-----------------------------------------------------
public class Student {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    //重写equals()，比较值是否相等
    @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);
    }

}

4.finalize()方法

• 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列
• 垃圾对象：没有有效引用指向此对象时，为垃圾对象
• 垃圾回收：由GC销毁垃圾对象，释放数据存储空间
• 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
• 手动回收机制：使用System。gc()；通知JVM执行垃圾回收

public class TestStudent {
    public static void main(String[] args) {

        new Student().setName("yjj");

        System.gc();
        System.out.println("回收垃圾");
        
        //当只是new了一个空间并没有对象引用时，垃圾回收机制起作用
    }
}
-------------------------------------------------------
public class Student {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //重写finalize()
    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"被回收了");
    }
}

---

包装类

• 基本数据类型所对应的引用数据类型
• Object可统一所有数据，包装类的默认值时null
• 基本数据类型存放在栈中，引用数据类型存放在堆中

基本数据类型	引用数据类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

类型转换中的装箱和拆箱

• 装箱：基本数据类型转换成引用数据类型
• 拆箱：引用数据类型转换成基本数据类型

public class Demo01 {
    public static void main(String[] args) {

        //装箱：基本数据类型转换成引用数据类型
        int num1 = 10;//栈

        //1、使用Integer类创建对象
        Integer i1 = new Integer(num1);

        //2、使用valueOf()方法，返回一个 Integer指定的 int值的 Integer实例。
        Integer i2 = Integer.valueOf(num1);

        System.out.println(i1);
        System.out.println(i2);
        System.out.println("=======================");

        //=====================================================

        //拆箱：引用数据类型转换成基本数据类型
        Integer i3 = new Integer(20);//堆

        //使用intValuer，
        int num3 = i3.intValue();

        System.out.println(num3);
        System.out.println("======================");

        //JDK1.5之后，提供自动装箱和拆箱
        //虽然自动，其实是系统帮我们做了一些事
        int age =30;
        //自动装箱
        Integer i4 = age;

        System.out.println(i4);

        //自动拆箱
        int age1 = i4;

        System.out.println(age1);

        System.out.println("=======================");
        //基本数据类型与字符串之间的转换
        //1、基本数据类型转成字符串
        //使用"+"号
        int n1 = 100;
        String s1 = n1+"";
        System.out.println(s1);

        //使用Integer中的toString()打印
        String s2 = Integer.toString(n1);
        System.out.println(s2);
        String s3 = Integer.toString(n1,16);//16表示16进制
        System.out.println(s3);//64

        //2、字符串转成基本数据类型,parseXXX基本数据类型
        String str = "150";
        //使用parseInt(),不能出现非数字，否则异常
        Integer.parseInt(str);
        System.out.println(str);

        //boolean类型转字符串
        String str2 = "true";//当字符串为"true"时，转换后为true，其他情况为false
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);
    }
}

• 在.class中

Integer缓冲区

public class Demo02 {
    public static void main(String[] args) {
        //面试题
        Integer i1 = new Integer(100);
        Integer i2 = new Integer(100);
        System.out.println(i1 == i2);//false，地址不同

        Integer i3 = 100;
        Integer i4 = 100;
        System.out.println(i3 == i4);//true,比较的是值

        Integer i5 = 200;
        Integer i6 = 200;
        System.out.println(i5 == i6);//false,Integercach[]的大小为-128~127

        //Integer缓冲区-128~127
        
    }
}

---

String

• 不可变性

public class Demo03 {
    public static void main(String[] args) {
        //不可变性
        String name = "张三";
        name = "李四";//并不是修改张三，而是重新开辟一个空间
        // 如果原来的张三没有常量去用它，它就成为了垃圾，被回收

        String str = new String("Java");
        String str2 = new String("Java");
        System.out.println(str==str2);//比地址
        System.out.println(str.equals(str2));//比值，String中重写了equals
    }
}

几种常用方法

public class Demo04 {
    public static void main(String[] args) {

        String str = "12345678123";

        //length():返回字符串长度
        System.out.println(str.length());//11,如有空格要加上

        //charAt(int index):获取index下标的元素
        System.out.println(str.charAt(0));//下标从0开始，最大为10，即length-1

        //contains(String str):字符串中是否包含str
        System.out.println(str.contains("0"));//false,没有0这个字符

        //toCharArray():将字符串转换成数组
        System.out.println(str.toCharArray());//返回该数组
        System.out.println(Arrays.toString(str.toCharArray()));//打印，[1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3]

        //indexOf():返回str出现的下标
        System.out.println(str.indexOf("123"));//0,返回str"第一次"出现的下标
        System.out.println(str.indexOf("123",3));//8,从下标3往后找
        System.out.println(str.lastIndexOf("3"));//最后一次出现

        System.out.println("============================================");

        String str1 = "   hello Java  ";
        //trim():去掉字符串前后的空格
        System.out.println(str1.trim());//hello Java

        //toUpperCase():小写换大写
        System.out.println(str1.toUpperCase());//   HELLO JAVA

        //toLowerCase():大写换小写
        System.out.println(str1.toLowerCase());//   hello java

        //endsWith():是否以什么结尾
        System.out.println(str1.endsWith("java"));//false,是Java

        //startsWith():是否已什么开头
        System.out.println(str1.startsWith("Hello"));//false,是hello

        //replace():替换
        System.out.println(str1.replace("Java","C++"));

        //split():拆分
        String[] s1 = str1.split(" ");//以空格拆分
        //如果要用多个字符拆分可以split("[ ,.!]+")
        System.out.println(s1.length);//5，后面的空格被忽略了，空格后没有字符
        for (String s : s1) {//打印
            System.out.println(s);
        }

        System.out.println("============================================");
        String a = "JAVA";
        String b = "java";
        //equalsIgnoreCase():忽略大小写的比较
        System.out.println(a.equalsIgnoreCase(b));

        //compareTo():比较两个字符串首字母的差，如果首字母相同比较第二个，以此类推
        System.out.println(a.compareTo(b));
        String c = "abc";
        String d = "abcdef";
        System.out.println(c.compareTo(d));//没得比时，用长度比
    }

}
        System.out.println("=====================案例===================");
        String string = "this is a text";
        //1.打印每一个单词
        String[] xx = string.split(" ");
        for (String s : xx) {
            System.out.println(s);
        }
        //2.将text换成practice
        System.out.println(string.replace("text", "practice"));

        //3.在text前加easy
        string.replace("text","easy text");

        //4.将每一个单词的首字母变为大写
        String finalString="";
        for (int i = 0; i < xx.length; i++) {
            //获取
            char first = xx[i].charAt(0);
            //转换
            char upperFirst = Character.toUpperCase(first);
            //将转好的大写字母和单词从小组合，从第二个单词也就是下标为1开始组合
            String newString = upperFirst + xx[i].substring(1);//substring(int index)：从下标开始截取
            finalString += newString + " ";
        }
        System.out.println(finalString);
    }

}