Java集合框架共有三大类接口: List、Set、Map

List 接口存储一组不唯一，有序（插入顺序）的对象
1. List

俩个实现类：

1. ArrayList
   实现了长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高

   常用方法：
   	boolean add(Object obj)   将元素添加到集合
   	boolean add(int index,Object obj)   将元素添加到集合的index索引位置
   	Object get（int index）,返回集合中索引为index的元素
   	int indexOf（Object obj），返回元素在集合中出现的索引
   	Object set（int index,Object obj)，将index索引位置的元素替换为obj元素
   	Object remove（int index）,删除并返回index索引位置的元素
   	boolean isEmpty(),判断集合是否为空
   	boolean contains（Object obj），判断集合是否包含obj
   

   Arraylist,的下标从0开始，长度获取方式为size（）

   代码案例

package demo1;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * 
 * 	ArrayList
 * 		【增】使用.add()加到最后
 * 			能存放重复的值
 * 			能存放不同类型的值
 * 		
 * 		【泛型】
 * @author tcf
 *
 */
public class ShowList {
	public static void main(String[] args) {
		ArrayList list = new ArrayList ();
		
		// 操作：增、删、改、查
		System.out.println("【增】 .add() ");
		list.add(1);
		list.add(2);
		list.add("2分");
		list.add(5.3);
		list.add("2分");
		list.add(5.3);
		System.out.println(list);
		
		//删除第1个元素
		System.out.println("【删】-1：使用位置（索引号）删除第1个元素");
		list.remove(0);
		System.out.println(list);
		
		System.out.println("【删】-2：使用值删除，如果重复删除匹配到的第1个");
		list.remove(5.3);
		System.out.println(list);
//		list.remove(666);// 参数如果是整数，默认是按位置删除
//		System.out.println(list);
		list.remove(666.666);//删除不存在的值，对list没影响
		System.out.println(list);
		
		System.out.println("***  【删】-3：使用条件删除（spark编程常见风格（Scala）");
//		list.removeIf( (a) -> {
//			return a.toString().equals("2分");
//		});
		list.removeIf( a -> a.toString().equals("2分") );
		System.out.println(list);
		
		//用指定的元素替换此列表中指定位置的元素。   set只能修改，不能新增
		System.out.println("【改】");
		list.set(0, 1.0);
		list.set(1, 2.0);
		list.add(2, "1.0");
		System.out.println(list);
		
		System.out.println("【查】-1：contains，获取boolean型的结果 ");
		System.out.println(list.contains("1.0"));
		System.out.println(list.contains(1.0));
		System.out.println(list.contains("3.0"));
		System.out.println("【查】-1：indexOf，获取下标（没有就是-1) ");
		System.out.println(list.indexOf("1.0"));
		System.out.println(list.indexOf("3.0"));
		
		System.out.println("【遍历-1】：for(;;)");
		for (int i = 0; i < list.size(); i++) {
			System.out.println( list.get(i));
		}
		System.out.println("【遍历-2】：for( : ) / for-each");
		ArrayList<Integer> list2 = new ArrayList<Integer> ();
		list2.add(1);
		list2.add(3);
		list2.add(2);  //?1：能不能加入其它类型（非Integer）的元素
		for (int one: list2) {
			System.out.println(one);
		}
		// 遍历-3：while、do...while + iterator() 
		System.out.println("【遍历-3】：使用iterator");
		Iterator<Integer> iterator = list2.iterator();
		while (iterator.hasNext()) {
			// 打印
			System.out.println("====" + iterator.next());
		}
		
		
		
		System.out.println("【遍历-4】：*** 使用forEach() 方法");
		list2.forEach( one -> System.out.println("----" + one) );
		
	}
}

2. LinkedList
   LinkedList类采用链表存储方式。插入、删除元素时效率比较高

   常用放法：
   void addFirst(Object o),将给定元素插入当前集合头部
   void addLast(Object o)，将给定元素插入当前集合尾部
   Object getFirst（），获得当前集合的第一个元素
   Object getLast（），获得当前集合的最后一个元素
   Object removeFirst（），移除并返回当前集合的第一个元素
   Object removeLast（），移除并返回当前集合的最后一个元素
   

2. Map
HashMap是Map接口中最常见的实现类
存储一组成对的键－值对象，提供key（键）到value（值）的映射，通过key来索引，key不允许重复，value允许重复，添加的对象将转换为Object类型

常用方法：
	Object put（key,value）,将相互关联的一个关键字与一个值放入该集合
	
	Object remove（Object key），从当前集合中移除与指定键相关的映射
	并返回该键关联的旧值，如果key没有任何关联，则返回null
	
	Object get（Object key）：获得与关键字key相关的值，如果该键不关联
	任何非null值，则返回null
	
	boolean containsKey（key），判断集合中是否存在关键字key
	
	boolean containsValue（value），判断集合中是否存在值value
	
	boolean isEmpty(),判断是否存在元素
	void clear（），清空
	int size（），返回集合元素数量
	Set keySet（），获取所有键key的集合
	Collection values（），返回所有Value的集合

package demo1;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;

/**
 * 	HashMap
 * 		
 * @author tcf
 *
 */
public class ShowMap {

	public static void main(String[] args) {
		HashMap<Integer, String> map1 = new HashMap<Integer, String> ();

		// 数据的常用操作： 增、删、改、查
		System.out.println("【增】使用put");
		map1.put(5, "angle");
		map1.put(2, "baby");
		map1.put(6, "hahahah");
		System.out.println(map1);
		
		// 删
		System.out.println("【删】remove-1: 使用key");
		map1.remove("5");// 指定的key类型与map1的key类型不一致，删除不了
		System.out.println(map1);
		map1.remove(6);
		System.out.println(map1);
		System.out.println("【删】remove-2: 使用key+value");
		System.out.println(map1.remove(2, "baby2"));// (2, baby)
		System.out.println(map1);
		
		// 改: replace只有找到key，才会更新value
		System.out.println("【改】-1：使用put");
		map1.put(2, "baby2");// 修改
		System.out.println(map1);
		System.out.println("【改】-2：使用replace");
		map1.replace(5, "haah");
		System.out.println(map1);
		map1.replace(8, "ssssssssssss");
		System.out.println(map1);
		
		// 查
		System.out.println("【查】-1：根据key查找");
		System.out.println(map1.containsKey(5));
		System.out.println(map1.containsKey(8));
		System.out.println("【查】-2：根据value查找");
		System.out.println(map1.containsValue("baby"));
		System.out.println(map1.containsValue("baby2"));
		
		System.out.println("【查】-3：使用get提取，迂回判断是否存在");
		String value8 = map1.get(8);
		if (value8 == null) {
			System.out.println("key（8）在map1中不存在");
		}
		else {
			System.out.println("8存在:"+ value8);
		}
		if (map1.get(5) == null) {
			System.out.println("key（5）在map1中不存在");
		}
		else {
			System.out.println("5存在");
		}
		
		// 【遍历】
		//key
		Set<Integer> keySet = map1.keySet();
		System.out.println(keySet);
		Iterator<Integer> iterator = keySet.iterator();
		while (iterator.hasNext()) {
			System.out.println("===" + iterator.next());
			//?2: 此处可以通过key获取到value，使用get(key)
		}
//		for (int i = 0; i < keySet.size(); i++) {
//			System.out.println(keySet.);
//		}
		
		//value
		Collection<String> values = map1.values();
		Object[] array = values.toArray();
		for (int i = 0; i < array.length; i++) {
			System.out.println("?????" + array[i].toString());
		}
		

		//    Entry：  (key,value)
		Set<Entry<Integer, String>> entrySet = map1.entrySet(); 
		System.out.println(entrySet);
		Iterator<Entry<Integer, String>> iterator2 = entrySet.iterator();
		while (iterator2.hasNext()) {
			Entry<Integer, String> one = iterator2.next();
			System.out.println("(" + one + ")");
			// 提取key、value => key     value
			System.out.println("\t" + one.getKey() +"     " + one.getValue());
		}
		
		
		
		
	}

}

3. Set
Set接口存储一组唯一、无序的对象

HashSet允许集合元素值为null

※操作数据的方法与List类似，Set接口不存在get()方法
常用方法
add(),size(),addAll()添加一个集合，clear()清空，contains（）判断是否包含，remove（）删除

Iterator接口表示对集合进行迭代的迭代器，专门实现集合的遍历
	hasNext()：判断是否存在另一个可访问的元素
	next()：返回要访问的下一个元素


HashSet 是不重复的而且是无序的!
一般用HashSet要重写hashCode和equals方法。
唯一性保证. 重复对象equals方法返回为true ，重复对象hashCode方法返回相同的整数
HashSet其实就是一个HashMap,只是你只能通过Set接口操作这个HashMap的key部分	

HashSet和ArrayList的区别：ArrayList是可重复的 有序的
特点：查询效率高，增删效率低 轻量级 线程不安全。
Arraylist：在数据的插入和删除方面速度不佳，但是在随意提取方面较快