集合备忘【JAVA】

0、集合常用接口与类关系图示：

 1、Collection
 1.1 方法
 (1)Iterator<E> iterator():返回一个迭代器，用来迭代集合中的元素
 (2)int size():返回存放在集合中的元素的数量
 (3)boolean isEmpty():判断当前集合是否为空，为空则返回true
 (4)boolean contains(Object obj):判断当前集合中是否包含一个与obj相等的对象，相等返回true
 (5)boolean contains(Collection col):判断当前集合是否包含一个与col相等的集合，相等则返回true
 (6)boolean add(Object obj)：向集合中添加元素obj，成功返回true
 (7)boolean addAll(Collection col):将集合col中的所有元素添加到该集合中，成功返回true
 (8)boolean remove(Object obj):移除集合中与obj相等的对象，有并且成功移除返回true
 (9)boolean removeAll(Collection col):移除该集合中与集合col相等的所有元素，有并且成功移除返回true
 (10)void clear():移除集合中的所有元素
 (11)boolean retainAll(Collection col):集合中不与集合col相等的所有元素，有并且成功移除返回true
 (12)Object toArray():返回集合中的对象数组
 2、Iterator
 2.1 方法
 (1)boolean hasNext():如果存在下一个元素，则返回true
 (2)E next():返回下一个元素
 (3)void remove():移除上次被访问的对象，这个方法必须紧跟在访问一个元素之后执行。
 3、List
 3.0 (1)有序列表，允许存放重复的元素
 3.0.1 List方法
 (1)继承Collection所有方法
 (2)ListIterator listIterator():返回一个列表迭代器，以迭代列表中的所有元素
 (3)ListIterator listIterator(int index):返回一个列表迭代器，从指定的下标开始
 (4)void add(int index,E element):在指定的位置添加一个元素
 (5)void addAll([int index,]Collection<? extends E> elements):在[末尾]指定的位置添加一个元素集合
 (6)E remove(int index):移除执行位置上的元素并返回
 (7)E set(int index,E element):以新的元素取代指定位置上的元素并返回旧元素
 (8)int indexOf(Object obj):返回与obj相等的第一个元素的下标，如果没有匹配的返回-1
 (9)int lastIndexOf(Object obj):返回与obj相等的最后一个元素的下标，如果没有匹配的返回-1
 3.0.2 ListIterator 方法
 (1)void add(E obj):将obj插入添加到当前位置之前
 (2)void set(E obj):将obj替换next或previous方法访问到的那个元素，如果列表在上次调用next或previous时修改了结构，则会报异常。
 (3)boolean hasNext():以正向遍历列表时，如果列表迭代器有多个元素，则返回 true
 (4)boolean hasPrevious():如果以逆向遍历列表，列表迭代器有多个元素，则返回 true
 (5)E next():返回列表中的下一个元素
 (6)E previous():返回列表中的前一个元素
 (7)int nextIndex():返回对 next 的后续调用所返回元素的索引
 (8)int previousIndex():返回对 previous 的后续调用所返回元素的索引
 (9)void remove():从列表中移除由 next 或 previous 返回的最后一个元素
 3.1 ArrayList
 3.1.1
 (1)有序列表，允许重复
 (2)底层存储采用数组，查询快，增删慢，线程不安全，下标从0开始，轻量级
 (3)可以动态增长和缩减的索引序列
 3.1.2 方法
 (1)继承List所有方法
 (2)Object clone():返回此 ArrayList实例的浅表副本
 3.2 LinkedList
 3.2.1
 (1)有序列表，允许重复
 (2)底层采用链表实现，增删快，查询慢，线程不安全
 3.2.2 方法
 (1)void addFirst(E e):将指定元素插入此列表的开头
 (2)void addLast(E e):将指定元素添加到此列表的结尾
 (3)E getFirst():返回此列表的第一个元素
 (4)E getLast():返回此列表的最后一个元素
 (5)E removeFirst():移除并返回此列表的第一个元素
 (6)E removeLast(): 移除并返回此列表的最后一个元素
 (5)Object clone():返回此 LinkedList 的浅表副本
 3.3 Vector
 3.3.1
 (1)有序列表，允许重复，线程安全
 (2)底层存储采用数组，线程安全，重量级
 4、Set
 4.0
 (1)无序集合，不允许存放重复的元素,(TreeSet,SortedSet除外，这两个集合是有序的)
 4.0.1 方法
 (1)继承Collection所有方法
 (2)int hashCode():返回 set的哈希码值
 4.1 HashSet
 4.1.1
 (1)没有重复的无序集合
 (2)哈希表实现的
 4.1.2 方法
 (1)继承Set的所有方法
 (2)HashSet()构造一个新的空 set，其实例的默认初始容量是 16，加载因子是 0.75
 (3)HashSet(Collection<? extends E> c)构造一个包含指定 collection中的元素的 set
 (4)HashSet(int initialCapacity):构造一个新的空 set，其具有指定的初始容量initialCapacity
 (5)HashSet(int initialCapacity, float loadFactor)构造一个新的空 set，其实例具有指定的初始容量和指定的加载因子
 (6)Object clone():返回此 HashSet实例的浅表副本,但是没有复制这些元素本身
 4.2 TreeSet
 4.2.1
 (1)没有重复的有序集合
 (2)二叉树实现的
 (3)插入数据时要比hashSet要慢，但是比插入到list中要快
 4.2.2 方法
 (1)继承set的所有方法
 (2)TreeSet():构造一个新的空 set，该 set 根据其元素的自然顺序进行排序
 (3)TreeSet(Collection<? extends E> c):构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序
 (4)TreeSet(Comparator<? super E> comparator):构造一个新的空 TreeSet，它根据指定比较器进行排序
 (5)E ceiling(E e): 返回此 set中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null
 (6)E higher(E e):返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null
 (7)E floor(E e):返回此 set中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null
 (8)E lower(E e):返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null 
 (9)Comparator<? super E> comparator():返回对此 set中的元素进行排序的比较器；如果此 set使用其元素的自然顺序，则返回 null
 (10)Iterator<E> descendingIterator():返回在此 set元素上按降序进行迭代的迭代器
 4.3 SortedSet
 (1)没有重复的有序集合
 (2)对set排序
 (3)接口
 5、Map
 5.0.1
 (1)键值对
 (2)键值不存在重复，如果有两个Key重复，那么后来的会覆盖之前的
 (3)每个键最多只能映射到一个值
 5.0.2
 (1)void clear():从此映射中移除所有映射关系
 (2)boolean containsKey(Object key):如果此映射包含指定键的映射关系，则返回 true
 (3)boolean containsValue(Object value):如果此映射将一个或多个键映射到指定值，则返回 true
 (4)boolean equals(Object o):比较指定的对象与此映射是否相等
 (5)V get(Object key):返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null
 (6)int hashCode():返回此映射的哈希码值
 (7)boolean isEmpty():如果此映射未包含键-值映射关系，则返回 true
 (8)Set<K> keySet():返回此映射中包含的键的 Set视图
 (9)V put(K key, V value):将指定的值与此映射中的指定键关联
 (10)void putAll(Map<? extends K,? extends V> m):从指定映射中将所有映射关系复制到此映射中
 (11)V remove(Object key):如果存在一个键的映射关系，则将其从此映射中移除
 (12)int size():返回此映射中的键-值映射关系数
 (13) Collection<V> values():返回此映射中包含的值的 Collection 视图
 5.1 HashMap
 5.1.1
 (1)键值对
 (2)键值中不存在重复，但是没有顺序，键值就是HashSet
 (3)线程不安全
 (4)允许null作为key或value
 (5)基于哈希表的 Map 接口的实现
 5.1.2 方法
 (1)继承Map的所有方法
 (2)Object clone():返回此 HashMap 实例的浅表副本,并不复制键和值本身
 5.2 TreeMap
 5.2.1
 (1)键值对
 (2)键值中不存在重复，键值有顺序，键值就是TreeSet
 (3)线程不安全
 (4)基于红黑树的实现，该映射默认按照其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator进行排序，具体取决于使用的构造方法
 5.2.2 方法
 (1)继承Map的所有方法
 (2)Object clone():返回此 TreeMap实例的浅表副本,并不复制键和值本身
 (3)Comparator<? super K> comparator():返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null
 5.3 HashTable
 (1)键值对
 (2)键值中不存在重复，键值有顺序
 (3)线程安全
 (4)允许null作为key或value
 (5)基于哈希表的 Map接口的实现
 5.4 SortedMap
 (1)键值对
 (2)键值中不存在重复
 (3)对Map的键值做了排序的接口
 6、集合辅助类
 6.1 Collections类
 (1)主要提供了在 collection 上进行操作的静态方法
 7、衍生类
 7.1 Properties
 (1)继承自Hashtable，常用来解析键值对的配置文件，属性列表中每个键及其对应值都是一个字符串，格式:KEY=VALUE
 (2)常用方法1：String getProperty(String key)：根据KEY找到VALUE
 (3)常用方法2：setProperty(String key,String value);新增一个属性
 (4)使用例子：
    Properties p = new Properties();//声明对象
    p.load(new FileInputStream("D://test.properties"));//加载配置文件
    Value = p.getProperty("KEY");//根据Key得到Value

8、代码示例

public class List01 {
	
	public static void main(String[] args){
		System.out.println("**********Collection练习开始**********");
		testCollection();
		System.out.println("**********Collection练习结束**********");
		
		System.out.println("**********List练习开始**********");
		testList();
		System.out.println("**********List练习结束**********");
		
		System.out.println("**********Set练习开始**********");
		testSet();
		System.out.println("**********Set练习结束**********");
		
		System.out.println("**********Map练习开始**********");
		testMap();
		System.out.println("**********Map练习结束**********");
		
	}
	//Collection练习
	public static void testCollection() {
		
	    //Collection方法例子
		Collection<String> col = new ArrayList<String>();
		Collection<String> col2 = new ArrayList<String>();
		if(col.isEmpty()){
			System.out.println("集合为空");
		}
		//add()
		col.add("a");
		col.add("b");
		col.add("c");
		//addAll()
		col2.add("d");
		col2.add("e");
		col.addAll(col2);
		//isEmpty(),size()
		if(!col.isEmpty()){
			System.out.println("添加元素成功，元素个数是"+col.size());
			System.out.println("初始化阶段元素依次是：");
			for(String str : col){
				System.out.print(str+" ");
			}
			System.out.print("\n");
			//contains()
			if(col.contains("a")){
				System.out.println("有a这个元素");
			}
			Collection<String> col3 = new ArrayList<String>();
			col3.add("c");
			col3.add("e");
			//containsAll()
			if(col.containsAll(col3)){
				System.out.println("包含col3集合中的所有元素");
			}
			//remove()
			if(!col.remove("aa")){
				System.out.println("aa不在列表中，删除返回值是false");
				if(col.remove("a")){
					System.out.println("a在列表中，删除返回值是true，已删除");
				}
			}
			//removeAll()
			if(col.removeAll(col2)){
				System.out.println("col集合中与col2集合中的相等的元素已移除");
			}
			//toArray()
			System.out.print("当前阶段集合的元素的依次是：");
			Object[] objArgs = col.toArray();
			for(Object obj : objArgs){
				System.out.print(obj.toString()+" ");
			}
			System.out.print("\n");
			//retainAll()
			Collection<String> col4 = new ArrayList<String>();
			col4.add("b");
			col4.add("cc");
			if(col.retainAll(col4)){
				System.out.println("保留col与集合col4中所含的元素相等的元素，其他都移除");
			}
			//iterator()
			System.out.println("最后阶段集合元素依次是：");
			Iterator<String> it = col.iterator();
			while(it.hasNext()){
				System.out.print(it.next());
			}
			
			
			System.out.print("\n");
		}
	
	}
	//List练习
	public static void testList() {
		List<String> arrayList = new ArrayList<String>();
		List<String> arrayList1 = new ArrayList<String>();
		//add()
		arrayList.add("a");
		arrayList.add("b");
		arrayList.add("c");
		//add([int i,]E element)
		arrayList.add(1, "1");
		arrayList1.add("2");
		arrayList1.add("3");
		arrayList.addAll(arrayList1);
		
		ListIterator<String> lit = arrayList.listIterator();
		
		System.out.println("当前列表中的元素：");
		while(lit.hasNext()){
			System.out.print(lit.next()+" ");
		}
		System.out.print("\n");
		
		//set()
		String str = arrayList.set(5, "b");
		System.out.println("替换的掉的元素是："+ str);
		//indexOf()
	    if(arrayList.indexOf("b") != -1){
	    	System.out.println("第一个与b元素相等下标是："+ arrayList.indexOf("b"));
	    }
	    //lastIndexOf()
	    if(arrayList.lastIndexOf("b") != -1){
	    	System.out.println("最后一个与b元素相等下标是："+ arrayList.lastIndexOf("b"));
	    	//remove()
	    	arrayList.remove(arrayList.lastIndexOf("b"));
	    	
	    }		
	    ListIterator<String> lit2 = arrayList.listIterator(1);
	    System.out.println("当前列表中的元素：");
		while(lit2.hasNext()){
			System.out.print(lit2.next()+" ");
		}
		System.out.print("\n");

	}
    //Set练习
	public static void testSet(){
		Set<String> set = new HashSet<String>();
		set.add("b");
		set.add("a");
		Set<String> set2 = new HashSet<String>();
		set2.add("b");
		set2.add("a");
		
		Iterator<String> it = set.iterator();
		System.out.println("set中的元素是：");
		while(it.hasNext()){
			System.out.print(it.next()+ " ");
		}
		System.out.println("\n");
		//hashCode()
		int i = set.hashCode();
		int j = set2.hashCode();
		System.out.println(i+":"+j);
		if(set.equals(set2)){
			System.out.println("相等");
		}
		
		//TreeSet
		 Mycomparator c = new List01().new Mycomparator();
		 TreeSet<String> ts = new TreeSet<String>(c);
		 ts.add("bly");
		 ts.add("amy");
		 ts.add("cny");
		 System.out.println("ts中的元素是：");
		 //iterator()
		 Iterator<String> it2 = ts.iterator();
		 while(it2.hasNext()){
			 System.out.print(it2.next() + " ");
		 }
		 System.out.println("\n");

	}
	//Map练习
	public static void testMap(){
		Map<String, String> map = new HashMap<String, String>();		
		//put()
		map.put("amy", "a");
		map.put("denny", "b");
		map.put("cnny", "c");
		
		//isEmpty(),hashCode()
		if(!map.isEmpty()){
			System.out.println("此Map不为空，其哈希码是："+map.hashCode());
			//keySet()
			Set<String> keySet = map.keySet();
			Iterator<String> it = keySet.iterator();
			System.out.print("key分别是：");
			while(it.hasNext()){
				System.out.print(it.next()+" ");
			}
			System.out.print("\n");
			
			//values()
			Collection<String> col = map.values();
			Iterator<String> ite = col.iterator();
			System.out.print("值集元素分别是：");
			while(ite.hasNext()){
				System.out.print(ite.next()+" ");
			}
			System.out.print("\n");
			
			Set<String> keySet2 = map.keySet();
			System.out.println("Map中的映射关系是：");
			for(String key : keySet2){
				System.out.println(key+":"+map.get(key));
			}
		}

	}
	
	/**
	 * 自定义一个比较器类
	 */
	class Mycomparator implements Comparator<String>{
		public int compare(String o1, String o2) {
			int i = o1.compareTo(o2);
			return -i; //采用倒序，借此与自然排序做对比
		}
	}

}