Java学习笔记七——数组工具类Arrays

数组工具类Arrays

　　Java提供的Arrays类里包含的一些static修饰的方法可以直接操作数组。若将里面的方法用熟的话，那开发效率会大大提高。下面介绍其中的方法。

List<T> asList(T... a)

　　作用：将指定数组或数组元素，转换成固定大小的List。

　　用法：

        String[] strArr = { "aaa", "bbb", "vvv" };
        //用法1：参数是数组引用
        List<String> list = Arrays.asList(strArr);
        for (String str : list) {
            System.out.println(str);
        }

        //用法2：参数是不限个数的数组元素
        List<String> list2 = Arrays.asList("aaa", "bbb", "vvv");
        for (String str : list2) {
            System.out.println(str);
        }

　　注意：参数列表虽然是不定参数，但只有上面两种用法：要么是一个数组引用，要么是数据类型一致的多个参数。

int binarySearch(type[] a,type key)

　　作用：使用二分法查询元素key在数组a中出现的索引。

　　type：char，byte，short，int，float，double，String和自定义对象。

　　限制：1.若type是基本数据类型或String，则数组a的元素必须是按照升序排列好的；

　　        2.若type是自定义对象，则该对象必须实现Comparable接口（只有一个compareTo方法，用于规定对象比较大小规则），且数组a的元素必须是按照升序排列好的。

　　例子：

        int[] intArr = {12,34,45,56,67,78,89};
        int indexInt = Arrays.binarySearch(intArr, 67);
        System.out.println(indexInt); //

        String[] strArr = { "aaa", "bbb","ccc", "vvv" };
        int indexStr = Arrays.binarySearch(strArr, "ccc");
        System.out.println(indexStr); //

　　下面看一个type是自定义对象的例子：

//自定义对象 ，必须实现Comparable接口
public class Model implements Comparable<Model> {

    public int age;

    //规定两个对象之间比较大小的规则，按照参数顺序，
    //若返回1，则当前对象>m；
    //若返回0，则当前对象==m；
    //若返回-1，则当前对象<m；
    //
    @Override
    public int compareTo(Model m) {
        if(age >m.age){
            return 1;
        }
        if(age == m.age){
            return 0;
        }
        //剩下的就是小于
        return -1;
    }
}

public class Test {

    public static void main(String[] args) {

        //定义3个Model对象
        Model m1 = new Model();
        m1.age = 20;
        Model m2 = new Model();
        m2.age = 45;
        Model m3 = new Model();
        m3.age = 32;
        //定义数组，按照从小到大顺序，即升序
        Model[] mArr = {m1,m3,m2};

        int indexM = Arrays.binarySearch(mArr, m3);
        System.out.println(indexM);  //
    }
}

int binarySearch(type[] a,int fromIndex,int toIndex,typekey)

　　作用：与上个方法类似，只是搜索数组a中fromIndex索引到toIndex索引之间的元素。

　　type：char，byte，short，int，float，double，String和自定义对象。

　　限制：同上。

　　例子：略

type[] copyOf(type[] original,int newLength)

　　作用：复制数组original的newLength个元素，组成新的数组，并返回这个新数组。

　　type：type：基本类型，String类型和自定义对象。

　　说明：若newLength小于original数组的长度，则返回original数组的前newLength个元素；若newLength大于original数组的长度，则则不足的补充0（数值类型）、false（布尔类型）、null（引用类型）。

　　例子：

public class Test {

    public static void main(String[] args) {

        int[] original = {1,2,3,4,5};
        //小于original数组长度
        int[] newArr = Arrays.copyOf(original, 3);
        for (int i : newArr) {
            System.out.println(i);  //1,2,3
        }

        //大于original数组长度
        int[] newArr2 = Arrays.copyOf(original, 8);
        for (int i : newArr2) {
            System.out.println(i);  //1,2,3,4,5,0,0,0
        }

    }
}

type[] copyOfRangetype[] original,int from,int to)

　　作用：复制original中索引从from到to之间的元素（包括from，不包括to），组成新数组并返回该新数组。

　　type：基本类型，String类型和自定义对象。

　　例子：

import java.util.Arrays;

public class Test {

    public static void main(String[] args) {

        int[] original = { 1, 2, 3, 4, 5 };
        int[] newArr = Arrays.copyOfRange(original, 0, 2);
        for (int i : newArr) {
            System.out.println(i); // 1,2
        }

    }
}

boolean equals(type[] a1, type[] a2)

　　作用，比较两个数组，若a1和a2的长度相等，并且a1的每个元素都与a2与之对应索引的元素都相等，则返回true；否则返回false

　　type：基本类型，String类型和自定义类型（实现Comparable接口）

　　例子：

import java.util.Arrays;

public class Test {

    public static void main(String[] args) {

        String[] a1 = { "aaa","bbb","ccc"};
        String[] a2 = { "aaa","bbb","ccc"};
        String[] a3 = { "aaa","www","ccc"};
        boolean a1a2 = Arrays.equals(a1, a2);
        System.out.println(a1a2);  //true

        boolean a1a3 = Arrays.equals(a1, a3);
        System.out.println(a1a3);  //false
    }
}

void fill(type[] a,type val)

　　作用：将数组a的元素全部赋值为val，若原来有值，则覆盖。相当于用val填充数组a。

　　type：基本类型，String类型和自定义类型

　　例子：

import java.util.Arrays;

public class Test {

    public static void main(String[] args) {

        String[] a = new String[5];
        Arrays.fill(a, "aaa");
        for (String str : a) {
            System.out.println(str);  //打印5次 "aaa"
        }
    }
}

void fill( type[] a,int fromIndex,int toIndex,type val)

　　作用：用val填充数组a中索引从fromIndex到索引toIndex的元素，包括fromIndex，不包括toIndex

　　type：基本类型，String类型和自定义类型

　　例子：

import java.util.Arrays;

public class Test {

    public static void main(String[] args) {

        String[] a = { "111", "222", "333", "444444", "5555555555" };
        Arrays.fill(a, 2, 4, "mmm");
        for (String str : a) {
            System.out.println(str); // 打印"111", "222","mmm","mmm","5555555555"
        }
    }
}

未完待续。。。