java基础之 Collection 接口和 Collections工具类的区别

Collection接口

Collection 的介绍

E - 此集合中元素的类型
Collection 是集合的顶级父类接口，他有很多的实现类, 具体实现类可以参考以下的图片

Collection 的一些常用的方法

boolean add(E e) 
确保此集合包含指定的元素（可选操作）。  

boolean addAll(Collection<? extends E> c) 
将指定集合中的所有元素添加到此集合（可选操作）。  

void clear() 
从此集合中删除所有元素（可选操作）。  

boolean contains(Object o) 
如果此集合包含指定的元素，则返回 true 。  

boolean containsAll(Collection<?> c) 
如果此集合包含指定 集合中的所有元素，则返回true。 

boolean isEmpty() 
如果此集合不包含元素，则返回 true 。  

Iterator<E> iterator() 
返回此集合中的元素的迭代器。  

boolean remove(Object o) 
从该集合中删除指定元素的单个实例（如果存在）（可选操作）。  

boolean removeAll(Collection<?> c) 
删除指定集合中包含的所有此集合的元素（可选操作）。  

int size() 
返回此集合中的元素数。  

Object[] toArray() 
返回一个包含此集合中所有元素的数组。  

<T> T[] toArray(T[] a) 
返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。  

方法的具体的使用方法可以参考 java基础之集合

Collections 工具类

Collections的介绍

此类仅由静态方法组合或返回集合。 它包含对集合进行操作的多态算法，“包装器”，返回由指定集合支持的新集合，以及其他一些可能的和最终的。
如果提供给它们的集合或类对象为null，则此类的方法都抛出一个NullPointerException 。

Collections 的一些常用的方法

static <T> boolean addAll(Collection<? super T> c, T... elements) 
将所有指定的元素添加到指定的集合。

static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) 
使用二叉搜索算法搜索指定对象的指定列表。  


static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 
使用二叉搜索算法搜索指定对象的指定列表。  
  
static <T> void copy(List<? super T> dest, List<? extends T> src) 
将所有元素从一个列表复制到另一个列表中。   

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

static <T> ArrayList<T> list(Enumeration<T> e) 
返回一个数组列表，其中包含由枚举返回的顺序由指定的枚举返回的元素。   

static <T extends Object & Comparable<? super T>>
T max(Collection<? extends T> coll) 
根据其元素的 自然顺序返回给定集合的最大元素。  

static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) 
根据指定的比较器引发的顺序返回给定集合的最大元素。  

static <T extends Object & Comparable<? super T>>
T min(Collection<? extends T> coll) 
根据其元素的 自然顺序返回给定集合的最小元素。  

static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp) 
根据指定的比较器引发的顺序返回给定集合的最小元素。  

static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 
将列表中一个指定值的所有出现替换为另一个。  

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

static <T> Comparator<T> reverseOrder() 
返回一个比较器，它对实现 Comparable接口的对象集合施加了 自然排序的相反。  

static <T> Comparator<T> reverseOrder(Comparator<T> cmp) 
返回一个比较器，它强制指定比较器的反向排序。  
 
 static <T extends Comparable<? super T>>
void sort(List<T> list) 
根据其元素的natural ordering对指定的列表进行排序。  

static <T> void sort(List<T> list, Comparator<? super T> c) 
根据指定的比较器引起的顺序对指定的列表进行排序。  

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

以上方法涉及到排序的可以参考
java基础之Compareable和Comparator的区别和使用

具体方法的使用说明

public class CollectionsDemo {
	public static void main(String[] args) {
		//定义一个ArrayList()数组
		ArrayList<Integer> arrayList = new ArrayList<>();
		
		//定义一个set集合
		ArrayList<String> arrayList1 = new ArrayList<>();
		arrayList1.add("哼哼");
		arrayList1.add("小哈");
		arrayList1.add("小黑");
		arrayList1.add("小哼");
		arrayList1.add("武松");
		arrayList1.add("哼哼的博客");
		
		//利用Collections中的方法对以上集合进行操作
		
		//添加元素
		
		Collections.addAll(arrayList, 10,11,12);
		System.out.println(arrayList);
		//利用二叉树搜索元素(获得是元素的索引值)
		int value  = Collections.binarySearch(arrayList, 11);
		System.out.println("元素的索引值是："+value);
		
		//copy() 方法的使用,在下一篇博客中深入的说明一下，
		//第一个参数是目的集合，第二个参数是源集合，一定要声明目的集合的大小，并且容量大小等于或者大于源集合的容量大小，否则会报错（java.lang.IndexOutOfBoundsException）
		 ArrayList<Integer> arrayList2 = new ArrayList<>(Arrays.asList(new Integer[arrayList.size()]));
		 Collections.copy(arrayList2, arrayList);
		 System.out.println(arrayList2);
		 
		 //返回集合的最大值
		 int maxValue = Collections.max(arrayList);
		 System.out.println("集合的最大值是"+maxValue);
		 
		 //返回集合的最小值
		  int minValue = Collections.min(arrayList);
		  System.out.println("集合的最小值是"+minValue);
		 
		//替换指定的值
		  System.out.println("原来集合中的元素是"+arrayList);
		  Collections.replaceAll(arrayList, 12, 25);
		  System.out.println("替换后的集合中的元素是："+ arrayList);
		   // 反转集合中的元素
		  Collections.reverse(arrayList);
		  System.out.println("反转后集合元素是" + arrayList);
		  
		  //集合元素的比较
		  Collections.sort(arrayList1);
		  //这里是因为String 中实现了Comparable接口，可以自己定义一个类，然后重写Comparable接口，然后实现排序
		  //调用第二个sort（）方法。这里不做演示了，在Comparable接口的使用的博客中有详细的说明。
		  System.out.println(arrayList1);
		  
		  // 交换两个元素的位置
		   
		  System.out.println("没有交换之前集合中元素"+arrayList);
		  //这里的参数是元素的索引值，不是元素的值
		  Collections.swap(arrayList, 0, 2);
		  System.out.println("交换后的集合元素"+arrayList);
	}
}

输出结果是

[10, 11, 12]
元素的索引值是：1
复制之后的arrayList2集合中的元素是[10, 11, 12]
集合的最大值是12
集合的最小值是10
原来集合中的元素是[10, 11, 12]
替换后的集合中的元素是：[10, 11, 25]
反转后集合元素是[25, 11, 10]
[哼哼, 哼哼的博客, 小哈, 小哼, 小黑, 武松]
没有交换之前集合中元素[25, 11, 10]
交换后的集合元素[10, 11, 25]

Collections.copy()方法的详细介绍