JavaSE基礎:Arrays工具類

時間  2021-08-13
標籤 html java 算法 api 數組 markdown 框架 dom ide 工具 欄目 Java 简体版
原文   原文鏈接

Java工具類: Arrays

Arrays類是數組的操做類,定義在java.util包中,主要功能是實現數組元素的查找/數組內容的充填/排序等功能html

1.排序數組的sort方法

重點:對數組元素進行排序操做,默認由小到大排序.java

該方法的參數不只能夠是基礎數據類型的數組，也能夠是對象引用的數組。同時還能夠指定數組中須要排序的元素的索引範圍。算法

當對對象進行排序時，數組中的全部元素都必須實現 Comparable 接口。(就當你沒有看到,哈哈)api

即數組中的全部元素都必須是可相互比較的（也就是說，對於數組中的任何 e1 和 e2 元素而言，e1.compareTo(e2) 不得拋出 ClassCastException）數組

(1) 數字排序

排序規則:由小到大排序markdown

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) 字符串排序

排序規則:先大寫後小寫框架

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 sortdom

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) 反向排序

排序規則:先小寫後大寫ide

字符串反向工具

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 */
複製代碼
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程