集合框架

集合里面只能保存引用类型

0. UML
统一建模语言
类框图
圆形

1. Collection接口
1.1 集合框架的顶级接口
1.2 是Set和List的父接口
1.3 但不是Map的父接口

集合中只能添加引用类型数据

图文关系

1.List

1.特点： 1.有序（按添加顺序输出）
2.对象可以重复

2.遍历：
1.forecah
2.for循环（List有下标）
3.迭代器

        List list=new ArrayList();
    	list.add(1);
    	list.add(3);
    	list.add(2);
    	list.add(3);
    	//遍历
    	//1.foreach
    	for (Object o : list) {
			System.out.println(o);
		}
        //2.for循环
    	for(int i=0;i<list.size();i++) {
    		System.out.println(list.get(i));
    	}
    	//3.迭代器
    	Iterator iterator = list.iterator();
    	for (Object object : list) {
		 System.out.println(object);	
		}

3.List优化：
初始容量10，负载因子1.5
(当没加值时长度为0，当你加值时初始长度就为10（也就是不管你加1个还是2个长度都为10），当你到达10个值时，自动给你增加容量 （10*1.5取整）按这个算法一直算，当你不用加那么多的值时有些空间浪费了就可以这样:)

//给定初始长度
List list=new ArrayList<>(initialCapacity);

              // 反射
       static void print(List arrayList) throws Exception {
   	Class c = arrayList.getClass();
   	Field elementDataField = c.getDeclaredField("elementData");
   	elementDataField.setAccessible(true);
   	Object[] arr = (Object[]) elementDataField.get(arrayList);
   	System.out.println("elementData.length=" + arr.length);
   }

4.装箱，拆箱：
值类型->引用类型 装箱
引用类型->值类型 拆箱
jdk1.5之后引入了自动装箱及自动拆箱功能

5.ArrayList,LinkedList,Vector的区别：
ArrayList：以连续的数组结构存储数据，查询块（下标）、增删改慢
LinkedList：以链表的结构存储数据，查询慢、增删改快
Vector：增删改查都慢，已过时

2.Set

1.特点： 1.无序（取值没有按照放值顺序），无下标
2.对象不可重复（eqauls）eqauls从Object继承默认比较地址，如果重复是过滤

2.遍历：
1.foreach
2.迭代器

        Set set = new HashSet<>();
		// 取值没有按照放值的顺序，所以是无序的
		// 无序意味着没下标
		// 不可重复：如果放入重复值，那么是覆盖还是过滤 （过滤）
		set.add("zs");
		set.add("ls");
		set.add("ww");
		set.add("mz");
		set.add("zl");
		set.add("zs");
		System.out.println(set.size());
		// 循环遍历取值
		for (Object o : set) {
			System.out.println(o);
		}
        //迭代器
		Iterator<Student> iterator = set.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}

3.常用实现类：
1.HashSet
LinkedHashSet作用（不常用）:
1)元素是有顺序的
2)元素是不重复的
3)底层数据结构是按照链表的结构存贮的Linked
2.TreeSet:根据某种（规则）对里面的元素进行排序
规则1: java.lang.Comparable （按照26个字母排序）
特点：必须实现Comparable接口
规则2: java.util.Comparator

  //规则1
                       Set<String> set=new TreeSet<>();
		               set.add("zs");
	                   set.add("ls");
		               set.add("ww");
		               set.add("zl");
		              for (String string : set) {
			         System.out.println(string);
	                	}

#``# 3.Map
泛型：
以类型作为参数的类就叫泛型
作用：提高程序健壮性，简化代码
泛型的默认值是Object

1.特点: 1.无序，一键值对的形式添加元素，键不能重复，值可以重复
2.它没有继承Collection接口

2.遍历： 1.迭代所有键位
2.迭代所有值位
3.迭代器

         // Map 俩个泛型 键（key）值（value）对
		 Map<String, Object> map = new HashMap<String, Object>();
		 map.put("zs", "CN");
		 map.put("ww", "JSP");
		 map.put("zl", "CN");
		 map.put("zs", "USA");
        
         // 1.迭代所有的键位
         Set<String> keySet = map.keySet();
		 for (String string : keySet) {
		 System.out.println("键位:" + string);
		 System.out.println("值位:" + map.get(string));
         
         // 2.迭代所有的值位
		 Collection<Object> values = map.values();
		 for (Object object : values) {
		 System.out.println(object);
         
         // 3.迭代器
		 Set<Entry<String, Object>> entrySet = map.entrySet();
		 for (Entry<String, Object> entry : entrySet) {
		 System.out.println(entry.getKey());
		 System.out.println(entry.getValue());
		 }
		 }
     	 }

3.HashMap与Hashtable的区别：
HashMap（JDK1.2版本） 与 Hashtable（JDK1.0版本）
1.Hashtable种不能放空值 HashMap可以放
2.Hashtable 里的方法都带有synchronized(锁旗标),比较安全，但比较慢；HashMap比较快

         Map<String, Object> map = new HashMap<String, Object>();
		 //Map<String, Object> map=new Hashtable<>();
		 map.put("ls", null);//Hashtable种不能放空值

4.Map的简单嵌套：

        Map<String,List<Stu>>map=new HashMap<>();
		map.put("t248", list);
		Map<String, Map<String,List<Stu>>> m=new HashMap<>();
		m.put("y1阶段",map);
		Set<Entry<String, Map<String, List<Stu>>>> entrySet =    m.entrySet();
		for (Entry<String, Map<String, List<Stu>>> entry : entrySet) {
			System.out.println(entry.getKey());
			Map<String, List<Stu>> value = entry.getValue();
			Set<Entry<String, List<Stu>>> entrySet2 = value.entrySet();
			for (Entry<String, List<Stu>> entry2 : entrySet2) {
				System.out.println(entry2.getKey());
				List<Stu> value2 = entry2.getValue();
				for (Stu stu : value2) {
					System.out.println(stu);
				}
			}
		}