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之集合框架系列(四)