java中常用的类_string name = "张三";-CSDN博客

本文链接：https://blog.csdn.net/mjkkhjl/article/details/114642360

java中常用的类

Object类

Object类是所有类的超类（基类），所有的类都默认或间接继承Object类，并且都能访问里面的方法

getClass();方法。判断两个类是否属于同一个类

public class Test {
    public static void main(String[] args) {
        Day01 day01 = new Day01();      //创建两个Day01的两个对象
        Day01 day011 = new Day01();
        Class s1 = day01.getClass();    //通过getClass();方法把day01的类类型赋值给s1
        Class s2 = day011.getClass();   //通过getClass();方法把day011的类类型赋值给s2
        if(s1==s2){                     //判断s1和s2是否属于同一个类
            System.out.println("是同一个类");
        }else{
            System.out.println("不是同一个类");
        }
    }
}

hashCode();方法。返回一个通过对象的地址和哈希算法计算出来的一个int类型的值

System.out.println(day01.hashCode());//hashCode();方法是根据对象的地址和哈希算法计算出int类型的数值。
System.out.println(day011.hashCode());//继承第一个个代码

toString();方法。返回一个默认的属性值的字符串，具体返回是什么看类型（对象返回的字符串为：该对象的包名+类名+hashCode();方法返回的16进制的int类型的值）。并且可以根据自己需求重写toString方法。

String Name="网三";					//继承第一个个代码
@Override
public String toString() {
    return Name;
}

public class Test {
   public static void main (String[] args) {
    
        System.out.println(day01.toString());//为重写后的方法
        System.out.println(day011.toString());
        System.out.println(s1.toString());//返回的是类 的类型的字符串
       
    }
}

equals();方法。比较两个类型是否相等，相等返回true。不相同返回false。

字符串的比较，在数据相同的情况下，如果用“==”进行比较，比较的它们的地址，肯定是false。而用equals比较，比较的是它们的数据，所以是true。

//继承第一个个代码
System.out.println(s1.equals(s2));//比较两个类  是否为同一个类，返回true
System.out.println(day01.equals(day011));//比较两个对象的地址是否相等，返回false

finalice();方法。用于标记垃圾对象。通过System.gc(); 告诉jvm进行垃圾回收。

Day01 day012 = new Day01();
Day01 day013 = new Day01();
new Day01(); //通过重写finalize标记垃圾
new Day01(); //对象没有被引用的都是垃圾对象，所以被回收释放空间
System.gc(); //告诉jvm回收垃圾
System.out.println("回收垃圾");

包装类

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

在这里插入图片描述

装箱与拆箱

//装箱：把栈中的基本数据类型转化为堆中的引用数据类型，这个过程称为装箱
int num1=10;    //新建一个int类型的值
Integer integer=num1;   //利用Number类里提供的Integer方法进行自动装箱

 Integer integer1=Integer.valueOf(num1);//自动装箱实际是调用了Integer.valueOf();方法

System.out.println("已经自动装箱");
System.out.println(integer);
//拆箱：把堆中的引用数据类型转化为栈中的基本数据类型，这个过程称为拆箱
int num2=integer;       //把堆中的名为integer的引用类型转化为栈中名为num2的基本数据类型

 int num3=Integer.valueOf(integer);//自动拆箱实际是调用了Integer.valueOf();方法

System.out.println("已经自动拆箱");
System.out.println(num2);

根据上述提供的方法，根据参考代码可对所有数据类型进行装箱和拆箱

基本数据类型的字符串之间的转化

public class String1 {
    public static void main(String[] args) {
        //基本数据类型和字符串之间的转换


        //基本数据类型转化为字符串
        int num=150;
        //第一种转换方式：+一个字符串即可
        String s1=num+"";
        //第二种转化方式：通过Integer.toString();方法。
        String s2=Integer.toString(num);
        System.out.println("为int型："+num);
        System.out.println("为字符串型："+s1);
        System.out.println("为字符串型："+s2);

        double num1=21.1;
        String s3=Double.toString(num1);
        System.out.println("为字符串型；"+s3);
        System.out.println("为double型："+num1);

        //字符串转化为基本数据类型
        String d1="152";        //注意字符串必须为数字，不能有非数字的符号，否则会抛出异常
        //通过Integer.parseInt();方法转化
        int d2=Integer.parseInt(d1);
        System.out.println("为字符串型："+d1);
        System.out.println("为int："+d2);
        
	 	//注意：在Boolean与字符串类型进行转化时，当String为true时，Boolean返回true值，其他任何字符串都返回false值

        String s1="true";
        boolean b1=Boolean.parseBoolean(s1);
        System.out.println(b1);
    }
}

Integer的缓冲区

在Integer方法中，在堆中定义了-128到127的一块缓存区，当需要使用这一块缓存区时，就不会再new对象，而是统一指向缓存区某一块地址。

public class Integer2 {

    public static void main(String[] args) {

        Integer integer5=new Integer(100);
        Integer integer6=new Integer(100);
        System.out.println(integer5==integer6);
        //结果为false，因为新建了两个对象，它们在堆中存放，
                                               
        //而我们比较的是存放在它们栈中的地址，所以为false。

        Integer integer1=(100);                
        
        
        Integer integer2=(100);
        									
        System.out.println(integer1==integer2);
        //结果为true，因为这是Integer的缓冲区。栈中的地址都指向堆缓冲区里面的100
                                               
        //而不是new对象，所以它们的地址都是相同的，所以为true

        Integer integer3=(500);                 
        Integer integer4=(500);
        System.out.println(integer3==integer4);
        //结果为false，因为Integer缓冲区是定义了-128到127,500没有在范围之内
                                                
        //所以，两个500单独new了两块空间，在栈中有单独2个内存地址指向它们。所以为false
    }
}

String类

用String创建字符串有两种方式

第一种：String name=“张三”;

String name1=“张三”;

注意：

它是在方法区里的字符串池中开辟一块空间，里面存着张三，而在栈中存放着它的地址名字为name。如果把name从新赋值，他会在字符串池开辟新空间存放新值，地址也会指向新空间，而不会去修改原来的值。
如果命名字符串相同的两个常量，那么他们的地址相同都会指向同一个相同的字符串（上面的例子都会指向张三），而不是创建两个张三的空间。

第二种：String name=new String(“张三”);

注意：

这种创建方式会产生两个对象，一个在堆里，一个在方法区的字符串池里。栈中储存堆中的地址，而堆指向字符串池。
如果创建两个字符串相同的常量（两个张三），那么它们会在堆开辟两块空间，并且同时指向字符串池的“张三”，所以栈中也会储存两个不同的地址。

lengh();方法。通过length();方法可以遍历字符串个数。（字符串本质是通过数组存储的）
charAt();方法。通过charAt(int index);方法可以通过数组下标查询该下标下的字符内容
contains();方法。通过contains(String s);方法查询输入的字符串是否和name相同，（顺序不同也不行）。相同返回true，为否返回false。
toLowerCase();方法。将字符串的大写变为小写
toUpperCase();方法。将字符串的小写变为大写

public class String2 {
    public static void main(String[] args) {
        String name="通过学习可以成为java高手";
        System.out.println("数组个数："+name.length());//通过length();方法可以遍历字符串个数。（字符串本质是通过数组存储的）
        System.out.println(name.charAt(13));        //通过charAt(int index);方法可以通过数组下标查询该下标下的字符内容
        System.out.println(name.contains("jaa"));     //通过contains(String s);方法查询输入的字符串是否和name相同，（顺序不同也不行）
                                                    //相同返回true，为否返回false
                System.out.println(name.toLowerCase());//把字符串字母变为小写
        System.out.println(name.toUpperCase());//把字符串字母变为大写
    }
}