Java基礎之集合框架系列（五）

原創 CodingEnding 2020-02-22 14:52

1.集合工具類概述

2.Collections類

專門對集合進行操作的工具類，裏面全都是靜態方法，可以直接調用。

1.排序

使用場景：List系列集合可以存儲相同的元素，但是無法進行排序，這時就可以使用Collelctions的靜態方法進行排序操作

static <T extends Comparable<? super T>> void sort(List<T>list)
根據元素的自然順序，對指定列表按升序進行排序。

說明：使用以上排序方法時，要求被比較的元素必須實現comparable接口

static <T> void sort(List<T> list, Comparator<? super T> c)
根據指定比較器產生的順序對指定列表進行排序。

說明：使用以上排序方法時，不要求被比較的元素實現comparable接口，因爲排序方式可以在比較器Comparator中進行規定。

示例代碼:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

//自定義比較器-根據字符串長度進行排序
class StrLenComp implements Comparator<String>{

    @Override
    public int compare(String o1, String o2) {
        if(o1.length()>o2.length())
            return 1;
        if(o1.length()==o2.length())
            return o1.compareTo(o2);//當字符串長度相等時將自然順序作爲排序依據
        else
            return -1;
    }

}

//測試用類
public class CollectionsDemo {

    public static void main(String[] args) {
        //新建ArrayList集合
        ArrayList<String> al=new ArrayList<String>();
        al.add("python");
        al.add("R");
        al.add("java");
        al.add("js");
        al.add("ruby");

        System.out.println("原始集合："+al);

        //使用工具類中的方法對List進行自然排序
        Collections.sort(al);
        System.out.println("自然排序後的集合："+al);

        //使用工具類中的方法對List進行排序-按照字符串的長度
        Collections.sort(al, new StrLenComp());
        System.out.println("傳入自定義比較器排序後的集合"+al);
    }

}

程序運行結果：

原始集合：[python, R, java, js, ruby]
自然排序後的集合：[R, java, js, python, ruby]
傳入自定義比較器排序後的集合[R, js, java, ruby, python]

2.最值

static <T extends Object & Comparable<? super T>>
T max(Collection<? extends T> coll)
根據元素的自然順序，返回給定 collection 的最大元素。

static <T extends Object & Comparable<? super T>>
T min(Collection<? extends T> coll)
根據元素的自然順序 返回給定 collection 的最小元素。

說明：使用以上方法時，要求集合中的元素必須實現Comparable接口

static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
根據指定比較器產生的順序，返回給定 collection 的最大元素。
static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)
根據指定比較器產生的順序，返回給定 collection 的最小元素。

說明：使用以上排序方法時，不要求被比較的元素實現comparable接口。因爲排序方式可以在比較器中進行規定。

示例代碼：

        //部分代碼-本例中的自定義比較器與排序中的比較器類一致，此處省略
        //新建ArrayList集合
        ArrayList<String> al=new ArrayList<String>();
        al.add("python");
        al.add("R");
        al.add("java");
        al.add("js");
        al.add("ruby");

        System.out.println("原始集合："+al);
        //根據元素的自然順序，返回給定List的最大、最小元素。
        String maxStr=Collections.max(al);
        String minStr=Collections.min(al);

        System.out.println("自然順序下的最大元素："+maxStr);
        System.out.println("自然順序下的最小元素："+minStr);

        //根據指定比較器的排序依據，返回List中的最大、最小元素
        String maxStrByComp=Collections.max(al, new StrLenComp());
        String minStrByComp=Collections.min(al,new StrLenComp());

        System.out.println("按照比較器順序獲得的最大元素："+maxStrByComp);
        System.out.println("按照比較器順序獲得的最小元素："+minStrByComp);

程序運行結果：

原始集合：[python, R, java, js, ruby]
自然順序下的最大元素：ruby
自然順序下的最小元素：R
按照比較器順序獲得的最大元素：python
按照比較器順序獲得的最小元素：R

3.二分查找

static<T> int binarySearch(List<? extends Comparable<? super T>>list, T key)
使用二分搜索法搜索指定列表，以獲得指定對象。被操作的List對象需要實現Comparable接口，即自身具備比較性。

static <T> int binarySearch(List<? extends T> list,
T key,Comparator<? super T> c)
使用二分搜索法搜索指定列表，以獲得指定對象。被操作的List對象不必實現Comparable接口，但該方法需要傳入一個比較器對象，即通過比較器對List集合中的元素進行排序。

方法說明：如果搜索的元素包含在List中，則返回搜索值的索引；否則返回 (-(插入點) - 1)。插入點被定義爲將鍵插入列表的那一點，即第一個大於此鍵的元素索引。如果列表中的所有元素都小於指定的鍵，則爲 list.size()，即插入點位於List尾部。注意，這保證了當且僅當此鍵被找到時，返回的值將 >= 0。

注意：以上方法只能查找List系列集合中的指定元素，因爲使用二分法查找元素要求操作索引。並且操作的對象必須是先進行相應排序後的有序集合。

示例代碼：

        //部分代碼-本例中的自定義比較器與排序中的比較器類一致，此處省略
        //新建ArrayList集合
        ArrayList<String> al=new ArrayList<String>();
        al.add("python");
        al.add("R");
        al.add("java");
        al.add("js");
        al.add("ruby");

        System.out.println("原始集合："+al);

        //對集合進行自然排序
        Collections.sort(al);
        System.out.println("自然排序後的集合："+al);
        //使用二分查找法按照自然順序查找List集合中的特定元素
        int existIndex=Collections.binarySearch(al,"js");
        int notExistindex=Collections.binarySearch(al,"javas");

        System.out.println("按自然順序查找存在的特定元素："+existIndex);
        System.out.println("按自然順序查找不存在的特定元素："+notExistindex);

        //對集合進行自定義比較器排序
        Collections.sort(al, new StrLenComp());
        System.out.println("傳入自定義比較器排序後的集合"+al);
        //使用二分查找法按照自定義比較器順序查找List集合的特定元素
        int existIndexByComp=Collections.binarySearch(al, "js", new StrLenComp());

        System.out.println("按照自定義比較器的順序查找存在的元素："+existIndexByComp);

程序運行結果：

原始集合：[python, R, java, js, ruby]
自然排序後的集合：[R, java, js, python, ruby]
按自然順序查找存在的特定元素：2
按自然順序查找不存在的特定元素：-3
傳入自定義比較器排序後的集合[R, js, java, ruby, python]
按照自定義比較器的順序查找存在的元素：1

4.元素互換

static void swap(List<?> list, int i, int j)
在指定列表的指定位置處交換元素。

示例代碼：

        //部分代碼
        //新建ArrayList集合
        ArrayList<String> al=new ArrayList<String>();
        al.add("python");
        al.add("R");
        al.add("java");
        al.add("js");
        al.add("ruby");

        System.out.println("原始集合："+al);
        //交換集合中索引爲1和3的兩個元素
        Collections.swap(al, 1, 3);
        System.out.println("交換元素後的集合："+al);

程序運行結果：

原始集合：[python, R, java, js, ruby]
交換元素後的集合：[python, js, java, R, ruby]

5.批量填充

static <T> void fill(List<? super T> list, T obj)
使用指定元素替換指定列表中的所有元素。

示例代碼：

        //部分代碼
        //新建ArrayList集合
        ArrayList<String> al=new ArrayList<String>();
        al.add("python");
        al.add("R");
        al.add("java");
        al.add("js");
        al.add("ruby");

        System.out.println("原始集合："+al); 
        //使用demo填充集合中的所有元素
        Collections.fill(al,"demo");
        System.out.println("經過填充後的集合："+al);

程序運行結果：

原始集合：[python, R, java, js, ruby]
經過填充後的集合：[demo, demo, demo, demo, demo]

6.批量代替

static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
使用另一個值替換列表中出現的所有某一指定值。

示例代碼：

        //部分代碼
        //新建ArrayList集合
        ArrayList<String> al=new ArrayList<String>();
        al.add("python");
        al.add("R");
        al.add("java");
        al.add("js");
        al.add("ruby");

        System.out.println("原始集合："+al); 

        //將集合中的java替換爲demo
        Collections.replaceAll(al, "java", "demo");
        System.out.println("經過代替後的集合："+al);

程序運行結果：

原始集合：[python, R, java, js, ruby]
經過代替後的集合：[python, R, demo, js, ruby]

7.反轉集合

static void reverse(List<?> list)
反轉指定列表中元素的順序。

示例代碼：

        //部分代碼
        //新建ArrayList集合
        ArrayList<String> al=new ArrayList<String>();
        al.add("python");
        al.add("R");
        al.add("java");
        al.add("js");
        al.add("ruby");

        System.out.println("原始集合："+al);         
        //對集合進行反轉
        Collections.reverse(al);
        System.out.println("反轉後的集合："+al);

程序運行結果：

原始集合：[python, R, java, js, ruby]
反轉後的集合：[ruby, js, java, R, python]

8.反轉比較器

static <T> Comparator<T> reverseOrder()
返回一個比較器，它強行逆轉實現了 Comparable 接口的對象 collection 的自然順序。
static<T> Comparator<T> reverseOrder(Comparator<T>cmp)
返回一個比較器，它強行逆轉指定比較器的順序。

示例代碼：

        //部分代碼
        //新建裝載String對象的TreeSet數組
        TreeSet<String> ts=new TreeSet<String>();
        ts.add("python");
        ts.add("java");
        ts.add("js");
        ts.add("R");
        ts.add("ruby");
        System.out.println("原始集合："+ts);

        //新建傳入逆向自然順序比較器的TreeSet
        TreeSet<String> reTs=new TreeSet<String>(Collections.reverseOrder());
        reTs.add("python");
        reTs.add("java");
        reTs.add("js");
        reTs.add("R");
        reTs.add("ruby");
        System.out.println("傳入逆向比較器的集合："+reTs);

程序運行結果：

原始集合：[R, java, js, python, ruby]
傳入逆向比較器的集合：[ruby, python, js, java, R]

9.隨機置換

即隨機打亂集合的順序：

static void shuffle(List<?> list)
使用默認隨機源對指定列表進行置換。
static void shuffle(List<?> list, Random rnd)
使用指定的隨機源對指定列表進行置換。

示例代碼：

        //部分代碼
        //新建ArrayList集合
        ArrayList<String> al=new ArrayList<String>();
        al.add("python");
        al.add("R");
        al.add("java");
        al.add("js");
        al.add("ruby");

        System.out.println("原始集合："+al);                 
        //對集合進行隨機置換
        Collections.shuffle(al);
        System.out.println("隨機置換後的集合："+al); 
        //再次對集合進行隨機置換
        Collections.shuffle(al);
        System.out.println("再次隨機置換後的集合："+al);

程序運行結果：

原始集合：[python, R, java, js, ruby]
隨機置換後的集合：[ruby, java, js, R, python]
再次隨機置換後的集合：[java, python, ruby, js, R]

10.集合線程安全性

static <T> Collection<T>
synchronizedCollection(Collection<T> c)
返回指定 collection 支持的同步collection(線程安全的)。

static <T> List<T>
synchronizedList(List<T> list)
返回指定List支持的同步List(線程安全的)。

static <K,V> Map<K,V>
synchronizedMap(Map<K,V> m)
返回由指定Map支持的同步Map(線程安全的)。

static <T> Set<T> synchronizedSet(Set<T> s)
返回指定 Set 支持的同步Set(線程安全的)。

說明：將非線程同步的集合對象轉換爲線程同步的集合返回，使得集合的線程安全性問題得到解決。

3.Arrays類

用於操作數組的工具類，裏面全是靜態方法，可以直接調用。

1.相關方法

static <T> List<T> asList(T… a)
返回一個受指定數組支持的固定大小的列表。

二分查找：

static int binarySearch(byte[] a, byte key)
使用二分搜索法來搜索指定的 byte 型數組，以獲得指定的值。
static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key)
使用二分搜索法來搜索指定的 byte 型數組的範圍，以獲得指定的值。
static int binarySearch(char[] a, char key)
使用二分搜索法來搜索指定的 char 型數組，以獲得指定的值。
static int binarySearch(char[] a, int fromIndex, int toIndex, char key)
使用二分搜索法來搜索指定的 char 型數組的範圍，以獲得指定的值。
static int binarySearch(double[] a, double key)
使用二分搜索法來搜索指定的 double 型數組，以獲得指定的值。
static int binarySearch(double[] a, int fromIndex, int toIndex, double key)
使用二分搜索法來搜索指定的 double 型數組的範圍，以獲得指定的值。
static int binarySearch(float[] a, float key)
使用二分搜索法來搜索指定的 float 型數組，以獲得指定的值。
static int binarySearch(float[] a, int fromIndex, int toIndex, float key)
使用二分搜索法來搜索指定的 float 型數組的範圍，以獲得指定的值。
static int binarySearch(int[] a, int key)
使用二分搜索法來搜索指定的 int 型數組，以獲得指定的值。
static int binarySearch(int[] a, int fromIndex, int toIndex, int key)
使用二分搜索法來搜索指定的 int 型數組的範圍，以獲得指定的值。
static int binarySearch(long[] a, int fromIndex, int toIndex, long key)
使用二分搜索法來搜索指定的 long 型數組的範圍，以獲得指定的值。
static int binarySearch(long[] a, long key)
使用二分搜索法來搜索指定的 long 型數組，以獲得指定的值。
static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
使用二分搜索法來搜索指定數組的範圍，以獲得指定對象。
static int binarySearch(Object[] a, Object key)
使用二分搜索法來搜索指定數組，以獲得指定對象。
static int binarySearch(short[] a, int fromIndex, int toIndex, short key)
使用二分搜索法來搜索指定的 short 型數組的範圍，以獲得指定的值。
static int binarySearch(short[] a, short key)
使用二分搜索法來搜索指定的 short 型數組，以獲得指定的值。
static<T> int
binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)
使用二分搜索法來搜索指定數組的範圍，以獲得指定對象。
static <T> int
binarySearch(T[] a, T key, Comparator<? super T> c)
使用二分搜索法來搜索指定數組，以獲得指定對象。

數組複製：

static boolean[] copyOf(boolean[] original, int newLength)
複製指定的數組，截取或用 false 填充（如有必要），以使副本具有指定的長度。
static byte[] copyOf(byte[] original, int newLength)
複製指定的數組，截取或用 0 填充（如有必要），以使副本具有指定的長度。
static char[] copyOf(char[] original, int newLength)
複製指定的數組，截取或用 null 字符填充（如有必要），以使副本具有指定的長度。
static double[] copyOf(double[] original, int newLength)
複製指定的數組，截取或用 0 填充（如有必要），以使副本具有指定的長度。
static float[] copyOf(float[] original, int newLength)
複製指定的數組，截取或用 0 填充（如有必要），以使副本具有指定的長度。
static int[] copyOf(int[] original, int newLength)
複製指定的數組，截取或用 0 填充（如有必要），以使副本具有指定的長度。
static long[] copyOf(long[] original, int newLength)
複製指定的數組，截取或用 0 填充（如有必要），以使副本具有指定的長度。
static short[] copyOf(short[] original, int newLength)
複製指定的數組，截取或用 0 填充（如有必要），以使副本具有指定的長度。
static <T> T[]
copyOf(T[] original, int newLength)
複製指定的數組，截取或用 null 填充（如有必要），以使副本具有指定的長度。
static <T,U> T[]
copyOf(U[] original, int newLength, Class<? extends T[]> newType)
複製指定的數組，截取或用 null 填充（如有必要），以使副本具有指定的長度。

數組範圍複製：

static boolean[] copyOfRange(boolean[] original, int from, int to)
將指定數組的指定範圍複製到一個新數組。
static byte[] copyOfRange(byte[] original, int from, int to)
將指定數組的指定範圍複製到一個新數組。
static char[] copyOfRange(char[] original, int from, int to)
將指定數組的指定範圍複製到一個新數組。
static double[] copyOfRange(double[] original, int from, int to)
將指定數組的指定範圍複製到一個新數組。
static float[] copyOfRange(float[] original, int from, int to)
將指定數組的指定範圍複製到一個新數組。
static int[] copyOfRange(int[] original, int from, int to)
將指定數組的指定範圍複製到一個新數組。
static long[] copyOfRange(long[] original, int from, int to)
將指定數組的指定範圍複製到一個新數組。
static short[] copyOfRange(short[] original, int from, int to)
將指定數組的指定範圍複製到一個新數組。
static<T> T[]
copyOfRange(T[] original, int from, int to)
將指定數組的指定範圍複製到一個新數組。
static<T,U> T[]
copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)
將指定數組的指定範圍複製到一個新數組。

數組比較：

static boolean deepEquals(Object[] a1, Object[] a2)
如果兩個指定數組彼此是深層相等 的，則返回 true。
static int deepHashCode(Object[] a)
基於指定數組的“深層內容”返回哈希碼。
static String deepToString(Object[] a)
返回指定數組“深層內容”的字符串表示形式。
static boolean equals(boolean[] a, boolean[] a2)
如果兩個指定的 boolean 型數組彼此相等，則返回 true。
static boolean equals(byte[] a, byte[] a2)
如果兩個指定的 byte 型數組彼此相等，則返回 true。
static boolean equals(char[] a, char[] a2)
如果兩個指定的 char 型數組彼此相等，則返回 true。
static boolean equals(double[] a, double[] a2)
如果兩個指定的 double 型數組彼此相等，則返回 true。
static boolean equals(float[] a, float[] a2)
如果兩個指定的 float 型數組彼此相等，則返回 true。
static boolean equals(int[] a, int[] a2)
如果兩個指定的 int 型數組彼此相等，則返回 true。
static boolean equals(long[] a, long[] a2)
如果兩個指定的 long 型數組彼此相等，則返回 true。
static boolean equals(Object[] a, Object[] a2)
如果兩個指定的 Objects 數組彼此相等，則返回 true。
static boolean equals(short[] a, short[] a2)
如果兩個指定的 short 型數組彼此相等，則返回 true。

填充數組：

static void fill(boolean[] a, boolean val)
將指定的 boolean 值分配給指定 boolean 型數組的每個元素。
static void fill(boolean[] a, int fromIndex, int toIndex, boolean val)
將指定的 boolean 值分配給指定 boolean 型數組指定範圍中的每個元素。
static void fill(byte[] a, byte val)
將指定的 byte 值分配給指定 byte 節型數組的每個元素。
static void fill(byte[] a, int fromIndex, int toIndex, byte val)
將指定的 byte 值分配給指定 byte 型數組指定範圍中的每個元素。
static void fill(char[] a, char val)
將指定的 char 值分配給指定 char 型數組的每個元素。
static void fill(char[] a, int fromIndex, int toIndex, char val)
將指定的 char 值分配給指定 char 型數組指定範圍中的每個元素。
static void fill(double[] a, double val)
將指定的 double 值分配給指定 double 型數組的每個元素。
static void fill(double[] a, int fromIndex, int toIndex, double val)
將指定的 double 值分配給指定 double 型數組指定範圍中的每個元素。
static void fill(float[] a, float val)
將指定的 float 值分配給指定 float 型數組的每個元素。
static void fill(float[] a, int fromIndex, int toIndex, float val)
將指定的 float 值分配給指定 float 型數組指定範圍中的每個元素。
static void fill(int[] a, int val)
將指定的 int 值分配給指定 int 型數組的每個元素。
static void fill(int[] a, int fromIndex, int toIndex, int val)
將指定的 int 值分配給指定 int 型數組指定範圍中的每個元素。
static void fill(long[] a, int fromIndex, int toIndex, long val)
將指定的 long 值分配給指定 long 型數組指定範圍中的每個元素。
static void fill(long[] a, long val)
將指定的 long 值分配給指定 long 型數組的每個元素。
static void fill(Object[] a, int fromIndex, int toIndex, Object val)
將指定的 Object 引用分配給指定 Object 數組指定範圍中的每個元素。
static void fill(Object[] a, Object val)
將指定的 Object 引用分配給指定 Object 數組的每個元素。
static void fill(short[] a, int fromIndex, int toIndex, short val)
將指定的 short 值分配給指定 short 型數組指定範圍中的每個元素。
static void fill(short[] a, short val)
將指定的 short 值分配給指定 short 型數組的每個元素。

獲取哈希碼：

static int hashCode(boolean[] a)
基於指定數組的內容返回哈希碼。
static int hashCode(byte[] a)
基於指定數組的內容返回哈希碼。
static int hashCode(char[] a)
基於指定數組的內容返回哈希碼。
static int hashCode(double[] a)
基於指定數組的內容返回哈希碼。
static int hashCode(float[] a)
基於指定數組的內容返回哈希碼。
static int hashCode(int[] a)
基於指定數組的內容返回哈希碼。
static int hashCode(long[] a)
基於指定數組的內容返回哈希碼。
static int hashCode(Object[] a)
基於指定數組的內容返回哈希碼。
static int hashCode(short[] a)
基於指定數組的內容返回哈希碼。

數組排序：
static void sort(byte[] a)
對指定的 byte 型數組按數字升序進行排序。
static void sort(byte[] a, int fromIndex, int toIndex)
對指定 byte 型數組的指定範圍按數字升序進行排序。
static void sort(char[] a)
對指定的 char 型數組按數字升序進行排序。
static void sort(char[] a, int fromIndex, int toIndex)
對指定 char 型數組的指定範圍按數字升序進行排序。
static void sort(double[] a)
對指定的 double 型數組按數字升序進行排序。
static void sort(double[] a, int fromIndex, int toIndex)
對指定 double 型數組的指定範圍按數字升序進行排序。
static void sort(float[] a)
對指定的 float 型數組按數字升序進行排序。
static void sort(float[] a, int fromIndex, int toIndex)
對指定 float 型數組的指定範圍按數字升序進行排序。
static void sort(int[] a)
對指定的 int 型數組按數字升序進行排序。
static void sort(int[] a, int fromIndex, int toIndex)
對指定 int 型數組的指定範圍按數字升序進行排序。
static void sort(long[] a)
對指定的 long 型數組按數字升序進行排序。
static void sort(long[] a, int fromIndex, int toIndex)
對指定 long 型數組的指定範圍按數字升序進行排序。
static void sort(Object[] a)
根據元素的自然順序對指定對象數組按升序進行排序。
static void sort(Object[] a, int fromIndex, int toIndex)
根據元素的自然順序對指定對象數組的指定範圍按升序進行排序。
static void sort(short[] a)
對指定的 short 型數組按數字升序進行排序。
static void sort(short[] a, int fromIndex, int toIndex)
對指定 short 型數組的指定範圍按數字升序進行排序。
static <T> void
sort(T[] a, Comparator<? super T> c)
根據指定比較器產生的順序對指定對象數組進行排序。
static <T> void
sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
根據指定比較器產生的順序對指定對象數組的指定範圍進行排序。

數組轉化爲字符串：

static String toString(boolean[] a)
返回指定數組內容的字符串表示形式。
static String toString(byte[] a)
返回指定數組內容的字符串表示形式。
static String toString(char[] a)
返回指定數組內容的字符串表示形式。
static String toString(double[] a)
返回指定數組內容的字符串表示形式。
static String toString(float[] a)
返回指定數組內容的字符串表示形式。
static String toString(int[] a)
返回指定數組內容的字符串表示形式。
static String toString(long[] a)
返回指定數組內容的字符串表示形式。
static String toString(Object[] a)
返回指定數組內容的字符串表示形式。
static String toString(short[] a)
返回指定數組內容的字符串表示形式。

2.數組變爲字符串

static String toString(int[] a)
返回指定數組內容的字符串表示形式。

示例代碼：

        //部分代碼
        int[] numStr={2,15,48,95};
        //通過Arrays中的靜態方法將數組轉化爲字符串
        String strNum=Arrays.toString(numStr);
        System.out.println(numStr);
        System.out.println(strNum);

程序運行結果：

[I@139a55
[2, 15, 48, 95]

說明：以上代碼演示了將int型數組轉化爲String字符串的操作。其他的類型的數組轉化與之類似。

3.數組變爲集合

static <T> List<T> asList(T… a)
返回一個受指定數組支持的固定大小的List。

注意：通過這個方法轉化後的集合不可以使用增刪方法，因爲數組的長度是固定的，獲取到的List也是固定大小的。

這樣做的好處：可以使用操作集合的方法來對數組進行操作，可以避免手動封裝相關操作造成的麻煩。

示例代碼：

        //部分代碼
        String[] strArr={"python","ruby","java","js"};
        //通過Arrays中的靜態方法將數組轉化爲集合
        List<String> strList=Arrays.asList(strArr);
        System.out.println("集合的元素個數爲："+strList.size());
        //通過迭代器對集合中的元素進行取出
        Iterator<String> it=strList.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

程序運行結果：

集合的元素個數爲：4
python
ruby
java
js

特殊情況：

        //部分代碼
        int[] numStr={2,15,48,95};
        List<int[]> numList=Arrays.asList(numStr);
        System.out.println("集合中的元素個數："+numList.size());
        System.out.println(numList);

程序運行結果：

集合中的元素個數：1
[[I@139a55]

說明：如果數組中的元素都是基本數據類型，那麼會將該數組作爲集合中的一個元素存在(如上例中的int數組)。如果數組中的元素都是對象，那麼轉化爲集合時，數組中的元素就直接轉化爲集合中的元素。

如果想要將數組中的基本數據分別作爲一個元素存入List集合中，則需要使用基本數據類型的包裝類。

改進的方法：將基本類型數組改爲其包裝類對象數組

改進後的代碼：

        //部分代碼
        Integer[] numArr={2,15,48,95};//自動裝箱
        List<Integer> numList=Arrays.asList(numArr);
        System.out.println("集合中的元素個數："+numList.size());
        System.out.println(numList);

程序運行結果：

集合中的元素個數：4
[2, 15, 48, 95]

4.集合轉成數組

使用Collection接口中的toArray方法

Object[] toArray()
返回包含此 collection 中所有元素的數組。

<T> T[] toArray(T[] a)
返回包含此 collection 中所有元素的數組；返回數組的運行時類型與指定數組的運行時類型相同。

說明：當指定類型的數組長度小於集合長度時，該方法內部會創建一個新的數組，其長度等於集合的長度；當指定類型的數組長度大於集合長度時，就不會創建新的數組了，而是使用傳遞進來的數組，且對多餘的部分使用null進行填充。因此，建議將傳入的數組長度設置爲集合的長度。

示例代碼：

        //部分代碼
        //新建ArrayList集合
        ArrayList<String> al = new ArrayList<String>();
        al.add("python");
        al.add("R");
        al.add("java");
        al.add("js");
        al.add("ruby");
        System.out.println("原始集合：" + al);               

        //通過List集合的toArray()方法將集合轉化爲數組
        String[] strArr=al.toArray(new String[al.size()]);
        System.out.println(strArr.length);
        //對集合進行循環輸出
        for(int i=0;i<strArr.length;i++)
            System.out.println(strArr[i]);

程序運行結果：

原始集合：[python, R, java, js, ruby]
5
python
R
java
js
ruby

爲什麼要將集合轉化爲數組？
這樣做實際上是爲了限定集合使用者對元素的操作，一般這就代表着不需要或不建議使用者對集合進行增刪操作。

相關閱讀：
菜鳥猿大戰Java之集合框架系列（一）
菜鳥猿大戰Java之集合框架系列（二）
菜鳥猿大戰Java之集合框架系列（三）
菜鳥猿大戰Java之集合框架系列（四）

CodingEnding
發佈了49 篇原創文章 · 獲贊 77 · 訪問量 6萬+
私信 關注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

高併發系統-使用自定義日誌埋點快速排查問題

背景 在高併發的系統中，通常不會打印除參數校驗失敗或捕獲異常之外的日誌，防止對接口的性能產生影響。 那對於請求不符合預期的情況，我們如何快速找到是哪塊邏輯影響的至關重要。 Pfinder提供的鏈路監控，更多的是性能層面的監控，無法滿足

原創 2024-05-21 11:56:04

代理服務器調試技巧：優化Kotlin網絡爬蟲的數據抓取過程

在網絡爬蟲的開發過程中，經常會遇到需要使用代理服務器的情況。代理服務器不僅可以幫助隱藏真實IP地址，還可以繞過網站的訪問限制，提高數據抓取的成功率。然而，在實際應用中，使用代理服務器也會遇到一些問題，如連接超時、IP被封禁等。因此，本文將

原創 2024-05-21 00:07:04

探討篇（一）：服務粒度的藝術 - 簡化架構與避免服務氾濫

一、背景 上週小組有個需求上線牽扯9個應用（小組目前維護了26個服務，由於團隊系統業務屬性特徵基於高可用、高性能原則拆分，有些是合理的，有些不是很合理的），同時上週OpsReview的一個微服務濫用典範案例（Promise服務A調用服務B，

原創 2024-05-20 23:55:39

Java常用的JSON序列化與反序列化工具實踐

JSON簡介： JSON（Java Script Object Notation）是一種輕量級的數據交換格式，通常用於在不同系統之間傳輸數據。它基於 JavaScript 對象語法，但已成爲一種獨立於語言的格式。JSON 數據以鍵值對的形式

原創 2024-05-20 23:55:38

PDManer [元數建模]-v4.9.0 發佈：一款簡單好用的數據庫建模平臺

特別說明 平臺公雲版及企業私雲版已經發布，增加多人團隊協作支持,點擊這裏瞭解 [PDManer元數建模-v4]，歷時五年，持續升級，工匠精神，做一款簡單好用的數據庫建模平臺。 元數建模平臺，使用React+Electron+Java技

原創 2024-05-20 11:36:32

PDManer [元數建模]-v4.7.0 發佈：一款簡單好用的數據庫建模平臺

特別說明 平臺公雲版及企業私雲版已經發布，增加多人團隊協作支持,點擊這裏瞭解 [PDManer元數建模-v4]，歷時五年，持續升級，工匠精神，做一款簡單好用的數據庫建模平臺。 元數建模平臺，使用React+Electron+Java技

原創 2024-05-20 11:36:29

PDManer [元數建模]-v4.9.2 發佈：一款簡單好用的數據庫建模平臺

特別說明 平臺公雲版及企業私雲版已經發布，增加多人團隊協作支持,點擊這裏瞭解 [PDManer元數建模-v4]，歷時五年，持續升級，工匠精神，做一款簡單好用的數據庫建模平臺。 元數建模平臺，使用React+Electron+Java技

原創 2024-05-20 11:36:28

PDManer [元數建模]-v4.8.0 發佈：一款簡單好用的數據庫建模平臺

特別說明 平臺公雲版及企業私雲版已經發布，增加多人團隊協作支持,點擊這裏瞭解 [PDManer元數建模-v4]，歷時五年，持續升級，工匠精神，做一款簡單好用的數據庫建模平臺。 元數建模平臺，使用React+Electron+Java技

原創 2024-05-20 11:36:27

在Java中，如何以編程的方式設置 Excel 單元格樣式

前言 在Java開發中，處理Excel文件是一項常見的任務。在處理Excel文件時，經常需要對單元格進行樣式設置，以滿足特定的需求和美化要求，通過使用Java中的相關庫和API，我們可以輕鬆地操作Excel文件並設置單元格的樣式。 在本文中

原創 2024-05-20 10:46:43

在Java中，如何以編程的方式設置 Excel 單元格樣式

前言 在Java開發中，處理Excel文件是一項常見的任務。在處理Excel文件時，經常需要對單元格進行樣式設置，以滿足特定的需求和美化要求，通過使用Java中的相關庫和API，我們可以輕鬆地操作Excel文件並設置單元格的樣式。 在本文中

原創 2024-05-20 10:46:42

java.util.concurrent包概覽

JDK8下的java.util.concurrent包 1. java.util.concurrent 1.1 併發容器 未完待續 1.2 線程池 常用線程池 ThreadPoolExecutor ForkJoinPool Schedul

原創 2024-05-20 10:27:06

「Java開發指南」如何用MyEclipse搭建GWT 2.1和Spring？（二）

本教程將指導您如何生成一個可運行的Google Web Toolkit (GWT) 2.1和Spring應用程序，該應用程序爲域模型實現了CRUD應用程序模式。在本教程中，您將學習如何： 安裝Google Eclipse插件 爲GWT配置

原創 2024-05-17 12:21:26

Java ThreadPoolShutdown

CountDownLatch 是 Java 中的一個同步工具類，它允許一個或多個線程等待一系列指定操作執行完成。CountDownLatch 的主要方法有兩個：await() 方法等待 countDown 方法被調用指定的次數後繼續執行，c

原創 2024-05-17 02:06:32

通過MVEL表達式和Apache Chain職責鏈模式解耦MQ消息處理節點的實踐應用

導讀 本文主要講解了MVEL表達式和責任鏈設計模式相結合一起的消息處理解決方案設計、解耦消息處理節點以及方便代碼維護擴展。通過“訂單拆單消息”的接入作爲具體實踐案例，簡要闡述了MVEL表達式和Apache Chain職責鏈設計模式應用場景。

原創 2024-05-16 23:56:24

Spring @EnableXxx註解的使用理解

@EnableXxx註解 Spring有很多@EnableXxx這種形式的註解，類似於可以一鍵打開某項功能，相當於暴露給用戶的一種便捷的配置API，例如 @EnableAsync 激活異步執行能力，@EnableTransactionMan

原創 2024-05-16 23:48:06