java学习之旅（day.13）

常用类

Object类

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

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

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对象被回收了

    }

}

 */

hashcode方法

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

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

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

程序实现见getClass方法

toString方法

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

equals（）方法

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

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

public boolean equals(object obj){

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

}

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

步骤：

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

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);

        }

    }

}