#1、集合Collection
1.什么是集合
集合就是一个容器，我们之前的学的容器有：数组，StringBuffer。2.集合和数组的区别：
a、长度区别集合长度可变
数组长度固定
b、内容区别
集合可以存储不同引用类型的数据
数组只能存储相同类型的数据，但是他可以存储基本类型的数据
3、集合的体系结构
集合有两大体系：Collection 存储单列数据
List 有序，可重复
ArrayList 底层实现是数组，插入慢，访问快，默认使用
LinkedList 底层实现是链表，插入快，访问慢
Vector 底层实现是数组，插入慢，访问快，但是是线程安全的，已不建议使用
Set 无序，不能重复
HashSet 底层是有哈希表实现，可存储null
LinkedHashSet 底层是由哈希表和链表实现，插入快，访问慢
TreeSet 自动排序
Map 存储两列数据（Key value），键值对
HashMap
linkedHashMap
TreeMap
HashTable
4、常用方法
4.1增加方法：
boolean add(E e)确保此 collection 包含指定的元素（可选操作）。
boolean addAll(Collection<? extends E> c)
将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
4.2转数组方法：
Object[] toArray()返回包含此 collection 中所有元素的数组。
4.3删除方法：
boolean remove(Object o)从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
boolean removeAll(Collection<?> c)
移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
4.4判断方法：
boolean contains(Object o)如果此 collection 包含指定的元素，则返回 true。
boolean containsAll(Collection<?> c)
如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean isEmpty()
如果此 collection 不包含元素，则返回 true。
4.5获取集合长度的方法：
int size()返回此 collection 中的元素数。
4.6集合遍历：
1、使用Collection标准的迭代器方法：Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。
//使用迭代器遍历Collection接口
Iterator itr = c1.iterator();
//判断迭代器是否有下一个元素，有就处理没有就退出循环
while(itr.hasNext()){
Student s = (Student)itr.next();
System.out.println(s);
}
2、foreach
//通过foreach循环遍历集合
//什么是foreach？也叫增强for循环，是java1.5之后的特性
for (Object obj : c1) {
//向下转型，可以使用子类的特有的方法
Student student = (Student)obj;
System.out.println(student);
}
4.7交集功能：
boolean retainAll(Collection<?> c)仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
#2、List接口
List是Collection接口的子接口特点：
1、元素有序、且可重复
2、每个元素都有自己的索引，我们可以根据这个索引来访问其对应的元素
常用实现类：
1、ArrayList
2、LinkedList
3、Vector
常用方法（自己扩展的方法）：
void add(int index, Object ele) //在指定位置添加元素
boolean addAll(int index, Collection eles) //可以将另外一个集合添加到指定位置
Object get(int index) //根据索引获取集合中的元素
int indexOf(Object obj) //判断一个对象首次一次出现的位置
int lastIndexOf(Object obj) //判断一个对象最后一次出现的位置
Object remove(int index) //根据索引移除对象
Object set(int index, Object ele)
List subList(int fromIndex, int toIndex)
List接口遍历
1、迭代器
Iterate itr = list.iterator);
while(itr.hasNext()){...}
2、foreach
for(Object object:list){...}
3、for和Iterator
for (Iterator iterator = list.iterator(); iterator.hasNext();) {...}
4、普通for循环
for (int i = 0; i < list.size(); i++) {...}
##2.1.ArrayList
List的三大子类：1、ArrayList：
底层数据结构是数组，访问快，插入慢
2、LinkedList
底层数据结构是链表，插入快，访问慢
3、Vector
底层是数组，访问快，插入慢，但是他是线程安全的，性能不如ArrayList
该怎么使用呢？
1、如果你的数据修改很少，访问很多
选ArrayList
2、如果你的数据经常变更，很少访问
选LinkedList
3、Vector不建议使用
4、如果我根本不清楚据访问多还是存储多
那么就选ArrayList
泛型编写数字：
1、泛型卸载<>之间
2、跟在类的后面
##2.2.LinkedList
List实现类之：LinkedList:对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高
新增方法：
void addFirst(Object obj) //将指定元素插入此列表的开头。
void addLast(Object obj) //将指定元素插入此列表的开头。
Object getFirst() //返回此列表的第一个元素。
Object getLast() //返回此列表的第一个元素。
Object removeFirst() //移除并返回此列表的第一个元素。
Object removeLast() //移除并返回此列表的第一个元素。
案例：
* 要求你是用LinkedList模拟实现栈(Stack)的数据结构
* 栈的数据结构忒点：
* 数据先进后出
*
* 思路：
* 1、编写自定义Stack类
* 2、提供一个add方法，能够添加数据
* 3、提供一个get数据，能过获取数据
##3.VectorList实现类之：Vector
线程安全，并发访问就慢
void addElement(Object obj)
void insertElementAt(Object obj,int index)
void setElementAt(Object obj,int index)
void removeElement(Object obj)
void removeAllElements()
#2.3、Set接口
Collection子接口之：Set特点：
无序，且不能有重复的元素
子类：
HashSet: 底层数据结构是哈希表
LinkedHashSet：底层数据结构是链表+哈希表
TreeSet：底层数据结构是红黑树，自动排序
##2.3.1 HashSet
HashSet特点：1、无序（存进去和取出来的顺序不一样）
2、HashSet 不是线程安全的
3、集合元素可以是 null
怎么保证数据的唯一性：
1、先判断hashcode
2、在判断equals
如果需要存储自定义的对象，那么我们最好重写hashcode()和equals()方法
怎么重写呢？很简单：
eclipse：shift+alt+s来生成
##2.3.2 LInkedHashSet
set实现类之二：LinkedHashSetLinkedHashSet是HashSet的子类
数据结构：
链表+哈希表
特点：
有序（由链表保证）
数据不能重复
#3、TreeSet
TreeSet 是 SortedSet 接口的实现类.特点：
元素唯一
排序
两种排序方法：
自然排序 比较的类需要实现接口compareable，并重写compareTo方法
比较器排序，也叫定制排序 自定义比较器实现comparator，并重写comapre方法
升序：需要在compareTo和comapre方法里面，使用前者的属性和后者的属性相比较：
倒叙：需要在compareTo和comapre方法里面，使用后者的属性和前者的属性相比较：
注意：
1、如果试图把一个对象添加到 TreeSet 时，则该对象的类必须实现 Comparable 接口。
2、TreeSet是用compareTo()来判断重复元素的，而非equals()
#4、Map
特点1、map存储的数据有两列，叫键值对
2、Map 中的 key 用Set来存放，不允许重复，value使用Collection存放
3、key 和 value 之间存在单向一对一关系
常用实现类：
HashMap
LinkedHashMap
TreeMap
HashTable
Properties
常用方法
添加、删除操作：
Object put(Object key,Object value) 将指定的值与此映射中的指定键关联（可选操作）。
Object remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除
void putAll(Map t) 从指定映射中将所有映射关系复制到此映射中
void clear() 从此映射中移除所有映射关系
元素查询的操作：
Object get(Object key) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
boolean containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true。
boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true。
int size() 如果此映射将一个或多个键映射到指定值，则返回 true。
boolean isEmpty() 如果此映射未包含键-值映射关系，则返回 true。
boolean equals(Object obj) 比较指定的对象与此映射是否相等。
最常用get和size方法，其他都较少使用
元视图操作的方法：
Set keySet() 返回此映射中包含的映射关系的 Set 视图
Collection values()
Set entrySet()
keyset和entryset是需要掌握的
//必须掌握map的遍历方法
Map<String, String> map = new HashMap<String,String>();
map.put("郭靖", "黄蓉");
map.put("杨康", "穆念慈");
map.put("杨过", "小龙女");
//通过keyset可以取出所有的key到Set对象
Set<String> set = map.keySet();
for (Object object : set) {
System.out.println(object+" "+ map.get(object));
}
System.out.println();
//通过entrySet来获取map的key和value
Set<Map.Entry<String,String>> set1 = map.entrySet();
for (Entry<String, String> entry : set1) {
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key+" "+ value);
}
System.out.println();
//把所有的value返回到一个Collection里
Collection<String> c1 = map.values();
for (String string : c1) {
System.out.println(string);
}
##4.1 HashMap
HashMap是 Map 接口使用频率最高的实现类允许使用null键和null值
HashMap 判断两个 key 相等的标准:equals() 和hashCode
##4.2 LinkedHashMap（了解）
特点：有序（有链表保证）
##4.3 TreeMap
TreeMap：可以保证所有的 Key-Value 对处于有序状态。自然排序: 排序的类实现Comparable，然后需要实现compateTo方法
定制排序: 自定义比较器类实现个 Comparator
判断key相等的标准：两个key通过compareTo()方法或者compare()方法返回0
注意：
若使用自定义类作为TreeMap的key，所属类需要重写equals()和hashCode()方法，且equals()方法返回true时，compareTo()方法应返回0。
##4.4 HashTable（了解）
1、Hashtable线程安全。2、Hashtable 不允许使用 null
3、无序
4、判断key是否相等与hashMap一致
##4.5 Properties
Properties: 是 Hashtable 的子类，该对象用于处理属性文件常用方法：
setProperty(String key,String value)
String getProperty(String key)
//读取配置文件
Properties properties = new Properties();
//把config.properties文件加载到内存中的pros对象中
properties.load(new FileInputStream("G:\\workspace\\javabase\\src\\day15\\map\\config.properties"));
String driverClassName = properties.getProperty("driverClassName");
String userName = properties.getProperty("userName");
String password = properties.getProperty("password");
String url = properties.getProperty("url");
System.out.println(driverClassName);
System.out.println(userName);
System.out.println(password);
System.out.println(url);
#5、Collections
Collections是集合的工具类，类似数组的工具类Arrays##5.1 sort(list, Comparator)
//通过sort(List，Comparator)对map的value进行排序Set<Map.Entry<String, Integer>> set = map.entrySet();
List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(set);
Collections.sort(list, new Comparator<Map.Entry<String, Integer>>(){
@Override
public int compare(Entry<String, Integer> o1,
Entry<String, Integer> o2) {
return o1.getValue()-o2.getValue();
}
});
##5.2 同步控制
Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题#6、集合嵌套
//经典案例之list包含map，map再包含listList<Map<String,List<Student>>> list = new ArrayList<Map<String,List<Student>>>();
//现在有两个Map，分别是javaEEMap和h5Map
//javaee班有个班级
//h5有1个班级
Map<String, List<Student>> javaEEMap = new HashMap<String, List<Student>>();
List<Student> l1 = new ArrayList<Student>();
l1.add(new Student("张三1",21));
l1.add(new Student("张三2",22));
l1.add(new Student("张三3",23));
l1.add(new Student("张三4",24));
javaEEMap.put("java01班", l1);
List<Student> l2 = new ArrayList<Student>();
l2.add(new Student("李四1",21));
l2.add(new Student("李四2",22));
l2.add(new Student("李四3",23));
l2.add(new Student("李四4",24));
javaEEMap.put("java02班", l2);
Map<String, List<Student>> h5Map = new HashMap<String, List<Student>>();
List<Student> l3 = new ArrayList<Student>();
l3.add(new Student("王五1",21));
l3.add(new Student("王五1",21));
l3.add(new Student("王五1",21));
l3.add(new Student("王五1",21));
h5Map.put("h5班", l3);
//把map放到总的List里面
list.add(javaEEMap);
list.add(h5Map);
for (Map<String,List<Student>> map : list) {
for (String key : map.keySet()) {
//得到map的value，是个list
List<Student> values = map.get(key);
for (Student student : values) {
System.out.println(key +"+"+ student);
}
}
}