集合和泛型

一、集合框架关系图

二、Java的三大集合接口

a)三大集合接口：collection( list set ) map
   i.Collection 存放的是一组 无序，不唯一的集合
      1.List 存放的是一组 有序，不唯一的集合
      2.Set 存放的是一组 无序，唯一的集合
   ii.Map 存放的是一组键值对（key 唯一的 ，value 不唯一）
b)接口的常用实现类：
   i.List: ArrayList  LinkedList
   ii.Set: hashSet
   iii.Map: hashMap
c)LinkedList
   i.存放的一组有序不唯一的集合
   ii.在内存表现的是连个链表方式
   iii.遍历，随机访问的效率比较低
   iv.删除，插入效率很高
d)ArrayList
   i.在内存中创建时一个连续的空间
   ii.存放一组有序的不唯一的集合
   iii.遍历，和随机访问的效率高
   iv.删除，插入的效率比较低
e)Hashcode
   i.每个对象都有一个hashcode
   ii.不同的hashcode 一定是不同的对象
   iii.不同的对象可能有相同的hashcode
   iv.Hash表
      散列表又称哈希表（Hash表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
f)HashSet去重原理
   i.首先比较 hashcode，调用hashcode方法，hashcode值不同 ,则放进set集合
   ii.如果hashcode 值相同，作比较调用equals方法 --》 如果返回false ,则放进set集合，如果返回true则认为所添加对象与set集合中对象重复，无法添加

三、集合的遍历方法

a)HashMap
   i.增强型for 循环

for (Entry<String, String> entry : map.entrySet()) {
	System.out.println(entry .getKey() + "-------" + entry .getValue());
}

   ii.间接的迭代器迭代

Iterator<String> it = map.keySet().iterator();
while (it.hasNext()) {
	String str = (String) it.next();
	System.out.println(str + ":" + map.get(str));
}

   iii.通过key 遍历

Set<String> keys = map.keySet();
for(Object obj : keys){
	System.out.println(obj+ "_"+ map.get(obj));
}

b)Hashset
   i.增强型for 循环
   ii.数组的方式
   iii.迭代器
c)ArrayList | LinkedList
   i.普通for循环

for（int i = 0;i < list.size(); i++）{
	System.out.println(list.get(i));
}

   ii.增强型for 循环

for(List list : names){
	System.out.println(list.toString());
}

   iii.数组的方式
运用list集合中的toArray方法将list集合转为数组再遍历数组（没搞清意义所在）

	Object[] objs = list.toArray();
		for (Object obj : objs) {
			System.out.println(obj);
		}

   iv.迭代器

	Iterator<String> iterator = list.iterator();
	while(iterator.hasNext()) {
		System.out.println(iterator.next());
	}

   vi.Lambda表达式（jdk1.8之后的功能）

 	strList.forEach(str -> {
        System.out.println(str);
    });

3.集合常用的方法

a)Collection — list set - {ArrayList LinkedList hashSet}
   i.clear() – 清空集合
   ii.isEmpty() – 判断集合是否为空
   iii.iterator() – 迭代器
   iv.toArray() — 将集合转换为数组
b)List {Arraylist LinkedList}
   i.add(Object o) – 添加一个对象
   ii.remove(Object o) – 移除一个对象
   iii.size() — 获取集合的大小
   iv.contains(Object o) — 判断是否包含对象
c)Arraylist
   i.add(int index,Object o) – 将对象添加到指定下表位置
   ii.remove(int index,Object o) – 移除指定下表位置对象
   iii.get(int index) — 根据下表获取对象
d)LinkedList
   i.addFirst(Object o) – 添加第一条元素
   ii.addLast(Object o) — 添加最后一条元素
   iii.getFirst() — 获取第一个元素
   iv.getLast() – 获取最后一个元素
   v.removeFirst() — 移除第一个元素
   vi.removeLast() — 移除最后一个元素
e)HashSet
   i.没有get(int index)
f)HashMap
   i.put(Object key, Object val) — 存放键值对
   ii.get(Object key) – 根据key 获取值
   iii.remove(Object key) --根据key移除map元素
   iv. size() - 获取map 大小
   v.keySet() - 获全部的 key
   vi.values() - 获取全部的值
   vii.containsKey(Object key)-判断是否包含key
   viii.containsValue(Object key) – 判断是否包含值

4.ArrayList & LinkedList 区别

a)底层实现的及方式
   i.ArrayList 基于动态数组 ；
   ii.LinkedList 基于链表
b)各自优势
   i.ArrayList 查询，获取 效率高
   ii.LinkedList 增加，删除 效率高
c)选择使用那一中list
   i.主要用来查询，获取，建议使用ArrayList
   主要用来增加，删除，建议使用LinkedList

5.泛型 — 规定集合内的类型

i.泛型类
ii.泛型接口
iii.泛型方法
iv.泛型通配符
a)HashMap<String , Object > map = new HashMap<String , Object >();
b)LinkedList<类型> list = new LinkedList<类型>();
c)ArrayList<类型> list = new ArrayList<类型>();
d)HashSet<类型> set = new HashSet<类型>();

6.Collections 集合的操作工具类

实现Comparable接口，重写compareTo方法，实现类之间比大小

a)sort(List): 元素排序 — 除包装类外 其他对象需要实现接口Comparable
b)shuffle(List): 元素随机排序
c)reverse(List)：元素逆序排序
d)max(List)\min(List):查找最大\最小值
e)binarySearch(List,Object)：查找