java学习之旅（day.13）

常用类

Object类

object类是所有类的父类，所有类直接或间接继承object类

所有类，如果没书写extends显示继承某个类，都默认继承object类

1. getClass（）方法

返回值是class类型，返回当前对象的类的类型

通过class可以判断2个对象是不是统一类型

package com.zhang.lei;

import com.sun.org.apache.xerces.internal.impl.xpath.XPath;

public class Student {
    private String name;
    private int age;
    //生成构造方法

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

    //生成get set
    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;
    }
    //若想输出年龄，需要重写方法
    public String toString(){
        return name+" "+age;
    }

     //重写equals方法4
    @Override
    public boolean equals(Object obj) {
        //1.判断两个对象是否为同一个引用（传过来的obj跟当前是否为同一个）
        if (this==obj){
            return true;
        }
        //2.判断obj是否为null
        if(obj==null){
            return false;
        }
        //3.判断是否为同一个类型，有两种方法
        //方法一：用getClass
        if(this.getClass()==obj.getClass()){//一般不用这个

        }
        //方法二：用instanceof，可以判断对象是否为某种类型
        if(obj instanceof Student){//如果obj是Student类型
            //4.强制类型转换
            Student s=(Student) obj;
            //5.比较属性
            if(this.name.equals((s.getName()))&&this.age==s.getAge()){
                return true;
            }
        }
        return false;
    }

    //为了能够调用方法，重写finalize（）方法5

    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"对象被回收了");
    }
}
/*
package com.zhang.lei;

public class TestStudent {
    //1.getClass方法
    public static void main(String[] args) {
        Student s1=new Student("zangsan",20);
        Student s2=new Student("zansan",21);
        //判断s1和s2这两个对象是不是同一个类型
        Class class1=s1.getClass();
        Class class2=s2.getClass();
        if(class1==class2){
            System.out.println("属于同一个类型");
        }else{
            System.out.println("不属于同一个类型");
        }
//2.hashcode方法
        System.out.println(s1.hashCode());//21685669
        System.out.println(s2.hashCode());//2133927002
        Student s3=s1;
        System.out.println(s3.hashCode());//21685669
        //3.toString方法
        System.out.println(s1.toString());//com.zhang.lei.Student@14ae5a5
        System.out.println(s2.toString());//com.zhang.lei.Student@7f31245a
          //重写方法后输出值为：zangsan 20
                           //zansan 21
        //4.equals方法，判断两个对象是否相等
        System.out.println(s1.equals(s2));//false
        Student s4=new Student("小明",20);
        Student s5=new Student("小明",20);
        System.out.println(s4.equals(s5));//false
    }


}




package com.zhang.lei;


public class TestStudent2 {
    public static void main(String[] args) {//因为方法5建立了这个类
        //创建几个对象
        Student S1=new Student("aaa",20);
        Student S2=new Student("bbb",20);
        Student S3=new Student("ccc",20);
        Student S4=new Student("ddd",20);
        Student S5=new Student("eee",20);
        new Student("aaa",20);//垃圾
        new Student("bbb",20);//垃圾
        new Student("ccc",20);//垃圾
        new Student("ddd",20);//垃圾
        new Student("eee",20);//垃圾
        //告诉垃圾回收器回收垃圾
        System.gc();//用此来控制垃圾回收器
        System.out.println("回收垃圾");
//输出：回收垃圾
//eee对象被回收了
//ddd对象被回收了
//ccc对象被回收了
//bbb对象被回收了
//aaa对象被回收了
    }
}


 */

2. hashcode方法

返回值为int类型，是个数字，是该对象的哈希码值

哈希值根据对象的地址或字符串或数字使用hash算法计算出的int类型的数值

一般情况下，相同对象返回的哈希码值相同

程序实现见getClass方法

3. toString方法

返回值是字符串类型，返回该对象的字符串表示形式（该对象返回的类型+16进制的哈希值）

4. equals（）方法

返回值类型为boolean 有参数Object obj

用来比较两个对象是否相等，若相等，返回值为true，不相等，返回值为false

public boolean equals(object obj){

return (this==obj) 比较两个对象的地址是否相等

}

对equals方法重写后，可以比较两个对象的内容是否相等

步骤：

• 比较两个引用是否指向同一个对象
• 判断obj是否为null
• 判断两个引用指向的实际对象类型是否一致
• 强制类型转换
• 依次比较各个属性值是否相等

5. finalize（）方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列

垃圾对象：没有有效引用指向此对象时为垃圾对象

垃圾回收：有GC销毁垃圾对象，释放储存空间

自动回收机制：JVM内存耗尽，一次性回收所有的垃圾对象

手动回收机制：使用System.gc（）；通知JVM执行垃圾回收。但是此时，回不回收看当前的运行情况，用户只是给了一个回收指令

protected void finalize（）throws Throwable {}

包装类

基本类型的数据存储在栈中，栈中存储对象的地址?

引用类型的数据存储在堆中?

包装类：基本数据类型所对应的引用数据类型

Object可统一所有数据，包装类默认值为null

类型转换与装箱拆箱

类型转换：基本类型和包装类类型之间的转换

装箱：栈中的数据拿到堆里面（基本类型转为引用类型的过程）

拆箱：堆里面的对象拿到栈里（引用类型转为基本类型的过程）

parse 类型（）静态方法

可以实现基本类型和字符串之间的转换

valueOf（）方法可将引用类型转为基本类型

package com.zhang.lei;

public class Demo01 {
    public static void main(String[] args) {
       // int num=10;
        //类型转换：装箱，基本类型转为引用类型的过程
        int num1=18;//基本类型  存于栈中，要转存到堆中需要Integer类创建对象
        Integer  integer1=new Integer(num1);
        Integer  integer2=Integer.valueOf(num1);//装箱的两种方法
        System.out.println("装箱");
        System.out.println(integer1);//18
        System.out.println(integer2);//18
        //这样就把基本类型转为包装类了
        //类型转换 ：拆箱，引用类型转为基本类型
        Integer  integer3=new Integer(100);
        //integer3指向堆中的一个对象，属性100，现需转到栈中
        int num2=integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);//100
        //JDK1.5后提供了自动装箱与拆箱
        int age=30;
        //自动装箱
        Integer integer4=age;
        System.out.println("自动装箱");
        System.out.println(integer4);//30
        //自动拆箱
        int age2=integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);//30



        //==============================
        //基本类型和字符串间的转换
        int n1=100;
        //1.基本类型转字符串
        //法一：使用+
        String s1=n1+"";
        //法二：使用Integer中的toString（）方法
        String s2=Integer.toString(n1);
        System.out.println(s1);//100
        System.out.println(s2);//100
        //2.字符串转基本类型
        String str="150";
        //使用Integer.parse xxx()方法
        int n2 =Integer.parseInt(str);
        System.out.println(n2);//150
         //boolean字符串形式（”true“）转成基本类型（true），非”true“都会转成false
        String str2="true";
        String str3="tru";
        boolean b1=Boolean.parseBoolean(str2);
        boolean b=Boolean.parseBoolean(str3);
        System.out.println(b1);//true
        System.out.println(b);//false

    }
}

整数缓冲区

package com.zhang.lei;

public class Demo02 {
    public static void main(String[] args) {
        Integer integer1=new Integer(100);//把基本类型100转成了引用类型
        Integer integer2=new Integer(100);
        System.out.println(integer1==integer2);//false  引用类型数据存放在堆中，比的是地址一不一样
        Integer integer3=100;//自动装箱  把基本类型转换为引用类型，等同于Integer integer3=Integer.valueOf(100);
        Integer integer4=100;//等同于Integer integer4=Integer.valueOf(100);
        System.out.println(integer3==integer4);//true
        Integer integer5=200;//等同于Integer integer5=Integer.valueOf(100);
        Integer integer6=200;//等同于Integer integer6=Integer.valueOf(100);
        System.out.println(integer5==integer6);//false

    }
}

String类

字符串是常量，创建后不可改变

package com.zhang.lei;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

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

public class Demo03 {
    public static void main(String[] args) {
        String name="hello";
        name="zhnagsan";//此处zhangsan赋值给name变量，给字符串赋值时，并不是蟹盖hello为zhangsan，而实重新开辟一个空间赋值，而hello就变成了垃圾

        //字符串的另一种创建方法
        String str=new String("JAVA");
        String str2=new String("JAVA");
        System.out.println(str==str2);//false       比地址
        System.out.println(str.equals(str2));//true   比数据


        //字符串常见的方法的使用
        String contents="java好难呀java";
        System.out.println(contents.length());//11
        System.out.println(contents.charAt(0));//j
        System.out.println(contents.contains("java"));//true
        System.out.println(contents.contains("j好"));//false
        System.out.println(Arrays.toString(contents.toCharArray()));//[j, a, v, a, 好, 难, 呀]
        System.out.println(contents.indexOf("java"));//0
        System.out.println(contents.indexOf("java",4));// 7 找到的是第二个java
        //或者用lastIndexOf
        System.out.println(contents.lastIndexOf("java"));//7
        String contents2="     hello   world   ";
        System.out.println(contents2.trim());//hello   world
        System.out.println(contents2.toUpperCase());//     HELLO   WORLD
        System.out.println(contents2.toLowerCase());//     hello   world
        String filename="hello.java";
        System.out.println(filename.endsWith("java"));//true
        System.out.println(filename.startsWith("h"));//true
        System.out.println(contents.replace("java","c#"));//c#好难呀c#

        String say="java is a language,j";
        String[] arr=say.split("[ ,]");//[ ，]表示选择空格或逗号.若在[ ,]加加号，即[ ,]+表示多个空格或逗号
        System.out.println(arr.length);//5
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);//java
                                       //is
                                       //a
                                       //language
                                       //j
            //补充方法equals(比较两个字符串是否相等)
            //compareTo() 两个字符串比较大小相减（比的是字符串在编码表或自检表中的位置）
            String s1="hello";
            String s2="Hello";
            System.out.println(s1.equals(s2));//false
            System.out.println(s1.equalsIgnoreCase(s2));//true    忽略大小写的比较
            String s3="abc";
            String s4="xyz";
            System.out.println(s3.compareTo(s4));//-23 先取a与x比，a：97  b：128
           //也有特殊情况
            String s5="abc";
            String s6="abcxyz";
            System.out.println(s5.compareTo(s6));//-3 此时比字符串的长度而不是位置  3-6

        }

    }
}

字符串的创建有两种方式：

方式一：String s=“hello”；产生一个对象，存储在字符串池中

方式二：String s=new String（“hello”）；产生2个对象，分别存储与堆和池中

常用方法：

• public int length（） 返回字符串长度
• public char charAt（int index） 根据下标获取字符
• public boolean contains（String str） 判断当前字符串中是否包含传递过来的参数
• public char[] toCharArray() 将字符串转换为数组
• public int indexOf(String str) 查找str首次出现的下标，若存在，返回该下标，若不存在，则返回-1(返回字符串首次出现的位置)
• public int lastIndexOf(String str) 查找字符串在当前字符串中最后一次出现的下标索引(返回字符串最后一次出现的位置)
• public String trim（） 去掉字符串前后的空格
• public String toUpperCase（） 将小写转成大写
• ublic String toLowerCase（） 将大写转成小写
• public boolean endWith（String str） 判断字符串是否以str结尾
• public boolean startWith（String str） 判断字符串是否以str开始
• public String replace(char oldChar,char newChar) 将旧字符串替换为新的字符串
• public String[] split(String str) 根据str做拆分

String案例实操

package com.zhang.lei;
/*
需求：
已知String str="this is a text";
1.将str中的单词获取出来
2.将str中的text替换为practice
3.在text前插入一个easy
4.将每个单词的首字母改为大写
 */
public class Demo04 {
    public static void main(String[] args) {
        String str="this is a text";
        //将str中的单词单独获取出来
        String[] arr=str.split(" ");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
//或
      /*  for (String a:arr) {
            System.out.println(a);
        }

       */
        //将str中的text替换为practice
        String str2=str.replace("text","practice");
        System.out.println(str2);
        //在text前加一个easy
        String str3=str.replace("text","easy text");
        System.out.println(str3);
        //将每个单词的首字母变成大写
        for (int i = 0; i <arr.length; i++) {
            char first=arr[i].charAt(0);
            //把第一个字母转成大写
            char upperfirst= Character.toUpperCase(first);//包装类
             String news=upperfirst+arr[i].substring(1);//substring() 截取方法
            System.out.println(news);
        }
    }
}