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

关注

原创最新推荐文章于 2026-05-07 09:14:06 发布 757 阅读 AI 写同款· GEO 优化 ›

Java集合框架是什么？说出一些集合框架的优点？干货太重，且文字比较多。需要花费时间与耐心细细咀嚼，但是真的能收获到很多。每种编程语言中都有集合，最初的Java版本包含几种集合类：Vector、Stack、HashTable和Array。随着集合的广泛使用，Java1.2提出了囊括所有集合接口、实现和算法的集合框架。在保证线程安全的情况下使用泛型和并发集合类，Java已经经历了很久。它还包括在Java并发包中，阻塞接口以及它们的实现。 1... 阅读详情

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]);