java集合（一）--六个接口（List、Set、Map）

集合

1. 为什么学习java集合框架？
	学习数组可以用来存储数据
	（数据存储数据的弊端：
		1.存储相同数据类型的有序集合：存储的数据是相同类型的
		2.数组存储数据时，需要指定当前数组的长度而且长度不可变（定长）
			需求：使用数组存储学生信息，效率变低。使用数组存储每天的新闻信息
	）
	由于在大多数的应用场景中数据都是动态的，导致数组存储要么浪费空间，或者效率
2. java提供了一套功能强大的集合框架，来帮助存储数据信息
3.为什么java提供了这么多集合对象存储数据信息
	这么多集合对象用来在不同的需求场景使用
	本质上而言，其实不同的集合对象底层存储实现方案不同，不同的存储结构适用不同的需求

迭代器

1. Iterable是java.lang包下的接口，实现该接口都能够作为foreach的目标
2. Iterator是java.util包下的接口，迭代器用来迭代当前集合对象的
3. Iterator是一个接口，ArrayList中通过内部类完成了对于该接口的实现，获取		的实际是类的实现类对象
4. ListIterator 是一个接口 这个接口可以支持并发修改 内部提供了add set remove方法如果对于一个List集合对象要通过使用迭代器做修改(删除、添加、修改)那么请使用ListIterator

[外链图片转存失败(img-MAexFLeB-1565095754279)(https://i.loli.net/2019/07/30/5d4028674f5a559945.png)]

泛型

1. 泛型是编译期行为只能在编译期有效如果能够跨过编译期，那么泛型就没有任何意义。
2. 如何定义泛型类：在类后加<> 括号中编写任意长度任意字符，不能是数值
3.一般情况下我们通过大写的26个字母去声明当前泛型 T指type，E指element
4. 使用：泛型类<具体类型> 变量名 = new 泛型类<>();
5. 泛型接口：
	实现类实现泛型接口时不指定泛型类型，此时创建实现类对象是可以指定泛型类型
	class UserSerbeiceImpl<T> implements UserService<T>
	实现类实现泛型接口时指定泛型类型，那么将确定泛型类型
	class UserServiceImpl implements UserService<String>
6. 泛型方法：
	方法中使用泛型，该方法就是一个泛型方法
	静态方法无法使用泛型类中声明的泛型类型，因为泛型类型的确定是在创建对象是确定的，而静态方法是先于对象存在的，如果要使用，在当前静态方法上声明泛型类型
	public static<泛型类型> void 方法名()

六个接口

（collectionn、List、Set、Map、Iterable、Iterator）

Collection

定义：
	public interface collection<E> extends Iterable<E>
	<E>代表Object
	Iterator：是接口，凡是继承\实现了Iterable的类都能够作为foreach的目标
1. Iterable是java.lang包下的接口，实现该接口都能够作为foreach的目标
2. Iterator是java.util包下的接口，迭代器用来迭代当前集合对象的

常见方法：
	add、addAll、clear、remove、removeAll、retainAll、size、isEmpty
	contains、containsAll、iterator
迭代方法：
	foreach、迭代器

//注解，用来抑制警告的
@SuppressWarnings("all")
public class Test01 {
	public static void main(String[] args) {
		//学习接口中的方法，接口只要指向实现类对象			
		Collection coll = new ArrayList();
		//添加元素
		coll.add("你还好吗");	//相当于自动类型转换(Object obj="你还好吗")
		coll.add(123);	//Integer in=Integer.valueOf(123);Object obj=in;
		System.out.println("coll中的元素是："+coll);
		Collection coll2 = new ArrayList();
		coll2.add("林正阳");
		coll2.add("sure");
		coll.addAll(coll2);
		System.out.println("往coll中添加coll2："+coll);
		//删除元素
		//coll.clear();
		System.out.println(coll);
		
		//System.out.println("移除不存在的元素："+coll.remove("你还好"));
		//System.out.println(coll.removeAll(coll2));	//移除他俩的交集
		
		//System.out.println("retainAll()方法："+coll.retainAll(coll2));
		//查看元素
		System.out.println("查看是否为空coll:"+coll.isEmpty());
		System.out.println("查看元素个数:"+coll.size());
		System.out.println("查看是否包含元素sure:"+coll.contains("sure"));
	}
}

List

有序，可重复，可以是null值
定义：public interface List<E> extends Collection<E>
常见方法：
	增加：add(obj),add(index,obj),addAll(coll),addAll(index,coll)
	删除：remove(obj\index) removeAll(coll),clear(),retainAll(coll)
	修改：set(index,obj)
	查询：indexOf(obj),lastIndex(obj),subList(Startindex,endindex)
			isEmpty(),get(index),size(),contains(obj),containsAll(coll)
迭代：
普通for，增强for，迭代器(iterator[不支持并发修改]listIterator[支持并发修改])
1. 查看当前是否存在三国演义，如果存在则添加寓言故事，只能通过for循环完成，
增强for以及iterator都会报异java.util.ConcurrentModificationException并发修改异常，增强for循环底层使用迭代器，而对于迭代器而言，他也指向了集合对象，ls指向集合对象要先执行添加操作，迭代器对象	指向集合要执行迭代操作，此时会出现并发修改问题，程序就会报错。

/*
 * 	注意：不能是(ls.get(i)).equals("三国演义")因为ls.get(i)可能为null
 * 		if("三国演义".equals(ls.get(i))) {
 *				ls.add("寓言故事");
 *				
 *			}
 * 
 * */
public class Test05 {

	public static void main(String[] args) {
		List ls = new ArrayList();
		//添加元素
		ls.add("三国演义");
		ls.add("水浒传");
		ls.add("西游记");
		ls.add("红楼梦");
		//查看当前是否存在三国演义，如果存在则添加元素 寓言故事
		System.out.println("普通for循环》》》》");
		for(int i=0;i<ls.size();i++) {
			if("三国演义".equals(ls.get(i))) {
				ls.add("寓言故事");
				
			}
			
			
		}
		System.out.println(ls);
		//第二种
		//运行时出现异常、java.util.ConcurrentModificationException   并发修改异常
//		System.out.println("foreach循环》》》》");
//		for(Object obj:ls) {
//			String str = (String)obj;
//			if("三国演义".equals(str)){
//				ls.add("寓言故事");
//			}
//			
//		}
		
		//第三种
		//运行时出现异常、java.util.ConcurrentModificationException   并发修改异常
//		System.out.println("迭代器》》》》");
//		for(Iterator it=ls.iterator();it.hasNext();) {
//			if("三国演义".equals(it.next())) {
//				ls.add("寓言故事");
//				
//			}
//		}
//		System.out.println(ls);
        //listIterator[支持并发修改]
		System.out.println("=========ListIterator=========");
		ListIterator iterator = ls.listIterator();
		
		while(iterator.hasNext()) {
			if("三国演义".equals(iterator.next())) {
				iterator.add("寓言故事");
			}
		}
		System.out.println(ls);
		
		
	}

}

Set

		无序，唯一
定义：public interface Set<E> extends Collection<E>
常见方法：
	add、addAll、clear、remove、removeAll、retainAll、size、isEmpty、contains、containsAll、iterator
迭代方法：
	foreach、迭代器

迭代器接口

Iterable作为foreach目标

Iterator用来迭代元素

Map

数据： k-v 以键值的方式存储
	  k：无序、唯一（和Set一样）	v：无序、可重复（和collection一样）
常见方法：
	添加元素：put(k,v) 	get(k)	containsKey(k)		keySet(),
			remove(k)	size()	containsValue(v)	values()
迭代方式：
	1.获取键，迭代键的过程中通过get方法获取值
		for(Object key:keySet()){
		System.out.println(k+"="+map.get(k));
		
		}
	2.获取Entry对象，通过getKey和getValue获取键和值
	Set<Entry<String,String> kvs=mps.entrySet();
	// 实际是 HashSet中的Node对象 因为Node实现了Map中的Entry接口
	for(Entry<String,String> entry:kvs){
	System.out.println(entry.getKey()+"=="+entry.getValue());
	
	}

public class Test06 {

	public static void main(String[] args) {
		Map<String,Integer> mp = new HashMap<>();
		mp.put("宫本",18800);
		mp.put("橘右京",13800);
		mp.put("娜可露露",1000);
		
		mp.put("宫本", 13435);
		//mp.remove("宫本");
		
		//迭代元素
		Set<String> keys = mp.keySet();
		System.out.println("迭代所有的key和值");
		for(String key:keys) {
			System.out.println(key+"=="+mp.get(key));
			
		}
		System.out.println("迭代所有的值value");
		Collection<Integer> coll = mp.values();
		for(Integer value:coll) {
			System.out.println(value);
			
		}
		
		//获取entry对象迭代元素
		System.out.println("获取entry对象迭代元素");
		Set< Entry<String,Integer> > kvs = mp.entrySet();
		for(Entry<String,Integer>  entry:kvs) {
			System.out.println(entry.getKey()+"=="+entry.getValue());
			
			
		}
		
		System.out.println(mp);
		System.out.println(mp.size());
		System.out.println(mp.get("宫本"));
	}

}