java常用类(1) - 技术栈

1.Object类

[1.1 toString()方法](#1.1 toString()方法)

1.1.1重写toString()方法

[2.1 equals()方法](#2.1 equals()方法)

[2.1.1 ==的作用](#2.1.1 ==的作用)

[2.1.2 equals()方法](#2.1.2 equals()方法)

2.Arrays类

[2.1 equals()方法](#2.1 equals()方法)

[2.2 copyOf()方法](#2.2 copyOf()方法)

[2.3 fill()方法](#2.3 fill()方法)

[2.4 sort()方法](#2.4 sort()方法)

1.Object类

在java中Object类是所有类的父类,如果一个类没有显示继承任何类，则默认继承了Object类

1.1 toString()方法

我们在直接输出一个对象时,往往得到的是一串我们看不懂的东西,这是什么呢,上面说到,任何一个类都直接或间接的继承了Object类,当我们输出一个对象时,会自动调用toString方法,而当我们没有写toString方法时,就回去调用父类的toString方法,所以往往当我们没有写toString方法时,就会去调用Object类中的toString方法,而这个方法给我们返回了什么呢,我们来看源码

由此可见,该方法返回了我们的全类名再拼上一个@符号作为分割,从而输出我们对象在内存中的哈希值(以16进制输出) ,但是这样往往不符合我们的要求,所以我们就要对父类(Object类)中的toString()方法进行重写

1.1.1重写toString()方法

我们重写toString()方法的目的就是为了让对象以我们想要的形式进行输出,在IDEA中我们可以用快键方式让工具生成

这就是系统生成的,当然我们也可以自己去修改,以自己想要的方式去输出对象的信息

2.1 equals()方法

2.1.1 ==的作用

(1)==在用于基本类型的比较时,比的是值是否相同

(2)==在用于引用类型的比较时,比较的是地址是否相同

2.1.2 equals()方法

当我们用==判断两个对象是否相同时,往往达不到我们的预期,因为==对于引用类型来说比较的是地址,这时候就要用到Object类中的equals方法,但是我们发现它同样也达不到我们的目的,我们来看看源码

我们可以看到Object类中的equals方法其实也是用==去比较的,所以也同样达不到我们的目的,这时候,我们就需要在自己的类中重写Object(父类)中的equals方法,来达到我们比较内容的目的

我们一般用到的java中的类基本都重写了equals方法,以达到比较内容的目的

2.Arrays类

Arrays类主要是一个用于对数组操作的类,在java.util包中,下面介绍几种常用的方法

2.1 equals()方法

equals()方法不是重写的Object类中的方法,而是自己重新定义的一个新的equals()方法,主要用于比较两个数组中的内容是否相等

java 复制代码

public class Arrays1 {
    public static void main(String[] args) {
    /*
    equals()方法:
    比较两个数组的内容是否相等
    */
        int[] a ={1,2,3,4};
        int[] b= {1,2,3,4};
        System.out.println(Arrays.equals(a,b));//true
        
    }
}

2.2 copyOf()方法

copyOf()方法,用于数组的复制,将一个数组中的内容复制到一个指定长度的数组中,并返回这个新数组

java 复制代码

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

        int[] c = new int[5];
        c[0] = 1;
        c[1] = 2;
        c[2] = 3;
        c[3] = 4;
        c[4] = 5;

        /*
        copyOf 数组复制
        将原数组内容复制到一个指定长度的新数组中
         */

        int[] d = Arrays.copyOf(c,10);
        System.out.println(Arrays.toString(d));

    }
}

2.3 fill()方法

fill()方法是用指定值填充整个数组

java 复制代码

public class Arrays1 {

    public static void main(String[] args) {

        /*
        fill:用指定值填充整个数组
         */

        int[] e = {1,2,3,4,5};
        Arrays.fill(e,10);
        System.out.println(Arrays.toString(e));
    }
}

2.4 sort()方法

sort()方法用于对数组进行升序排序

(1)sort(数组名):对整个数组进行排序

(2)sort(数组名,开始排序的位置,结束排序的位置(不包含):对部分区间排序,注意是左闭右开

java 复制代码

public class Arrays2 {
    public static void main(String[] args) {
        /*
        sort()对指定的数组进行升序排序
         */
        int a[] = {5,4,3,2,1};
       /* Arrays.sort(a);
        System.out.println(Arrays.toString(a));*/

        //Arrays.sort(a,开始排序的位置,结束排序的位置(不包含的))
        Arrays.sort(a,0,3);
        System.out.println(Arrays.toString(a));
    }
}

2.4.1 sort()实现降序排序

我们知道Arrays中的sort默认是升序,要想实现降序要调用Collections类中的reverseOrder()方法,并且该方法不能对基本类型排序,要将基本类型换成对应的包装类

java 复制代码

public class Arrays2 {

       //Arrays.sort(a,Collections.reverseOrder());

    public static void main(String[] args) {
       
        Integer a[] = {5,4,3,2,1};
  

        Arrays.sort(a, Collections.reverseOrder());//注意只能对引用类型排序

        System.out.println(Arrays.toString(a));
    }
}

2.4.2引用类型排序

我们要想对引用类型排序就要实现Comparable接口,并实现其中的compareTo()方法,来决定按照哪种成员变量(属性)进行排序

java 复制代码

public class Student implements Comparable<Student>{
    private int id;
    private String name;

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

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    /*
    用来指定排序规则
    可以执行用类中哪个属性作为排序的项
    这个方法在sort()方法的底层调用,来判断大小
     */
    @Override
    public int compareTo(Student o) {
        // return this.id - o.id; 以学号排序
        return this.name.compareTo(o.name);//以姓名排序
    }
}

2.5 binarySearch()方法

binarySearch()方法,用于对有序数组进行二分查找,若找到返回对应的下标,没找到返回-(low+1),即返回一个负数

java 复制代码

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

        /*
        binarySearch() 二分搜索算法查找指定的元素位置,如果未找到,返回负数,前提是数组必须有序
         */
        int[] b = {1,2,3,4,5};
        Arrays.sort(b);
        int index = Arrays.binarySearch(b,-1);
        System.out.println(index);
    }
}

3.基本类型的包装类

java为了体现一切皆对象,使语言更符合面向对象的原则,将8种基本数据类型进行了封装,封装成8种基本类型的包装类

|---------|-----------|
| 基本类型 | 包装类型 |
| byte | Byte |
| short | Short |
| char | Character |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| boolean | Boolean |

在包装类型的底层其实还是一个基本数据类型,只不过为其提供了很多便于我们对基本类型进行操作的方法,同时也更加符合面向对象的方法

3.1 常用方法

java 复制代码

public class IntegerDemo {

        //一类是静态方法
        System.out.println(Integer.toBinaryString(5));//转为二进制
        System.out.println(Integer.toHexString(17));//转为十六进制
        System.out.println(Integer.toOctalString(9));//转为八进制
        System.out.println(Integer.max(10,5));//返回两个数中较大的一个
        System.out.println(Integer.compare(8,10));//两个整数比较大小,返回1,0,-1

        //一类是非静态的
        System.out.println(a.equals(b));//判断两个数是否相同
        System.out.println(a.compareTo(b));//两个数比较大小,返回1,0,-1

        //转换方法
        //把包装类转为基本类型
        //1. intValue()方法
        int aa = a.intValue();

        //把字符串转为int基本类型,parseInt静态方法
        int bb = Integer.parseInt("20");

        //把基本类型转为包装类型
        //1.构造方法 2.valueOf静态方法
        int cc = 10;
        Integer dd = new Integer(cc);
        Integer ee = Integer.valueOf(cc);

        
    }
}

切记,静态方法操作的是传进去的两个整数,而不是底层的value.非静态操作的是底层的value

3.2 自动装箱和自动拆箱

自动装箱:将基本类型转为引用类型

java 复制代码

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

        /*
        自动装箱:把基本类型 转为 引用类型
        自动装箱时,会默认自动调用 valueof()方法
        在valueOf()中如果 基本类型的值 在-128 -- +127之间,会从缓存数组中直接取出一个Integer对象,减少创建次数
        如果两个值相同,获取的是同一个对象
        基本类型值如果不在-128 -- +127之间,每次都创建一个新Integer对象返回
         */
        int x = 1000;
        Integer yy = Integer.valueOf(x);
        Integer y = x;//自动装箱 会默认自动调用valueOf()方法
}

自动装箱底层其实就是调用静态方法valueOf(),而valueOf()方法底层有一个缓冲数组,如果要装箱的值在-128 -- 127之间,它会直接从该缓冲数组中获取,也就是说如果用 == 去比较两个值是否相等,是相等的,因为获取的是同一个对象,如果装箱的值不在这个区间,它会去new一个新的对象,也就是说如果不在这个区间你用 == 去比较,这两个对象的地址是不同的,即使他们两个值是相同的,但地址也不同

自动拆箱:将引用类型转为基本类型

java 复制代码

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

        Integer a = new Integer(10);
        /*
        自动拆箱:把引用类型 转为 基本类型
         */
        int c = a.intValue();
        int d = a;//自动拆箱 会默认自动的调用intValue()方法
    }
}

自动拆箱底层调用的是intvalue()

自动装箱和自动拆箱的目的就是为了简化语法,不用自己去调用转换方法,直接赋值即可