JavaSE基础:Arrays工具类

时间 2019-11-16

原文原文链接

Java工具类: Arrays

Arrays类是数组的操做类,定义在java.util包中,主要功能是实现数组元素的查找/数组内容的充填/排序等功能html

1.排序数组的sort方法

重点:对数组元素进行排序操做,默认由小到大排序.java

该方法的参数不只能够是基础数据类型的数组，也能够是对象引用的数组。同时还能够指定数组中须要排序的元素的索引范围。算法

当对对象进行排序时，数组中的全部元素都必须实现 Comparable 接口。(就当你没有看到,哈哈)api

即数组中的全部元素都必须是可相互比较的（也就是说，对于数组中的任何 e1 和 e2 元素而言，e1.compareTo(e2) 不得抛出 ClassCastException）数组

(1) 数字排序

排序规则:由小到大排序框架

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest01 {
    public static void main(String[] args) {
        int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
        Arrays.sort(a);
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + "\t");
        }
    }
}
复制代码

(2) 字符串排序

排序规则:先大写后小写dom

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest02 {
    public static void main(String[] args) {
        String[] a = {"a","A","b","B"};
        Arrays.sort(a);
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + "\t");
        }
    }
}
复制代码

(3) 字符串严格排序

排序规则:严格按字母表顺序排序，也就是忽略大小写排序 Case-insensitive sortide

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest03 {
    public static void main(String[] args) {
        String[] a = {"a","C","b","D"};
        Arrays.sort(a,String.CASE_INSENSITIVE_ORDER);
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + "\t");
        }
    }
}
复制代码

(4) 反向排序

排序规则:先小写后大写工具

字符串反向学习

package com.shxt.demo03;

import java.util.Arrays;
import java.util.Collections;

public class ArraysTest04 {
    public static void main(String[] args) {
        String[] a = {"a","A","b","B"};
        Arrays.sort(a, Collections.reverseOrder());//Collections 集合类中的工具类
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + "\t");
        }
    }
}
复制代码

数字排序,要使用包装类

package com.shxt.demo03;

import java.util.Arrays;
import java.util.Collections;

public class ArraysTest05 {
    public static void main(String[] args) {
        //不能使用基本数据类型
        Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
        Arrays.sort(a, Collections.reverseOrder());
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + "\t");
        }
    }
}
复制代码

这个里面咱们使用了Collections工具类,若是想本身完成规则的定义,那么就须要使用比较器接口Comparable(简单了解便可)

package com.shxt.demo03;

import java.util.Arrays;
import java.util.Comparator;

public class ArraysTest05_1 {
    public static void main(String[] args) {
        //不能使用基本数据类型
        Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
        Arrays.sort(a, new IntegerComparator());
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + "\t");
        }
    }
}

/** * Comparator是一个接口 * 因此这里咱们本身定义的类IntegerComparator要implents该接口 * 而不是extends Comparator * */
class IntegerComparator implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        //若是o1小于o2，咱们就返回正值，若是n1大于n2咱们就返回负值，
        //这样颠倒一下，就能够实现反向排序了
        if(o1 < o2) {
            return 1;
        }else if(o1 > o2) {
            return -1;
        }else {
            return 0;
        }
    }
}
复制代码

(5) 忽略大小写反向排序

package com.shxt.demo03;

import java.util.Arrays;
import java.util.Collections;

public class ArraysTest04 {
    public static void main(String[] args) {
        String[] a = {"a","C","b","D"};
        Arrays.sort(a, Collections.reverseOrder());
        Collections.reverse(Arrays.asList(a));//先忽略吧
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + "\t");
        }
    }
}
复制代码

(6) 区间排序-了解

Arrays.sort(int[] a, int fromIndex, int toIndex)
复制代码

这种形式是对数组部分排序，也就是对数组a的下标从fromIndex到toIndex-1的元素排序，注意：下标为toIndex的元素不参与排序！

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest07 {
    public static void main(String[] args) {
        int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
        Arrays.sort(a, 0, 3);
        for(int i = 0; i < a.length; i ++) {
            System.out.print(a[i] + " ");
        }
    }
}
//运行结果为: 7 8 9 2 3 4 1 0 6 5 
复制代码

Java初学者最多见的错误思想，就是试图去写一些方法来完成数组的排序功能，

其实，数组排序功能，在java的api里面早已实现，咱们没有必要去重复制造轮子。

若是你是应届生,仍是须要学习各类排序的,参考网址:http://geek.csdn.net/news/detail/113928

JDK8强大了排序功能:parallelSort
parallelSort是java8中新出的一种排序API，
这是一种并行排序，Arrays.parallelSort使用了Java7的Fork/Join框架使排序任务能够在线程池中的多个线程中进行，
Fork/Join实现了一种任务窃取算法，一个闲置的线程能够窃取其余线程的闲置任务进行处理
发现数据量越大，parallelSort的优点就越明显。
复制代码

2.查找数组的binarySearch方法

public static int binarySearch(T[] a, T key) 复制代码

使用二分搜索法来搜索指定类型数组，以得到指定的值。

[重点]必须在进行此调用以前对数组进行排序（经过 sort() 方法）。

若是没有对数组进行排序，则结果是不肯定的。若是数组包含多个带有指定值的元素，则没法保证找到的是哪个。

返回值说明:

一、若是找到关键字，则返回值为关键字在数组中的位置索引，且索引从0开始

二、若是没有找到关键字，返回值为负的插入点值，所谓插入点值就是第一个比关键字大的元素在数组中的位置索引，并且这个位置索引从1开始 (-(插入点)),若是数组中的全部元素都小于指定的键，则为(-a.length-1)。

package com.shxt.demo03;

import java.util.Arrays;

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

        int[] b = new int[]{4, 25, 10, 95, 06, 21};
        System.out.println("原数组为：");
        for (int dim1 : b) {
            System.out.print("" + dim1 + " ");
        }
        //必定要先排序
        Arrays.sort(b);
        System.out.println("排序后为：");
        for (int x : b) {
            System.out.print(x + " ");
        }
        System.out.println();
        int index = Arrays.binarySearch(b, 2);
        System.out.println("关键字2的返回值为：" + index);

        index = Arrays.binarySearch(b, 20);
        System.out.println("关键字20的返回值为：" + index);

        index = Arrays.binarySearch(b, 30);
        System.out.println("关键字30的返回值为：" + index);

        index = Arrays.binarySearch(b, 100);
        System.out.println("关键字100的返回值为：" + index);

        index = Arrays.binarySearch(b, 10);
        System.out.println("关键字10的返回值为：" + index);


    }
}
复制代码

结果分析以下:
原数组为：
4 25 10 95 6 21 
排序后为：
4 6 10 21 25 95 
关键字2的返回值为：-1 
关键字2并无在数组中，并且2比数组中的任何一个元素都小，因此其插入点的值应为元素4的位置也就是1(没有找到关键字从1开始）

关键字20的返回值为：-4
关键字20也不在数组中，数组中第一个比20大的数是21，因此20的插入点值为4（没用找到关键字从索引从1开始）

关键字30的返回值为：-6
关键字30也不在数组中，数组中第一个比30大的数是95，因此30的插入点值为6（没用找到关键字从索引从1开始）

关键字100的返回值为：-7 
关键字100也不在数组中，并且100比数组中全部的元素都大，此时插入点值为length+1 为7（没有找到关键字索引从1开始）

关键字10的返回值为：2
关键字10在数组中，因此返回其在数组中的索引为2（找到关键字索引从0开始）
复制代码

3.充填数组的fill()方法

用指定的值来填充数组，能够指定须要填充的索引范围。

package com.shxt.demo03;

import java.util.Arrays;

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

        Integer[] a = new Integer[5];
        Arrays.fill(a, 2);
        System.out.println("当前数组容器："+Arrays.toString(a));
        Arrays.fill(a, 5);
        // 数字3覆盖并填满了整个Array容器
        System.out.println("当前数组容器："+Arrays.toString(a));
        // 填充的开始位
        Integer startIndex = 1;
        // 填充的结束位
        Integer endIndex = 3;
        Arrays.fill(a, startIndex, endIndex, 8);
        System.out.println("当前数组容器："+Arrays.toString(a));

    }
}
/* 当前数组容器：[2, 2, 2, 2, 2] 当前数组容器：[5, 5, 5, 5, 5] 当前数组容器：[5, 8, 8, 5, 5] */
复制代码

4.比较两个数组的equals方法

若是两个指定类型数组彼此相等，则返回 true。若是两个数组包含相同数量的元素，而且两个数组中的全部相应元素对都是相等的，则认为这两个数组是相等的。换句话说，若是两个数组以相同顺序包含相同的元素，则两个数组是相等的。此外，若是两个数组引用都为 null，则认为它们是相等的。

equals方法适用于一维数组，多维数组则使用deepEquals()，用法同equals。

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest10 {
    public static void main(String[] args) {
        int[] array1={5,6,9,3,2,4};
        int[] array2={5,6,9,3,2,4};
        int[] array3={6,5,9,3,2,4};
        boolean flag1=Arrays.equals(array1,array2); // true
        boolean flag2=Arrays.equals(array1,array3); // false

        //直接使用equals方法会是什么结果呢?
        boolean flag3 = array1.equals(array2); //堆内存地址不同 false array1==array2


        System.out.println(flag1+" "+flag2+" "+flag3);

    }
}
复制代码

5.数组转字符串toString()方法

返回指定数组内容的字符串表示形式。

字符串表示形式由数组的元素列表组成，括在方括号（"[]"）中。

相邻元素用字符 ", "（逗号加空格）分隔。

这些元素经过 String.valueOf(short) 转换为字符串。若是 a 为 null，则返回 "null"。

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest11 {
    public static void main(String[] args) {
        String[] array01 = new String[3];
        System.out.println(array01);
        System.out.println(Arrays.toString(array01));
        
        String[] array02 = {"悟空","八戒","唐僧"};
        System.out.println(array02);
        System.out.println(Arrays.toString(array02));

    }
}
复制代码

6.克隆数组的copyOf方法

若是你想扩大数组容量又不想改变它的内容的时候可使用这个方法

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest13 {
    public static void main(String[] args) {
        int[] array1={5,6,9,3,2,4};
        System.out.println("array1的数组长度:"+array1.length);

        int[] array2 = Arrays.copyOf(array1,array1.length+1);//根据实际状况扩容
        System.out.println("array2的数组长度:"+array2.length);

        array2[0]=100;

        System.out.println("array1:"+Arrays.toString(array1));
        System.out.println("array2:"+Arrays.toString(array2));
        
    }
}
/** array1的数组长度:6 array2的数组长度:7 array1:[5, 6, 9, 3, 2, 4] array2:[100, 6, 9, 3, 2, 4, 0] */
复制代码

array1 和 array2 是两个不相干的数组

7.克隆数组的copyOfRange方法

copyOfRange(int []original,int from,int to)
复制代码

original为原始的int型数组，from为开始角标值，to为终止角标值。（其中包括from角标，不包括to角标。即处于[from,to)状态）

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest14 {
    public static void main(String[] args) {
        int[] array1={5,6,9,3,2,4};
        int[] array2 = Arrays.copyOfRange(array1,1,5);
        System.out.println("array2的数组长度:"+array2.length);

        System.out.println("array2:"+Arrays.toString(array2));

    }
}
// 运行结果: array2的数组长度:4
// array2:[6, 9, 3, 2]
复制代码

这个方法比循环遍历复制数组效率要高。

8.数组转列表asList方法

返回一个受指定数组支持的固定大小的列表。（对返回列表的更改会“直接写”到数组。）此方法同Collection.toArray()一块儿，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的，而且实现了 RandomAccess。

package com.shxt.demo03;

import java.util.Arrays;
import java.util.List;

public class ArraysTest15 {
    public static void main(String[] args) {
        Integer[] array1={5,6,9,3,2,4};
        List list = Arrays.asList(array1);
        System.out.println("list的长度:"+list.size());
    }
}
// list的长度:6

复制代码

避免使用基本数据类型数组转换为列表

对上述的代码改造一下,改成基本数据类型的数组

package com.shxt.demo03;

import java.util.Arrays;
import java.util.List;

public class ArraysTest15 {
    public static void main(String[] args) {
        int[] array1={5,6,9,3,2,4};
        List list = Arrays.asList(array1);
        System.out.println("list的长度:"+list.size());
        System.out.println(list);
    }
}
/** list的长度:1 [[I@4554617c] */
复制代码

程序的运行结果并无像咱们预期的那样是 6 而是逆天的 1，这是什么状况？

从这个运行结果咱们能够充分证实 list 里面的元素就是 int 数组。

转换为列表后不能添加元素

package com.shxt.demo03;

import java.util.Arrays;
import java.util.List;

public class ArraysTest15 {
    public static void main(String[] args) {
        Integer[] array1={5,6,9,3,2,4};
        List list = Arrays.asList(array1);
        list.add(99);//添加元素
    }
}
复制代码

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.AbstractList.add(AbstractList.java:148)
	at java.util.AbstractList.add(AbstractList.java:108)
	at com.shxt.demo03.ArraysTest15.main(ArraysTest15.java:10)
复制代码

若是想给列表添加数据,须要从新构造列表

package com.shxt.demo03;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ArraysTest15 {
    public static void main(String[] args) {
        Integer[] array1={5,6,9,3,2,4};
        List list = Arrays.asList(array1);
        //再次转换
        List tempList = new ArrayList(list);
        tempList.add(666);
        //能够添加
        System.out.println(tempList);
    }
}
复制代码

9.数组的哈希码hashCode

基于指定数组的内容返回哈希码。对于任何两个知足 Arrays.equals(a, b) 的同类型数组 a 和 b，也能够说 Arrays.hashCode(a) ==Arrays.hashCode(b)。

此方法返回的值与在 List 上调用 hashCode 方法得到的值相同，该 List 包含以相同顺序表示 a 数组元素的实例的序列。若是 a 为 null，则此方法返回 0。

package com.shxt.demo03;

import java.util.Arrays;

public class ArraysTest12 {
    public static void main(String[] args) {
        int[] array1={5,6,9,3,2,4};
        int[] array2={5,6,9,3,2,4};
        int[] array3={6,5,9,3,2,4};

        System.out.println(Arrays.hashCode(array1));
        System.out.println(Arrays.hashCode(array2));
        System.out.println(Arrays.hashCode(array3));

        System.out.println("---------------------");
        //全部的都不同
        System.out.println(array1.hashCode());
        System.out.println(array2.hashCode());
        System.out.println(array3.hashCode());

    }
}
/* 1036461630 1036461630 1064167260 --------------------- 1163157884 1956725890 356573597 */
复制代码