JAVA--集合和数组工具类(Collections、Arrays)
Collections
Collections类里面都是静态方法。
集合框架的工具类Collections常用方法
static
根据元素的自然顺序 对指定列表按升序进行排序。
static
根据指定比较器产生的顺序对指定列表进行排序。
static
根据元素的自然顺序，返回给定 collection集合的最大元素。
static
根据指定比较器产生的顺序，返回给定 collection集合的最大元素。
static
使用二分搜索法搜索指定列表，以获得指定对象。如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)
static
使用二分搜索法搜索指定列表，以获得指定对象。如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)
static
使用指定元素替换指定列表中的所有元素。
static
使用另一个值替换列表中出现的所有某一指定值。
static void reverse(List list)
反转指定列表中元素的顺序。
static
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
static
返回一个比较器，它强行逆转指定比较器的顺序。
static
返回指定列表支持的同步（线程安全的）列表。
static
返回指定 set 支持的同步（线程安全的）set。
static
返回由指定映射支持的同步（线程安全的）映射。
static void swap(List list, int i, int j)
在指定列表的指定位置处交换元素。
static void shuffle(List list)
使用默认随机源对指定列表进行置换。
static void shuffle(List list, Random rnd)
使用指定的随机源对指定列表进行置换。
案例
import java.util.*;
/*
集合框架的工具类
Collections: 里面都是静态方法。
static > void sort(List list)
根据元素的自然顺序 对指定列表按升序进行排序。
static void sort(List list, Comparator c)
根据指定比较器产生的顺序对指定列表进行排序。
static > T max(Collection coll)
根据元素的自然顺序，返回给定 collection集合的最大元素。
static T max(Collection coll, Comparator comp)
根据指定比较器产生的顺序，返回给定 collection集合的最大元素。
static int binarySearch(List> list, T key)
使用二分搜索法搜索指定列表，以获得指定对象。如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)
static int binarySearch(List list, T key, Comparator c)
使用二分搜索法搜索指定列表，以获得指定对象。如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)
static void fill(List list, T obj)
使用指定元素替换指定列表中的所有元素。
static boolean replaceAll(List list, T oldVal, T newVal)
使用另一个值替换列表中出现的所有某一指定值。
static void reverse(List list)
反转指定列表中元素的顺序。
static Comparator reverseOrder()
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
static Comparator reverseOrder(Comparator cmp)
返回一个比较器，它强行逆转指定比较器的顺序。
static List synchronizedList(List list)
返回指定列表支持的同步（线程安全的）列表。
static Set synchronizedSet(Set s)
返回指定 set 支持的同步（线程安全的）set。
static Map synchronizedMap(Map m)
返回由指定映射支持的同步（线程安全的）映射。
static void swap(List list, int i, int j)
在指定列表的指定位置处交换元素。
static void shuffle(List list)
使用默认随机源对指定列表进行置换。
static void shuffle(List list, Random rnd)
使用指定的随机源对指定列表进行置换。
*/
class CollectionsDemo{
public static void main(String[] args){
replaceAllDemo();
}
// 将集合中元素替换、反转和交换以及随机位置置换
public static void replaceAllDemo(){
List list=new ArrayList();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
sop(list);
Collections.replaceAll(list,"aaa","pp");
sop(list);
Collections.reverse(list);
sop(list);
Collections.swap(list,1,3);
sop(list);
Collections.shuffle(list);
sop(list);
}
// 将集合中的所有元素替换成指定元素
public static void fillDemo(){
List list=new ArrayList();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
sop(list);
Collections.fill(list,"ppp");
sop(list);
}
// 采用二分法搜索指定对象,前提要保证数据集合已经实现了升序排列
public static void binarySearchDemo(){
List list=new ArrayList();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
// 默认自然顺序
Collections.sort(list);
sop(list);
int index=Collections.binarySearch(list,"aaa"); // 找不到该元素返回 (-(插入点) - 1)
int index1=halfSearch(list,"cc"); // 仿写Collections类binarySearch方法
sop("index="+index);
sop("index1="+index1);
// 自定义长度顺序
Collections.sort(list,new StrLenComparator());
sop(list);
int index2=Collections.binarySearch(list,"aaa",new StrLenComparator()); // 找不到该元素返回 (-(插入点) - 1)
int index3=halfSearch2(list,"aaaa",new StrLenComparator()); // 仿写Collections类binarySearch方法
sop("index2="+index2);
sop("index3="+index3);
}
// 仿写三个参数binarySearch方法，自定义顺序
public static int halfSearch2(List list,String key,Comparator cmp){
int max,min,mid;
max=list.size()-1;
min=0;
while(min<=max){
mid = (max+min)>>1; // => /2(除2)
String str=list.get(mid);
int num=cmp.compare(str,key);
if(num>0)
max=mid-1;
else if(num<0)
min=mid+1;
else
return mid;
}
return -min-1;
}
// 仿写两个参数binarySearch方法,默认自然顺序
public static int halfSearch(List list,String key){
int max,min,mid;
max=list.size()-1;
min=0;
while(min<=max){
mid = (max+min)>>1; // => /2(除2)
String str=list.get(mid);
int num=str.compareTo(key);
if(num>0)
max=mid-1;
else if(num<0)
min=mid+1;
else
return mid;
}
return -min-1;
}
// 获取集合元素默认/自定义排序的最大值
public static void maxDemo(){
List list=new ArrayList();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
sop(list);
String max=Collections.max(list); // 默认排序
sop(max);
String max2=Collections.max(list,new StrLenComparator()); // 自定义比较器排序
sop(max2);
}
// 对集合元素默认/自定义排序
public static void sortDemo(){
List list=new ArrayList();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
sop(list);
Collections.sort(list); // 默认排序
sop(list);
Collections.sort(list,new StrLenComparator()); // 自定义比较器排序
sop(list);
}
// 打印语句
public static void sop(Object obj){
System.out.println(obj);
}
}
// 字符串长度比较器
class StrLenComparator implements Comparator{
public int compare(String s1,String s2){
if(s1.length()>s2.length())
return 1;
if(s1.length() Arrays
Arrays类里面都是静态方法。
把数组变成List集合有什么好处：
可以使用集合的思想和方法来操作数组中的元素。
如：get()、contains()、indexOf()、subList();
注意：
将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。
如果增删，那么会发生UnsupportedOperationException(不支持操作异常)
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素。
操作数组工具类Arrays常用方法
static
返回一个受指定数组支持的固定大小的列表，将数组变成List集合。
static String toString(int[] a)
返回指定数组(各种数据类型数组)内容的字符串表示形式。
static void sort(Object[] a)
根据元素的自然顺序对指定对象数组按升序进行排序。
static void sort(Object[] a, int fromIndex, int toIndex)
根据元素的自然顺序对指定对象数组的指定范围按升序进行排序。
static int hashCode(Object[] a)
基于指定数组的内容返回哈希码。
static void fill(Object[] a, int fromIndex, int toIndex, Object val)
将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。
static void fill(Object[] a, Object val)
将指定的 Object 引用分配给指定 Object 数组的每个元素。
static boolean equals(Object[] a, Object[] a2)
如果两个指定的 Objects 数组彼此相等，则返回 true。
static
将指定数组的指定范围复制到一个新数组。
static
复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。
static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
使用二分搜索法来搜索指定数组的范围，以获得指定对象。
static int binarySearch(Object[] a, Object key)
使用二分搜索法来搜索指定数组，以获得指定对象。
案例
import java.util.*;
/*
操作数组的工具类
Arrays：里面都是静态方法。
static String toString(int[] a)
返回指定数组(各种数据类型数组)内容的字符串表示形式。
static List asList(T... a)
返回一个受指定数组支持的固定大小的列表，将数组变成List集合。
static void sort(Object[] a)
根据元素的自然顺序对指定对象数组按升序进行排序。
static void sort(Object[] a, int fromIndex, int toIndex)
根据元素的自然顺序对指定对象数组的指定范围按升序进行排序。
static int hashCode(Object[] a)
基于指定数组的内容返回哈希码。
static void fill(Object[] a, int fromIndex, int toIndex, Object val)
将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。
static void fill(Object[] a, Object val)
将指定的 Object 引用分配给指定 Object 数组的每个元素。
static boolean equals(Object[] a, Object[] a2)
如果两个指定的 Objects 数组彼此相等，则返回 true。
static T[] copyOfRange(T[] original, int from, int to)
将指定数组的指定范围复制到一个新数组。
static T[] copyOf(T[] original, int newLength)
复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。
static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
使用二分搜索法来搜索指定数组的范围，以获得指定对象。
static int binarySearch(Object[] a, Object key)
使用二分搜索法来搜索指定数组，以获得指定对象。
*/
class ArraysDemo{
public static void main(String[] args){
int[] arr={2,4,5};
sop(Arrays.toString(arr));
/*把数组变成List集合有什么好处：
可以使用集合的思想和方法来操作数组中的元素。
如：get()、contains()、indexOf()、subList();
注意：将数组变成集合，不可以使用集合的增删方法，
因为数组的长度是固定的。
如果增删，那么会发生UnsupportedOperationException(不支持操作异常)
*/
String[] as={"abc","cc"," kkkk"};
List list=Arrays.asList(as);
sop(list);
/*
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素。
*/
}
// 打印方法
public static void sop(Object obj){
System.out.println(obj);
}
}
集合变数组
Collection接口中的toArray()方法。
注意：
1.指定类型的数组到底要定义多长：
当指定类型的数组长度小于集合的size,该方法内部会创建一个新的数组，长度为集合的size。
当指定类型的数组长度大于集合的size,就不会新创建数组，而是使用传递进来的数组,空的位置用null填充。
所以创建一个刚刚好长度的数组最优，即数组长度等于集合长度。
2.为什么要将集合变数组：
为了限定对元素的操作，不需要进行增删。
案例
import java.util.*;
/*
集合变数组：
Collection接口中的toArray()方法。
*/
class CollectionToArray{
public static void main(String[] args){
ArrayList al=new ArrayList();
al.add("abc1");
al.add("abc2");
al.add("abc3");
/*
1.指定类型的数组到底要定义多长：
当指定类型的数组长度小于集合的size,该方法内部会创建一个新的数组，长度为集合的size。
当指定类型的数组长度大于集合的size,就不会新创建数组，而是使用传递进来的数组,空的位置用null填充。
所以创建一个刚刚好的数组最优,即数组长度等于集合长度。
2.为什么要将集合变数组：
为了限定对元素的操作，不需要进行增删。
*/
// String[] arr=al.toArray(new String[5]);
String[] arr=al.toArray(new String[al.size()]);
System.out.println(Arrays.toString(arr));
}
}
取出集合元素的三种方式
1.使用高级for
格式：for(数据类型 变量名 : 被遍历的集合(Collection)或者数组){}
2.使用迭代器Iterator
3.使用集合get()方法[使用范围仅限List集合]
注意：
1.高级for对集合进行遍历：
只能获取集合元素，但是不能对集合进行操作。
2.迭代器除了遍历，还可以进行remove集合中元素的动作。
如果是用ListIterator，还可以在遍历过程中对集合进行增(add)删(remove)改(set)查(hasNext/next)的动作。
3.传统for和高级for区别：
高级for有一个局限性，必须要有被遍历的目标。
建议在遍历数组的时候，还是要用传统for，因为传统for可以定义角标（索引）。
import java.util.*;
/*
以ArrayList集合为例，展示获取集合元素的三种取出方式
1.使用高级for
格式：for(数据类型 变量名 : 被遍历的集合(Collection)或者数组){}
2.使用迭代器Iterator
3.使用集合get()方法[使用范围仅限List集合]
*/
class GetCollectionElements{
public static void main(String[] args){
ArrayList a1=new ArrayList();
a1.add("java01");
a1.add("java02");
a1.add("java03");
a1.add("java04");
a1.add("java05");
// 使用高级for
System.out.println("使用高级for获取集合元素");
for(String s:a1){
System.out.println(s);
}
// 使用迭代器Iterator
System.out.println("使用迭代器获取集合元素");
Iterator it=a1.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
/*
// 使用迭代器Iterator2
System.out.println("使用迭代器2获取集合元素");
for(Iterator it1=a1.iterator();it1.hasNext();){
System.out.println(it1.next());
}*/
// 使用get()方法
System.out.println("使用get()获取集合元素");
for(int i=0;i