章五、API 常用类（1）—— 概述、Object类、Arrays类

最新推荐文章于 2024-11-04 20:33:37 发布

三木几

最新推荐文章于 2024-11-04 20:33:37 发布

阅读量787

点赞数 20

文章标签： java 开发语言

本文链接：https://blog.csdn.net/king_faner/article/details/136262409

版权

一、Java API概述

API ( Application Programming Interface ) 应用程序编程接口（API文档）

是对 java预先定义的类或接口功能和函数功能的说明文档 ，目的是 提供给开发人员 进行使用帮助说明（说明文档）。

本章会学习java提供的一些基础常用类，以便后期学习需要。

后面的章节以具体模块化学习为主，本质就是学习java中提供的类的功能。

二、Object类

● Object类

Object类是所有Java类的祖先（根基类），每个类都使用 Object 作为超类（父类），所有对象（包括数组）都继承实现这个类的方法。

如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类

public class Person { ... }

等价于：

public class Person extends Object { ... }

● toString方法

● Object类中定义有public String toString()方法，其返回值是 String 类型，描述当前对象的有关信息。

● 当需要通过输出语句输出一个对象时，如System.out.println(person），将自动调用该对象类的 toString()方法，如果该类中没有重写toString()，那么默认调用Object类中的toString()，默认输出对象hashCode值。

● 可以根据需要在用户自定义类型中 重写toString( ) 方法。

public class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    //可以通过右键菜单栏中的Generate -> toString自行选择要重写的内容
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class TestPerson {
    public static void main(String[] args) {
        new Person().hashCode(); //继承于Object类
        new int[1].hashCode();   //数组也继承于Object类


        Person p = new Person("张三",20);
        /*
        输出一个对象，但是对象在内存中存储的，是不能输出的
        当输出一个对象时，会默认调用此对象的 toString();
        把对象通过字符串输出出来
         */
        System.out.println(p); //day1.javaapi.objectdemo.Person@74a14482
        //如果将toString()重写，那就会执行重写后的
    }
}

● equals方法

public boolean equals(Object obj)方法，判断对象是否相等的逻辑。

● Object类中定义有：

public boolean equals(Object obj) {

return (this == obj);

}

● Object 中的 equals 方法默认使用 “==” 比较，比较的是对象地址，这点需要注意。

● JDK提供的一些类，如String，Date等，重写了Object的equals方法，调用这些类的equals方法， x.equals (y) ，当x和y所引用的对象是同一类对象且属性内容相等返回 true ，否则返回 false。

public class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    //可以通过右键菜单栏中的Generate -> toString自行选择要重写的内容
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //重写equals()方法，使得它可以用来比较对象的内容而不是地址

    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Person){// instanceof 它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。
            //将 obj 向下转型
            Person other = (Person)obj;
            //以内容进行比较
            return name.equals(other.name) && age == other.age;
        }
        return false;

    }
}

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

        /*
        boolean equals(Object obj)
        判断两个对象是否相等

        public boolean equals(Object obj) {
            return (this == obj);
        }
        其中用于比较的是 == 在比较引用类型时会出问题
        所以在其他类中一般会把equals()重写，使得它可以用来比较对象的内容
         */
        /*
        双等号“==”：比较等号两边是否相等
        当 == 用于比较基本类型时，比较的是变量的值是否相等
        当 == 用于比较引用类型时，比较的是对象的地址是否相同

         */
        Person p1 = new Person("张三",20);
        Person p2 = new Person("张三",20);

        System.out.println(p1.equals(p2)); //false --在Person类中重写后--> true
        System.out.println(p1==p2); //比较地址是否相同

        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1.equals(s2));//true
        /*
        String类把equals方法重写了：
        public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }
         */
    }
}

三、 Arrays类

java.util（工具）.Arrays类用于操作数组工具类，里面定义了常见操作数组的静态方法。

● equals 方法

比较两个数组对象中元素是否相等

而数组对象中的 equals() 用来判断一个数组与另一个数组对象是否相等。

声明：

public static boolean equals( type[ ]a , type[ ] a2 )

参数的类型可以是原生数据类型和引用类型的任意一种类型

返回值：

如果两个相等，则返回true，否则返回false

import java.util.Arrays;

/*
equals()方法
 */
public class Arrays1 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4};
        int[] b = {1,2,3,4};

        System.out.println(Arrays.equals(a,b)); //true
        System.out.println(a==b);    //false
    }

}

● sort －排序

将指定的类型数组的元素按数字升序进行排序。

• 作用于数组的所有元素

声明：

public static void sort( type[ ] a )

import java.util.Arrays;

/*
sort方法 --- 排序
将数组内的元素按照升序排列
 */
public class Arrays2 {
    public static void main(String[] args) {
        int[] a = {15,11,3,4,2,10};

        Arrays.sort(a); //全部排序
        System.out.println(Arrays.toString(a));
        
    }
}

• 作用于数组指定范围内的元素

声明：

public static void sort( type[ ] a, int fromIndex(包括) , int toIndex(不包括))

import java.util.Arrays;

/*
sort方法 --- 排序
将数组内的元素按照升序排列
 */
public class Arrays2 {
    public static void main(String[] args) {
        int[] b = {6,5,4,3,2,1};
        
        /*
        范围排序
        */
        Arrays.sort(b,0,3);//从第0个（包含）到第3个（不包含）位置进行排序
        System.out.println(Arrays.toString(b));

    }
}

• 自定义对象排序

自定义类实现Comparable接口

重写compareTo方法

• 对引用类型的排序

● binarySearch－使用二分搜索算法搜索指定数组

注：使用前数组必须有序

• 声明

public static int binarySearch( type[ ] a , type key )

public static int binarySearch( long[ ] a , int fromIndex , int toIndex , long key )

• 参数

a - 要搜索的数组。

key - 要搜索的值。

fromIndex - 要排序的第一个元素的索引（包括）。

toIndex - 要排序的最后一个元素的索引（不包括）。

如果key在数组中，则返回搜索值的索引；否则返回负数，表示不存在

import java.util.Arrays;

/*
binarySearch
使用二分搜索算法搜索指定数组

public static int binarySearch( type[ ] a , type key )

public static int binarySearch( long[ ] a , int fromIndex , int toIndex , long key )

 */
public class Arrays3 {
    public static void main(String[] args) {
        int[] a = {1,3,5,7,9};

        int index1 = Arrays.binarySearch(a,2);
        int index2 = Arrays.binarySearch(a,1);
        System.out.println(index1); // -1 表示数不存在
        System.out.println(index2); // 0 表示查找到的数在第0位

    }
}

● copyOf方法

数组复制：将指定数组中的元素复制到一个指定长度的新数组中，并返回新数组。

声明：

static int[ ] copyOf( int[ ] a , int newLength )

import java.util.Arrays;

/*
因为Java中数组的长度是固定的，放满了就没法再扩展
所以引入了 copyOf()方法
    static int[ ] copyOf( int[ ] a , int newLength )
 */
public class Arrays4 {
    public static void main(String[] args) {
        int[] a = new int[5];
        a[0] = 1;
        a[1] = 2;
        a[2] = 3;
        a[3] = 4;
        a[4] = 5;
        /*
        此时 a这个数组放满了，
        一般我们创建一个新数组，
        然后将a数组中的数一个一个赋值过去
         */
        int[] b = Arrays.copyOf(a,10);
        System.out.println(Arrays.toString(b));


    }
}

● fill方法

将指定的int值分配给指定的int数组的每个元素。

声明：

fill ( int[ ] a , int val )

import java.util.Arrays;

/*
fill方法
    将指定的int值分配给指定的int数组的每个元素。
    fill ( int[] a , int val )
 */
public class Arrays5 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5};
        System.out.println("原数组："+Arrays.toString(a));
        //当我们想给数组元素全部归零时
        Arrays.fill(a,0);
        System.out.println("现数组："+Arrays.toString(a));



    }

}

● toString() 方法

返回指定数组内容的字符串表示形式（将数组中的元素内容拼接为一个字符串输出）

声明：

public static String toString( type[ ] a )

四、基本数据类型封装

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进表示，这样八个和基本数据类型对应的类统称为包装类。

● 包装类（如：Integer，Double等）：

这些类封装了一个相应的基本数据类型数值，并为其提供了一系列操作方法。

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

● 用途：

● 作为和基本数据类型对应的类类型存在。

● 包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。

● 包装类常用属性方法：

以下方法以java.lang.Integer为例：

成员变量：

        public static final int MAX_VALUE 最大的int型数（2147483647）

        public static final int MIN_VALUE 最小的int型数（-2147483648）

构造方法：

        Integer(int a);

        Integer(String a);

比较方法：

        static int compareTo(Integer a);

        boolean equals(Object);

        int max(int a,int b);

        int min(int a,int b);

转换方法：

        static toBinaryString(int i);

        static String toHexString(int i);

        static String toOctalString(int i);

        int intValue();

        static int parseInt(String s);

        String toString();

        static Integer valueOf(int i)

        static Integer valueOf(String s)

public class IntegerTest {
    public static void main(String[] args) {
        Integer integer = new Integer(20);
        /*
        在保证存在数据类型的同时可以使用多种功能
         */
        System.out.println(integer.intValue()); //封装类转化为基本类型（返回值为int）
        System.out.println(integer.hashCode());
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
    }
}

● 装箱和拆箱Auto-boxing/unboxing

• 装箱

自动将基本数据类型转换为包装器类型

装箱的时候自动调用的是Integer的valueOf(int)方法

• 拆箱

自动将包装器类型转换为基本数据类型

拆箱的时候自动调用的是Integer的intValue方法

/*
装箱与拆箱

装箱：
    自动将基本数据类型转换为包装器类型
    装箱的时候自动调用的是Integer的valueOf(int)方法
拆箱：
    自动将包装器类型转换为基本数据类型
    拆箱的时候自动调用的是Integer的intValue方法

 */
public class BoxingDemo {
    public static void main(String[] args) {

        int a = 12;
        //装箱
        Integer aa = Integer.valueOf(a);
        //拆箱
        int aaa = aa.intValue();

        int b = 10;
        //自动装箱
        Integer bb = b;  //隐式的自动调用valueOf(int)方法
        //自动拆箱
        int bbb = bb;  隐式的自动调用intValue方法
    }
}

注意：在自动装箱时默认调用的valueOf( )方法会产生歧义：

原码：

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

由此可以看出，实际上Java对于某个范围中的数（-128~127）构建了一个集合，
当这个数在集合中时，可以直接调取数组中的Integer对象，以减少创建次数，所以当 x = 10 时，结果是true
而当数不在这个范围内时，则会新建一个对象，所以当 x = 128时，结果为false

        int x = 128;
        Integer y = x;
        Integer z = x;
        System.out.println(y==z);
        //true x = 10 时
        //false x = 128 时

所以，当比较两个对象的值的时候，最好使用equals()方法来比较