JAVA--集合和数组工具类(Collections、Arrays)

最新推荐文章于 2022-07-13 23:00:00 发布

新一coding

最新推荐文章于 2022-07-13 23:00:00 发布

阅读量369

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/Xin6Yang/article/details/93619035

版权

JAVA 专栏收录该内容

114 篇文章 1 订阅

订阅专栏

Collections

Collections类里面都是静态方法。

集合框架的工具类Collections常用方法

static <T extends Comparable<? super T>> void sort(List<T> list)

根据元素的自然顺序对指定列表按升序进行排序。

static <T> void sort(List<T> list, Comparator<? super T> c)

根据指定比较器产生的顺序对指定列表进行排序。

static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)

根据元素的自然顺序，返回给定 collection集合的最大元素。

static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)

根据指定比较器产生的顺序，返回给定 collection集合的最大元素。

static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)

使用二分搜索法搜索指定列表，以获得指定对象。如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)

static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)

使用二分搜索法搜索指定列表，以获得指定对象。如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)

static <T> void fill(List<? super T> list, T obj)

使用指定元素替换指定列表中的所有元素。

static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)

使用另一个值替换列表中出现的所有某一指定值。

static void reverse(List<?> list)

反转指定列表中元素的顺序。

static <T> Comparator<T> reverseOrder()

返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

static <T> Comparator<T> reverseOrder(Comparator<T> cmp)

返回一个比较器，它强行逆转指定比较器的顺序。

static <T> List<T> synchronizedList(List<T> list)

返回指定列表支持的同步（线程安全的）列表。

static <T> Set<T> synchronizedSet(Set<T> s)

返回指定 set 支持的同步（线程安全的）set。

static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)

返回由指定映射支持的同步（线程安全的）映射。

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 <T extends Comparable<? super T>> void sort(List<T> list)
	根据元素的自然顺序 对指定列表按升序进行排序。 		  
static <T> void sort(List<T> list, Comparator<? super T> c)
	根据指定比较器产生的顺序对指定列表进行排序。 

static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
	根据元素的自然顺序，返回给定 collection集合的最大元素。 
static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
	根据指定比较器产生的顺序，返回给定 collection集合的最大元素。 

static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
	使用二分搜索法搜索指定列表，以获得指定对象。如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1) 
static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 
    使用二分搜索法搜索指定列表，以获得指定对象。如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1) 
	
static <T> void fill(List<? super T> list, T obj) 
    使用指定元素替换指定列表中的所有元素。 
	
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 
    使用另一个值替换列表中出现的所有某一指定值。 
static void reverse(List<?> list) 
    反转指定列表中元素的顺序。 

static <T> Comparator<T> reverseOrder() 
    返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。 
static <T> Comparator<T> reverseOrder(Comparator<T> cmp) 
    返回一个比较器，它强行逆转指定比较器的顺序。 

static <T> List<T> synchronizedList(List<T> list) 
    返回指定列表支持的同步（线程安全的）列表。
static <T> Set<T> synchronizedSet(Set<T> s) 
    返回指定 set 支持的同步（线程安全的）set。 
static <K,V> Map<K,V> synchronizedMap(Map<K,V> 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<String> list=new ArrayList<String>();
		
		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<String> list=new ArrayList<String>();
		
		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<String> list=new ArrayList<String>();
		
		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<String> list,String key,Comparator<String> 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<String> 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<String> list=new ArrayList<String>();
		
		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<String> list=new ArrayList<String>();
		
		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<String>{
	public int compare(String s1,String s2){
		if(s1.length()>s2.length())
			return 1;
		if(s1.length()<s2.length())
			return -1;
		
		return s1.compareTo(s2);
	}
}

Arrays

Arrays类里面都是静态方法。

把数组变成List集合有什么好处：

可以使用集合的思想和方法来操作数组中的元素。

如：get()、contains()、indexOf()、subList();

注意：

将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。

如果增删，那么会发生UnsupportedOperationException(不支持操作异常)

如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。

如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素。

操作数组工具类Arrays常用方法

static <T> List<T> asList(T... a)

返回一个受指定数组支持的固定大小的列表，将数组变成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 <T> T[] copyOfRange(T[] original, int from, int to)

将指定数组的指定范围复制到一个新数组。

static <T> 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)

使用二分搜索法来搜索指定数组，以获得指定对象。

案例

import java.util.*;
/*
操作数组的工具类
Arrays：里面都是静态方法。

static String toString(int[] a) 
    返回指定数组(各种数据类型数组)内容的字符串表示形式。
	
static <T> List<T> 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> T[] copyOfRange(T[] original, int from, int to) 
    将指定数组的指定范围复制到一个新数组。 

static <T> 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<String> 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<String> al=new ArrayList<String>();
		
		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<String> a1=new ArrayList<String>();
		
		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<String> it=a1.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
		/*
		// 使用迭代器Iterator2
		System.out.println("使用迭代器2获取集合元素");
		for(Iterator<String> it1=a1.iterator();it1.hasNext();){
			System.out.println(it1.next());
		}*/
        
		// 使用get()方法
		System.out.println("使用get()获取集合元素");
		for(int i=0;i<a1.size();i++){
			System.out.println(a1.get(i));
		}
	}
}

新一coding

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA--集合和数组工具类(Collections、Arrays)

CollectionsCollections类里面都是静态方法。集合框架的工具类Collections常用方法static <T extends Comparable<? super T>> void sort(List<T> list) 根据元素的自然顺序对指定列表按升序进行排序。 static &l...
复制链接

扫一扫