一、集合框架
集合是用于存储对象的容器，集合可以进行扩容，集合的长度可变。
下面是在网上找的一个图片，java集合框架图：
上述类图中，实线边框的是实现类，如ArrayList，Vector，LinkedList，HashMap,TreeSet等，折线边框的是抽象类，比如AbstractCollection，AbstractList，AbstractMap等，而点线边框的是接口，比如Collection，Iterator，List等。
集合类中三个最主要的接口List、Set、Map。 由上图可看出所有的类都实现了Iterator接口，Iterator接口是用于遍历集合内元素的接口。
List接口主要的实现类ArrayList，LinkedList。
Set接口主要实现类HashSet，TreeSet。
Map接口主要实现类HashMap，TreeMap。
二、 List实现类
List集合特点：集合的元素是有序的，取出元素时支持先进先出，集合中的元素允许重复。
2.1.ArrayList
ArrayList集合底层结构是数组结构，由于底层结构是数组结构，所以访问速度极快。
ArrayList中常用的方法。
增：
boolean add(E e):将指定元素加入集合尾部
void add(int index,E element):将指定元素加入集合指定位置
boolean addAll(Collention <? Extends E> c): 按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到集合的尾部。
boolean addAll(int index,Collention <? Extends E> c): 按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到集合指定位置。
删：
E remove(int index):将指定位置的元素删除，并且返回该元素。
boolean remove(Object o):删除第一次出现的元素o，如果集合里有。
void clear():删除集合中所有的元素
改：
set(int index,E e)：将指定位置的元素更换为指定元素
查：
E get(int index):获得指定位置的元素。
int size():获取集合的长度
boolean isEmpty():判断集合是否为空
boolean contains(Object o):判断结合中是否包含某个元素
int IndexOf(Object o):判断第一次出现o元素的位置。如果没有返回-1
下面使用代码进行演示：
1 package Blogs; 2 3 4 5 import java.util.ArrayList; 6 7 import java.util.Iterator; 8 9 10 11 public class ArrayListDemo { 12 13 14 15 public static void main(String[] args) { 16 17 // TODO Auto-generated method stub 18 19 //建立ArrayList集合，并指定集合中的元素类型为String类型。 20 21 ArrayList<String> al=new ArrayList<String>(); 22 23 24 25 //向集合中添加元素 26 27 al.add("黑马"); 28 29 al.add("程序员"); 30 31 al.add("训练营"); 32 33 al.add("!"); 34 35 al.add("安卓"); 36 37 al.add("就业班"); 38 39 al.add("！!"); 40 41 42 43 //获得集合迭代器，将集合中内容迭代打印到控制台 44 45 Iterator it=al.iterator(); 46 47 while(it.hasNext()){ 48 49 System.out.print(it.next()); 50 51 } 52 53 System.out.println(""); 54 55 56 57 //获得集合长度 58 59 System.out.println(al.size()); 60 61 62 63 //删除指定位置元素 64 65 System.out.println("删除集合角标为1的元素："+al.remove(1)); 66 67 68 69 //删除指定元素 70 71 System.out.println("删除元素中的 安卓 ："+al.remove("安卓")); 72 73 74 75 //将指定位置元素更改为指定元素 76 77 al.set(3,"基础班"); 78 79 Iterator it1=al.iterator(); 80 81 while(it1.hasNext()){ 82 83 System.out.print(it1.next()); 84 85 } 86 87 System.out.println(""); 88 89 //清空元素 90 91 al.clear(); 92 93 //判断元素是否为空 94 95 System.out.print("元素是否为空："+al.isEmpty()); 96 97 } 98 99 100 101 }
2.2LinkedList
LinkedList集合底层采用链表结构存储数据，适用于频繁的增删元素。
LinkedList常用方法：
增：
boolean add(E e):将指定元素加入集合尾部
void add(int index,E element):将指定元素加入集合指定位置
boolean addAll(Collention <? Extends E> c): 按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到集合的尾部。
boolean addAll(int index,Collention <? Extends E> c): 按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到集合指定位置。
void addFrist(E e):将指定元素加到集合开头
void addLast(E e):将指定元素加到集合结尾，和add(E e)等同
删：
E remove(int index):将指定位置的元素删除，并且返回该元素。
boolean remove(Object o):删除第一次出现的元素o，如果集合里有。
E removeFirst():获取并删除集合中第一个元素，当集合为空时，会抛出NoSuchElementException异常
E removeLast():获取并删除集合中最后一个元素，当集合为空时，会抛出NoSuchElementException异常
E pollFirst():获取并删除集合中第一个元素，当集合为空时,返回null；
E pollLast():获取并删除集合中最后一个元素，当集合为空时,返回null；
void clear():删除集合中所有的元素
改：
set(int index,E e)：将指定位置的元素更换为指定元素
查：
E get(int index):获得指定位置的元素。
int size():获取集合的长度
boolean isEmpty():判断集合是否为空
boolean contains(Object o):判断结合中是否包含某个元素
int IndexOf(Object o):判断第一次出现o元素的位置。如果没有返回-1
E getFrist():获取集合中第一个元素，当元素为空时，会抛出NoSuchElementException 异常
E getLast():获取集合中最后一个元素，当元素为空时，会抛出NoSuchElementException 异常
E peekFrist():获取集合中第一个元素，当元素为空时，返回null
E peekLast():获取集合中最后一个元素，当元素为空时，返回null
方法中主要增加头尾元素的操作，下面使用代码进行演示：
1 package Blogs; 2 3 4 5 import java.util.LinkedList; 6 7 import java.util.ListIterator; 8 9 10 11 public class LinkedListDemo { 12 13 public static void main(String[] args){ 14 15 LinkedList<String> ll=new LinkedList<String> (); 16 17 //向集合中增加元素 18 19 ll.add("黑马"); 20 21 ll.add("程序员"); 22 23 ll.add("训练营"); 24 25 //向集合头部增加元素 26 27 ll.addFirst("itheima.com"); 28 29 //使用ListIterator迭代器，取出集合元素 30 31 ListIterator<String> it=ll.listIterator(); 32 33 while(it.hasNext()){ 34 35 System.out.print(it.next()); 36 37 } 38 39 System.out.println(""); 40 41 //获取集合中第一个元素 42 43 System.out.println("集合中第一个元素为："+ll.peekFirst()); 44 45 //删除第一个元素 46 47 ll.pollFirst(); 48 49 System.out.println("删除第一个元素后、集合中第一个元素变为："+ll.peekFirst()); 50 51 //清空集合中元素 52 53 ll.clear(); 54 55 //使用peek()，获取空集合中的元素，返回为空 56 57 System.out.print("集合内容为空时，使用peek进行获取元素:"+ll.peek()); 58 59 } 60 61 } 62 63
输出结果如下：
黑马程序员训练营!安卓就业班！!
7
删除集合角标为1的元素：程序员
删除元素中的 安卓 ：true
黑马训练营!基础班！!
元素是否为空：true
三、 Set实现类
set类中存放的是数据，是不允许重复的。
3.1 HashSet
HashSet类使用哈希表进行数据存储，判断是两个元素是否相同，是通过hashCode和equals两个方法进行判断，为了使HashSet集合中成功的存储元素，元素对应的类必须实现hashCode和equals方法。
HashSet在对元素进行存储时，首先将需要存储的元素和已经存入的元素的哈希值进行比较，如果包含哈希值相同的元素，会再使用equals方法判断，如果返回true，则是为同一元素。
代码示例：
1 package Blogs; 2 3 4 5 import java.util.HashSet; 6 7 import java.util.Iterator; 8 9 10 11 public class HashSetDemo { 12 13 14 15 public static void main(String[] args) { 16 17 // TODO Auto-generated method stub 18 19 //建立HashSet集合对象 20 21 HashSet<Student> hs=new HashSet<Student>(); 22 23 //对象中添加元素 24 25 hs.add(new Student("张三",23)); 26 27 hs.add(new Student("李四",21)); 28 29 hs.add(new Student("王五",20)); 30 31 hs.add(new Student("张三",23));//此时写入失败 32 33 hs.add(new Student("李四",22)); 34 35 //建立迭代器，将集合内容进行打印。 36 37 Iterator<Student> it=hs.iterator(); 38 39 while(it.hasNext()){ 40 41 Student s=it.next(); 42 43 System.out.println(s.getname()+"--"+s.getage()); 44 45 } 46 47 } 48 49 50 51 } 52 53 class Student{ 54 55 private String name; 56 57 private int age; 58 59 Student(String name,int age){ 60 61 this.name=name; 62 63 this.age=age; 64 65 } 66 67 public String getname() { 68 69 return name; 70 71 } 72 73 public int getage() { 74 75 return age; 76 77 } 78 79 public int hashCode(){ 80 81 //复写hashCode方法 82 83 return name.hashCode()+age*54; 84 85 86 87 } 88 89 public boolean equals(Object o){ 90 91 //复写equals方法 92 93 if(!(o instanceof Student)) 94 95 return false; 96 97 Student s=(Student)o; 98 99 if(s.name.equals(name)&&s.age==age) 100 101 return true; 102 103 return false; 104 105 } 106 107 }
打印结果：
李四--21
张三--23
李四--22
王五—20
由打印结果可看出，重复的元素并未写入，并且读取的内容是无序的。
3.2TreeSet
TreeSet集合中是按照“二叉树”方法存放元素，使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序。
TreeSet存入的自定义类元素必须要实现Comparable接口或在创建集合时传入Comparator比较器进行排序。
下面分别用两种方式对TreeSet内集合进行排序。
1 package Blogs; 2 3 4 5 import java.util.Comparator; 6 7 import java.util.Iterator; 8 9 import java.util.TreeSet; 10 11 12 13 public class TreeSetDemo { 14 15 16 17 public static void main(String[] args) { 18 19 // TODO Auto-generated method stub 20 21 22 23 System.out.println("按照年龄进行排序"); 24 25 //以Person自然排序规则进行排序（按照年龄排序） 26 27 TreeSet<Person> ts=new TreeSet<Person>(); 28 29 ts.add(new Person("张三",32)); 30 31 ts.add(new Person("李四",33)); 32 33 ts.add(new Person("王五",31)); 34 35 ts.add(new Person("李四",30)); 36 37 ts.add(new Person("博士",32)); 38 39 Iterator<Person> it=ts.iterator(); 40 41 while(it.hasNext()){ 42 43 Person p=it.next(); 44 45 System.out.println(p.getname()+"--"+p.getage()); 46 47 } 48 49 50 51 System.out.println("------------------------------------------"); 52 53 System.out.println("按照姓名进行排序"); 54 55 //传入比较器，按照比较器进行排序。（按照姓名排序） 56 57 TreeSet<Person> ts1=new TreeSet<Person>(new myPersonCompare()); 58 59 ts1.add(new Person("张三",32)); 60 61 ts1.add(new Person("李四",33)); 62 63 ts1.add(new Person("王五",31)); 64 65 ts1.add(new Person("李四",30)); 66 67 ts1.add(new Person("博士",32)); 68 69 Iterator<Person> it1=ts1.iterator(); 70 71 while(it1.hasNext()){ 72 73 Person p=it1.next(); 74 75 System.out.println(p.getname()+"--"+p.getage()); 76 77 } 78 79 } 80 81 } 82 83 //person类实现Comparable接口，以便使自己有排序规则 84 85 class Person implements Comparable<Person>{ 86 87 private String name; 88 89 private int age; 90 91 Person(String name,int age){ 92 93 this.name=name; 94 95 this.age=age; 96 97 } 98 99 public String getname(){ 100 101 return name; 102 103 } 104 105 public int getage(){ 106 107 return age; 108 109 } 110 111 @Override 112 113 //实现 compareTo 方法 按照年龄排序 114 115 public int compareTo(Person o) { 116 117 // TODO Auto-generated method stub 118 119 Person p=(Person)o; 120 121 if(this.age!=p.age) 122 123 return this.age-p.age; 124 125 else 126 127 return this.name.compareTo(p.name); 128 129 } 130 131 } 132 133 134 135 //定义比较器 136 137 class myPersonCompare implements Comparator<Person>{ 138 139 140 141 @Override 142 143 public int compare(Person p1, Person p2) { 144 145 // TODO Auto-generated method stub 146 147 148 149 if(p1.getname().equals(p2.getname())) 150 151 return p1.getage()-p2.getage(); 152 153 else 154 155 return p1.getname().compareTo(p2.getname()); 156 157 } 158 159 }
输出结果如下：
按照年龄进行排序
李四--30
王五--31
博士--32
张三--32
李四--33
-------------------------------------------
按照姓名进行排序
博士--32
张三--32
李四--30
李四--33
王五--31
四、 Map类
Map类中存放的元素都是以键—值对进行存储的。其中的“键”必须是唯一的，值可以相同。
4.1HashMap
HashMap类常用的方法
增：
V put(K key,V value)：在此映射中关联指定值与指定键，并返回键关联的旧值
void putAll(Map<? extends K,? extends V> m):将指定映射的所有映射关系复制到此映射中，如果原来键对应的有值则替换原来的值。
删：
void clear():清除所有映射关系
V remove(Object key):移除指定键的映射关系，并返回该键对应的值
查：
V get(Object key):获得指定键所映射的值，如果没有映射则返回null。
int size():返回此映射中，映射关系数
Collection<V> values():返回此映射中值得collection视图
Set<Map.Entry<K,V>> entrySet():返回此映射所包含的映射关系的 Set 视图。
判断：
boolean containsKey(Object key):判断此映射中是否包含指定键
boolean containsValue(Object value):判断此映射中是否包含指定值
示例代码：
1 package Blogs; 2 3 4 5 import java.util.HashMap; 6 7 import java.util.Map; 8 9 import java.util.Set; 10 11 12 13 public class MapDemo { 14 15 16 17 public static void main(String[] args) { 18 19 // TODO Auto-generated method stub 20 21 //建立HashMap对象 22 23 HashMap<String,Integer> hm=new HashMap<String,Integer>(); 24 25 //添加映射关系 26 27 hm.put("张三", 24); 28 29 hm.put("李四", 23); 30 31 hm.put("王五", 25); 32 33 //添加相同键的映射关系，会替换原来键对应的值 34 35 hm.put("张三", 25); 36 37 System.out.println("hm中的键值对为："+hm); 38 39 40 41 //判断是否有值“25” 42 43 System.out.println("判断此映射中是否包含值25："+hm.containsValue(25)); 44 45 //判断是否有键"赵六" 46 47 System.out.println("判断此映射中是否有键 赵六："+hm.containsKey("赵六")); 48 49 //获取Set对象，使用entrySet()方法输出HashMap中的键值对 50 51 Set<Map.Entry<String,Integer>> s=hm.entrySet(); 52 53 for(Map.Entry<String, Integer> m:s){ 54 55 System.out.println(m.getKey()+"-----"+m.getValue()); 56 57 } 58 59 60 61 System.out.println("使用keySet方法获取键值对"); 62 63 Set<String> s1=hm.keySet(); 64 65 for(String sr:s1){ 66 67 System.out.println("键："+sr+"---值:"+hm.get(sr)); 68 69 } 70 71 } 72 73 }
输出结果：
hm中的键值对为：{李四=23, 张三=25, 王五=25}
判断此映射中是否包含值25：true
判断此映射中是否有键 赵六：false
李四-----23
张三-----25
王五-----25
使用keySet方法获取键值对
键：李四---值:23
键：张三---值:25
键：王五---值:25
4.2 TreeMap
TreeMap使用二叉树法对键值对进行排序。排序规则是以键的自然顺序或者是将键按照指定比较器进行排序。
TreeMap中特有的方法：
Map.Entry<K,V> ceilingEntry(K key)：返回一个键值对关联，它大于等于给定键的最小键的关联，不存在则返回为空
K ceilingKey(K key): 返回一个键值对关系，它大于等于给定键的最小键，不存在则返回为空。
Map.Entry<K,V> floorEntry(K key)：返回一个键值对关联，它小于等于给定键的最小键的关联，不存在则返回为空
K floorKey(K key): 返回一个键值对关系，它小于等于给定键的最小键，不存在则返回为空。
Map.Entry<K,V> fristEntry(K key)：返回一个最小键的键值对关联，不存在则返回为空
K fristKey(K key): 返回一个最小的键，不存在则返回为空。
Map.Entry<K,V> lastEntry(K key)：返回一个最大键的键值对关联，不存在则返回为空
K lastKey(K key): 返回一个最大的键，不存在则返回为空。
Map.Entry<K,V> higeherEntry(K key)：返回一个键-值映射关系，它与严格大于给定键的最小键关联；如果不存在这样的键，则返回 null。
K higeherKey(K key): 返回严格大于给定键的最小键；如果不存在这样的键，则返回 null。
Map.Entry<K,V> lowerEntry(K key)：返回一个键-值映射关系，它与严格小于给定键的最小键关联；如果不存在这样的键，则返回 null。
K lowerKey(K key): 返回严格小于给定键的最小键；如果不存在这样的键，则返回 null。
集中类中各类集合的特点。
