​
​

活动地址：CSDN21天学习挑战赛

文章目录

• 集合.Collection接口详解
• • 一、常用方法
  • 二、深入remove方法
  • 三、Collection与Collections的比较

集合.Collection接口详解

一、常用方法

• boolean add(E e)
  确保此集合包含指定的元素（可选操作）。
• int size()
  返回此集合中的元素数。
• void clear()
  从此集合中删除所有元素（可选操作）。
• Object[ ] toArray()
  返回一个包含此集合中所有元素的数组。
• boolean isEmpty()
  如果此集合不包含元素，则返回 true 。

import java.util.ArrayList;
import java.util.Collection;
class Customer{
	
	String name;
	int age;
	
	Customer(String name,int age){
		this.age = age;
		this.name = name;
	}
	public String toString(){
		return "Customer[name="+name+"age="+age+"]";
	}
}
 
public class CollectionTest01 {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//1.创建集合
		//Collection c = new Collection();  写法错误，接口不能new，需借助实现类
		Collection c = new ArrayList(); //利用多态
 
		//2.添加元素
		c.add(1); //自动装箱
		c.add(new Integer(100));
		Object o = new Object();
		c.add(o); //Collection集合只能单个存储元素
		
		Customer cust = new Customer("张三",20);
		c.add(cust);
		
		//3.将集合转换成Object类型数组
		Object[] objs = c.toArray();
		//遍历该数组
		for(int i=0;i
			System.out.println(objs[i]);
		}
		
		//4.获取元素的个数
		System.out.println(c.size()); //4
		System.out.println(c.isEmpty()); //false
		
		//5.清空元素
		c.clear();
		System.out.println(c.size()); //0
		System.out.println(c.isEmpty()); //true
	}
}

• Iterator iterator()
  返回此集合中的元素的迭代器。
  通过迭代器中方法完成集合的迭代（遍历）。

在之前的这张图中左上角部分描述过迭代器

注意：这种方式是所有的集合通用的便利方式。

import java.util.*;
public class CollectionTest02 {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
 
		//创建集合对象
		Collection c = new LinkedList();
		
		//添加元素
		c.add(10);
		c.add(3.14);
		c.add(true);
		
		//迭代
		//1.获取迭代对象
		Iterator it = c.iterator();
		System.out.println(it); //java.util.AbstractList$Itr是ArrayList集合所依赖的迭代器
		                        //java.util.LinkedList$ListItr是LinkedList集合所依赖的迭代器
		                        //Itr 、ListItr是内部类
		//迭代器是面向接口编程，it是引用，保存了内存地址，指向堆中的"迭代器对象"
		
		//2.遍历集合调用Collection内部方法
		while(it.hasNext()){
			Object element = it.next();
			System.out.println(element);
		}
		/*
		boolean b = it.hasNext(); 判断是否有更多的元素
		Object element = it.next(); 将迭代器下移一位，并且取出指向的元素
		原则：it.next()之前必须先调用it.hasNext()方法，防止出现空指针异常
		*/
		
		/*for(Iterator it1 = c.iterator();it.hasNext();){
			Object element1 = it.next();
			System.out.println(element1);
		}
		*/
	}
}
 

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

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

• 存储在集合中的元素应该去重写equals方法

import java.util.*;
public class CollectionTest03 {
 
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//创建集合
		Collection c = new ArrayList();
 
		//创建Integer类型的对象
		Integer i1 = new Integer(10);
		
		//添加对象
		c.add(i1);
		
		//判断集合中是否包含对象i1
		System.out.println(c.contains(i1)); //true
		
		//再创建一个Integer对象
		Integer i2 = new Integer(10);
		
		//删除
		c.remove(i2);
		System.out.println(c.size()); //0
	
		//判断集合中是否包含对象i2
		System.out.println(c.contains(i2)); //true
		//这就涉及到之前学的整型常量池，所以i1就是i2
		//并且contains方法底层调用的是equals方法
		
		//创建Manager对象
		Manager m1 = new Manager(100,"张三");
		
		//添加对象
		c.add(m1);
		
		//判断集合中是否存在对象m1
		System.out.println(c.contains(m1)); //true
		
		//再添加一个Manager对象
		Manager m2 = new Manager(100,"张三");
		
		//判断集合中是否存在对象m2
		System.out.println(c.contains(m2)); 
		
		//删除
		c.remove(m2);
		System.out.println(c.size()); //0
		
		//重写equals方法之前  
		//System.out.println(c.contains(m2)); false
		
		//重写equals方法之后  
	    //System.out.println(c.contains(m2)); true
		
	}
}
class Manager{
	
	int no;
	String name;
	
	Manager(int no,String name){
		this.no = no;
		this.name = name;
	}
	
	//重写equals方法
	public boolean equals(Object o){
		
		if(this==o) return true;
		if(o instanceof Manager){
			Manager m = (Manager)o;
			if(m.no==this.no && m.name.equals(this.name)){
				return true;
			}
		}
		return false;
	}
}

返回顶部

二、深入remove方法

1.迭代器的remove方法
2.集合本身的remove方法  

Java集合排序及java集合类详解(Collection、List、Map、Set)

doc 5星 超过95%的资源 446KB

下载

import java.util.*;
public class CollectionTest04 {
 
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//创建一个集合
		Collection c = new ArrayList();
		
		//添加元素
		c.add(1);
		c.add(2);
		c.add(3);
		
		//获取迭代器遍历
        Iterator it = c.iterator();
        while(it.hasNext()){
        	//推荐使用迭代器自身的remove方法
        	it.next();
        	//删除
        	it.remove();
        	
        	/*
             //使用集合本身的remove方法删除
             Object element = it.next();
             
             //删除
             c.remove(element);
             
             这种方式需要在每一次删除后重新获取新的迭代器
             */
        }
        System.out.println(c.size()); //0
	}
}

返回顶部

三、Collection与Collections的比较

java.util.Collections; 集合工具类
java.util.Collection; 集合接口

1.Collections 是集合工具类，用来对集合进行操作。部分方法如下

-public static  boolean addAll(Collectionc,T...elements)//往集合中添加一些元素
-public static void shuffle(List list) //打乱集合顺序
-public static  void sort(List list) //对集合进行排序，默认为升序

注意：

• sort使用前提：被排序的集合里边存储的元素，必须实现Comparable，重写接口中的方法compareTo定义排序的规则
• sort使用范围
  
  适用于List，若为其他类型，需要将其强制类型转换

2.Comparable接口的排序规则：

// 自己(this)-参数:升序
public static <T>void sort(List<T> list, Comparatorsuper T>):
//将集合中元素按照指定规则排序

3.Comparator和Comparable的区别

Comparable:自己(this)和别人(参数)比较，自己需要实现Comparable接口，重写比较的规则compareTo方法
Comparator:相当于找一个第三方的裁判，比较两个
Comparator定义排序规则： o1-o2 升序，反之降序

import java.util.*;
public class CollectionsTest01 {
 
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
 
		//使用Collections工具完成集合的排序
		List l = new ArrayList();
		
		//添加元素
		l.add(10);
		l.add(60);
		l.add(20);
		l.add(40);
		l.add(30);
		
		//遍历
		for(int i = 0; i < l.size(); i++){
			System.out.println(l.get(i));
		}
		System.out.println("=================");
		
		//完成集合的排序
		Collections.sort(l);
		
		//遍历
		for (int i = 0; i < l.size(); i++) {
			System.out.println(l.get(i));
		}
		System.out.println("=================");
		
		//给定一个set集合
		Set s = new HashSet();
		
		//添加元素
		s.add(15);
		s.add(35);
		s.add(55);
		s.add(25);
		s.add(45);
		
		/*
		Collections.sort(s);
		Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The method sort(List) in the type Collections is not applicable for the arguments (Set)
		*/
		
		//进行强制类型转换
		List lists = new ArrayList(s);
		Collections.sort(lists);
		
		//遍历
		Iterator it = lists.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
		System.out.println("=================");
		
		//将ArrayList集合转化成线程安全的
		List mylist = new ArrayList();
		Collections.synchronizedList(mylist);
	}
 
}

返回顶部