------- android培训、java培训、期待与您交流！ ----------
集合可以看作是一个容器，如红色的衣服可以看作是一个集合，所有Java类的书也可以看作是一个集合。对于集合中的对象很容易将其存放到集合中，也很容易将其从集合中取出来，还可以将其按照一定的顺序进行摆放。Java中提供了不同的集合类，这些类具有不同的存储对象的方式，并提供了相应的方法以方便用户对集合进行遍历、添加、删除以及查找指定的对象。 提到容器不难想到数组，
集合类与数组的不同之处是：1.数组的长度是固定的，集合的长度是可变的；
2.数组用来存放基本类型的数据，集合用来存放对象的引用；
3.数组的元素类型一致，集合元素类型可以不一致；
常用的集合有List集合、Set集合、Map集合，其中List与Set实现了Collection接口。各接口还提供了不同的实现类。上述集合类的关系如下图所示：
Collection：定义了集合框架的共性功能。(1)List（列表）：元素是有序的，元素可以重复，因为该集合体系有索引。
ArrayList：底层是数组数据结构，查询速度很快，但是增删稍慢，线程不同步，默认10个元素。(线程不同步)
LinkedList：底层是链表数据结构，查询很慢，增删速度很快。（线程不同步）
(2)Set（集）：元素是无序的（存入和取出顺序不一定一致），元素不可以重复。
HashSet：底层数据结构是哈希表。线程是不同步的。
采用散列函数对元素进行排序（Asiic），是专门为快速查询而设计的。存入HashSet的对象必须定义hashCode方法。
LinkedHashSet：有序。
内部使用散列以加快查询速度，同时使用链表维护元素插入的次序，在使用迭代器遍历Set时，
结果会按元素插入的次序显示。
TreeSet：底层的数据结构是二叉树。线程是不同步的。
注意：集合只能保存引用数据类型，也就是存储的是对象的地址值，而不是对象本身。集合中的元素相当于引用类型变量。
Collection 的常用方法如下：
布尔型 add(E e)此处的E现在可以当成Object去理解
将指定的元素添加到此列表的尾部。
布尔型addAll(Collection<? extendsE> c)
将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
无返回值clear()
移除此列表中的所有元素。
布尔型contains(Object o)
如果此列表中包含指定的元素，则返回 true。
布尔型containsAll(Collection<?> c)
如果此 collection 包含指定 collection 中的所有元素，则返回 true。
布尔型equals(Object o)
比较此 collection 与指定对象是否相等。
整数hashCode()
返回此 collection 的哈希码值。
布尔型 isEmpty()
如果此 collection 不包含元素，则返回 true。
迭代器 iterator()
返回在此 collection 的元素上进行迭代的迭代器。
布尔型remove(Object o)
从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
布尔型removeAll(Collection<?> c)
移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
布尔型 retainAll(Collection<?> c)
仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
整数size()
返回此 collection 中的元素数。
对象[] toArray()
返回包含此 collection 中所有元素的数组。
<T> T[]toArray(T[] a)
返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
ArrayList特有方法：既然是对数据进行操作的，当然就有 增、删、改、查 这四个方法。
无返回值 add(int index,E element)
将指定的元素插入此列表中的指定位置。
布尔型 addAll(Collection<? extendsE> c)
按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。
布尔值 addAll(int index,Collection<? extendsE> c)
从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。
Eget(int index)
返回此列表中指定位置上的元素。
整数 indexOf(Object o)
返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
整数 lastIndexOf(Object o)
返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
Eset(int index, E element)
用指定的元素替代此列表中指定位置上的元素。迭代器(Iterator)
其实就是集合取出元素的方式。就把取出方式定义在集合的内部，这样取出方式就可以直接访问结合内容的元素。那么取出方式就定义成了内部类。而每一个容器的数据结构不同，所以取出的动作细节也不一样，但是都有共性内容：取出。那么可以写共性取出。那么这些内部类都符合一个规则。该规则是Iterator。
迭代时注意：在迭代时候，不可以通过集合对象的方法操作集合中的元素，因为会发生 ConcurrenModificationException异常。
所以在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作
如果想要其他的操作，如添加、修改等，就需要使用其子接口，ListIterator。
Iterator
迭代器的使用
1.使用步骤1)通过集合对象获取迭代器对象2)通过迭代器对象判断3)通过迭代器对象获取2.迭代器原理
由于多种集合的数据结构不同，所以存储方式不同，所以，取出方式也不同。
这个时候，我们就把判断和获取功能定义在了一个接口中，将来，遍历哪种
集合的时候，只要该集合内部实现这个接口即可。
3.集合的常见使用步骤
1）创建集合对象
2）创建元素对象
3）把元素添加到集合中
4）遍历集合
1.通过集合对象获取迭代器对象。
2.通过迭代器对象判断。
3.通过迭代器对象获取。
//存储字符串代码示例： import java.util.List; import java.util.ArrayList; import java.util.Iterator; public class Test{ public static void main(String[] args){ ArrayList al = new ArrayList(); al.add("黑马程序员——Java01"); al.add("黑马程序员——Java02"); al.add("黑马程序员——Java03"); al.add("黑马程序员——Java04"); for(Iterator iter = al.iterator();iter.hasNext();){ sop(iter.next()); } } public static void sop(Object obj){ System.out.println(obj); } } //存储自定义对象代码示例： import java.util.List; import java.util.ArrayList; import java.util.Iterator; class Student{ private String name; privateint age; Student(String name,int age){ this.name=name; this.age=age; } public String toString(){ return "姓名："+name+"...年龄："+age; } } public class Test{ public static void main(String[] args){ List list = new ArrayList(); list.add(new Student("黑马程序员——张三",23)); list.add(new Student("黑马程序员——李四",24)); list.add(new Student("黑马程序员——王五",25)); list.add(new Student("黑马程序员——赵六",26)); for(Iterator iter = list.iterator();iter.hasNext();){ sop(iter.next()); } } public static void sop(Object obj){ System.out.println(obj); } }
由于Iterator迭代器对数据的操作功能太少，只有对数据进行获取和删除等功能，所以就有了ListIterator迭代器。
ListIterator迭代器不仅可以对迭代器进行获取和删除，还可以对迭代器进行添加和修改。
ListIterator
无返回值add(E e)
将指定的元素插入列表（可选操作）。
布尔型hasNext()
以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回true）。布尔型 hasPrevious()
如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。Enext()
返回列表中的下一个元素。整数nextIndex()
返回对 next 的后续调用所返回元素的索引。Eprevious()
返回列表中的前一个元素。整数previousIndex()
返回对 previous 的后续调用所返回元素的索引。无返回值 remove()
从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。无返回值set(E e)
用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。
List集合的遍历方式有两种：一种是Iterator 一种是ListIterator
//ListIterator代码示例： import java.util.List; import java.util.ArrayList; import java.util.ListIterator; public class Test{ public static void main(String[] args){ List list = new ArrayList(); list.add("黑马程序员——Java01"); list.add("黑马程序员——Java02"); list.add("黑马程序员——Java03"); list.add("黑马程序员——Java04"); for(ListIterator listIter = list.listIterator();listIter.hasNext();){ String name = listIter.next(); sop(name); } } public static void sop(Object obj){ System.out.println(obj); } }
LinkedList特有方法：
无返回值addFirst(E e)
将指定元素插入此列表的开头。
无返回值addLast(E e)
将指定元素添加到此列表的结尾。
Eelement()
获取但不移除此列表的头（第一个元素）。
EgetFirst()
返回此列表的第一个元素。EgetLast()
返回此列表的最后一个元素。
布尔型offerFirst(E e)
在此列表的开头插入指定的元素。布尔型 offerLast(E e)
在此列表末尾插入指定的元素。
EremoveLast()
移除并返回此列表的最后一个元素。
EremoveLast()
移除并返回此列表的最后一个元素。
1.6出现了替换方法
布尔型offer(E e)
将指定元素添加到此列表的末尾（最后一个元素）。布尔型 offerFirst(E e)
在此列表的开头插入指定的元素。布尔型 offerLast(E e)
在此列表末尾插入指定的元素。Epeek()
获取但不移除此列表的头（第一个元素）。EpeekFirst()
获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。EpeekLast()
获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。Epoll()
获取并移除此列表的头（第一个元素）EpollFirst()
获取并移除此列表的第一个元素；如果此列表为空，则返回 null。EpollLast()
获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
Set ：元素是无序的（存入和取出顺序不一定一致），元素不可以重复。
booleanadd(E e)
如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。booleanaddAll(Collection<? extendsE> c)
如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。voidclear()
移除此 set 中的所有元素（可选操作）。booleancontains(Object o)
如果 set 包含指定的元素，则返回 true。booleancontainsAll(Collection<?> c)
如果此 set 包含指定 collection 的所有元素，则返回 true。booleanequals(Object o)
比较指定对象与此 set 的相等性。inthashCode()
返回 set 的哈希码值。booleanisEmpty()
如果 set 不包含元素，则返回 true。Iterator<E>iterator()
返回在此 set 中的元素上进行迭代的迭代器。booleanremove(Object o)
如果 set 中存在指定的元素，则将其移除（可选操作）。booleanremoveAll(Collection<?> c)
移除 set 中那些包含在指定 collection 中的元素（可选操作）。booleanretainAll(Collection<?> c)
仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。intsize()
返回 set 中的元素数（其容量）。Object[]toArray()
返回一个包含 set 中所有元素的数组。
<T> T[]toArray(T[] a)
返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。
HashSet 底层数据结构是哈希表。
布尔型 add(E e)
如果此 set 中尚未包含指定元素，则添加指定元素。无返回值clear()
从此 set 中移除所有元素。
布尔型contains(Object o)
如果此 set 包含指定元素，则返回 true。布尔型 isEmpty()
如果此 set 不包含任何元素，则返回 true。迭代器 iterator()
返回对此 set 中元素进行迭代的迭代器。布尔型 remove(Object o)
如果指定元素存在于此 set 中，则将其移除。整数size()
返回此 set 中的元素的数量（set 的容量）。
HashSet是如何保证元素唯一性的呢？
怎么重写hashCode()和equals()方法呢?是通过两个方法，hashCode和equals来完成。
如果元素hashCode值相同，才会判断equals是否为true。
如果元素的hashCode不同，不会调用equals方法。
hashCode():把对象的所有成员变量值相加即可。
如果是基本数据类型，就加值。如果是引用类型，就加哈希值。
return name.hasCode()+ age * 27;
equals(obj):先判断是否是同一类型的对象，再把传递进来的对象进行向下转型。再判断对象的内容是否相同。
if(!(obj instanceof Student)) ;
Student stu = (Student)obj;
return this.name.equals(stu.name) && this.age == stu.age;
所有成员变量的值比较。基本类型用==,引用类型用equals()。
注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。
TreeSet ：底层的数据结构是二叉树。线程是不同步的。
比较器comparator()
返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回null。
存储字符串对象代码示例：
import java.util.TreeSet;
import java.util.Iterator;
public class Test{
public static void main(String args[]){
TreeSet ts =new TreeSet();
ts.add("Java01");
ts.add("Java03");
ts.add("Java02");
ts.add("Java04");
for(Iterator it = ts.iterator();it.hasNext();){
sop(it.next());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
TreeSet集合两种实现排序方式：
自然排序(元素具备比较性)TreeSet的无参构造，要求对象所属的类实现Comparable接口。比较器排序(集合具备比较性)TreeSet的带参构造，要求构造方法接收一个实现了Comparator接口的对象。
Comparable
整数 compareTo(T o)
比较此对象与指定对象的顺序。
Comparator
整数compare(T o1, T o2)
比较用来排序的两个参数。布尔值equals(Object obj)
指示某个其他对象是否“等于”此 Comparator。
//Comparable存储自定义对象代码示例： /* 需求：往 TreeSet 集合中存储自定义对象学生。 想按照学生的年龄进行排序。 */ import java.util.Iterator; import java.util.TreeSet; class Student implements Comparable{ private String name; private int age; Student(String name,int age){ this.name=name; this.age=age; } public int compareTo(Object obj){ if(!(obj instanceof Student)){ throw new RuntimeException("不是学生对象"); } Student s = (Student)obj; int num = this.age-s.age; if(num==0) return this.name.comparTo(s.name); else return num; } public String toString(){ return name +"..."+age; } } public class Test{ public static void main(String[] args){ TreeSet ts =new TreeSet(); ts.add(new Student("黑马程序员——张三",21)); ts.add(new Student("黑马程序员——王五",23)); ts.add(new Student("黑马程序员——周七",19)); ts.add(new Student("黑马程序员——赵六",18)); for(Iterator iter = ts.iterator();iter.hasNext();){ sop(iter.next()); } } public static void sop(Object obj){ System.out.println(obj); } } //Comparator存储自定义对象代码示例： import java.util.Iterator; import java.util.TreeSet; import java.util.Comparator; class Student{ private String name; private int age; Student(String name,int age){ this.name=name; this.age=age; } public String getName(){ return name; } public int getAge(){ return age; } } class MyCompare implements Comparator{ public int compare(Object obj1,Object obj2){ Student s1 = (Student)obj1; Student s2 = (Student)obj2; int num =new Integer(s1.getAge()).compareTo(new Integer(s2.getAge())); if(num==0) return s1.getName().compareTo(s2.getName()); returnnum; } } public class Test{ public static void main(String[] args){ TreeSet ts = new TreeSet(new MyCompare()); ts.add(new Student("黑马程序员——张三",21)); ts.add(new Student("黑马程序员——王五",23)); ts.add(new Student("黑马程序员——周七",19)); ts.add(new Student("黑马程序员——赵六",18)); for(Iterator iter = ts.iterator();iter.hasNext();){ Student stu = (Student)iter.next(); sop(stu.getName()+"..."+stu.getAge()); } } public static void sop(Object obj){ System.out.println(obj); } }
Map<K,V>集合：该集合存储键值对。一对一往里存，而且要保证键的唯一性。
无返回值clear()
从此映射中移除所有映射关系（可选操作）。布尔型containsKey(Object key)
如果此映射包含指定键的映射关系，则返回 true。布尔型containsValue(Object value)
如果此映射将一个或多个键映射到指定值，则返回 true。Set<Map.Entry<K,V>>entrySet()
返回此映射中包含的映射关系的Set视图。布尔型equals(Object o)
比较指定的对象与此映射是否相等。Vget(Object key)
返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回null。整数 hashCode()
返回此映射的哈希码值。布尔型 isEmpty()
如果此映射未包含键-值映射关系，则返回 true。Set<K>keySet()
返回此映射中包含的键的Set视图。Vput(K key,V value)
将指定的值与此映射中的指定键关联（可选操作）。无返回值 putAll(Map<? extendsK,? extendsV> m)
从指定映射中将所有映射关系复制到此映射中（可选操作）。Vremove(Object key)
如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。整数size()
返回此映射中的键-值映射关系数。
Map
|--HashMap：基于哈希表的Map接口的实现。此实现提供所有可选的映射操作，并允许使用null 值和null键。
（除了非同步和允许使用null 之外，HashMap 类与Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 将 Hashtable替代，JDK1.2.效率高。
|--TreeMap：基于红黑树（Red-Black tree）的 NavigableMap 实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator（比较器） 进行排序，具体取决于使用的构造方法。
和Set很像。其实大家，Set底层就是使用了Map集合。线程不同步。可以用于给Map集合中的键进行排序。
<span style="color:#000000;">import java.util.Map; import java.util.HashMap; import java.util.Collection; public class Test{ public static void main(String[] args){ Map<String,String> map = new HashMap<String,String>(); //添加元素 map.put("01","黑马程序员——张三"); map.put("02","黑马程序员——李四"); map.put("03","黑马程序员——王五"); map.put("null","黑马程序员——赵六");/*可以存入空值，但是不常见，所以可以通过get方法的返回值，null来判断一个键的不存在*/ sop(map.containsKey("02")); sop(map.get("null")); if(map.get("null")!=null) map.remove(map.get("null")); else sop("Value to Null"); //可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。 sop(map.remove("02"));/*返回值是删除键的值*/ sop(map.containsKey("02")); sop("-----------"); //获取map集合中所有的值。 Collection<String> coll = map.values(); sop(coll); map.put("01","zhangsan1"); /*如果加入的键和值都相同的话，返回null*/ map.put("01","zhangsan2");/*当添加相同的键而值不同，则后添加的值会覆盖原有值，并且返回原有值*/ } public static void sop(Object obj){ System.out.println(obj); } } </span>(1)Map是一个键值对形式的集合。它的元素都是由键和值组成。
(2)Map和Collection的区别?
A:Map 是由键值对组成的集合,Map的键是唯一的,值可以重复。
B:Collection 是有单列数据组成的集合,它的子类List是可以重复的，Set是唯一的。
(3)HashMap和Hashtable的区别?
HashMap:线程不安全，效率高。允许null键和值。
Hashtable:线程安全，效率低。不允许null键和值。
Map集合的两种取出方法
1. Set<k> keySet：将Map中所有的键存入到Set集合，因为Set具备迭代器。
所以可以迭代方式取出所有的键，再根据get方法获取每个键对应的值
Map集合取出原理：将Map集合转化成Set集合，再通过迭代器取出。
2.Set<Map.Entry<k,v>> entrySet:将Map集合中的映射关系存入到Set集合中，而这个关系的数据类型就是：Map.Entry
/* 1、Set<K> keySet() 将Map中所有的键存入到Set集合，因为set具备迭代器。 所有可以迭代方式取出所有的键，再根据get方法，获取每一个键对应的值 */ import java.util.Map; import java.util.HashMap; import java.util.Collection; import java.util.Iterator; import java.util.Set; public class Test{ public static void main(String[] args){ Map<String,String> map = new HashMap<String,String>(); map.put("01","黑马程序员——张三"); map.put("02","黑马程序员——李四"); map.put("03","黑马程序员——王五"); map.put("04","黑马程序员——赵六"); Set<String> keySet = map.keySet(); for(Iterator<String> iter = keySet.iterator();iter.hasNext();){ String key = iter.next(); String value = map.get(iter.next()); sop("key:"+key+"...value:"+value); } } public static void sop(Object obj){ System.out.println(obj); } }
Entry 接口方法
布尔型equals(Object o)
比较指定对象与此项的相等性。KgetKey()
返回与此项对应的键。VgetValue()
返回与此项对应的值。整数hashCode()
返回此映射项的哈希码值。VsetValue(V value)
用指定的值替换与此项对应的值（可选操作）。
Set<Map.Entry<K,V>> entrySet() 返回此映射所包含的映射关系的 Set 视图。
将Map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry
entrySet():将Map集合中的映射关系取出。
这个关系就是 Map.Entry 类型
那么关系对象 Map.Entry 获取到后，就可以通过，Map.Entry中getKey和getValue方法获取关系中的键和值
Map.Entry 其实Entry也是一个接口，它是接口中的一个内部接口。
代码示例：
<span style="color:#000000;">import java.util.Map; import java.util.HashMap; import java.util.Collection; import java.util.Iterator; import java.util.Set; public class Test{ public static void main(String[] args){ Map<String,String> map = new HashMap<String,String>(); map.put("01","黑马程序员——张三"); map.put("02","黑马程序员——李四"); map.put("03","黑马程序员——王五"); map.put("04","黑马程序员——赵六"); Set<Map.Entry<String,String>> entrySet = map.entrySet(); for(Iterator<Map.Entry<String,String>> iter = entrySet.iterator();iter.hasNext();){ Map.Entry<String,String>me = iter.next(); String key = me.getKey(); String value =me.getValue(); sop("key:"+key+"...value:"+value); } } public static void sop(Object obj){ System.out.println(obj); } } </span>
集合体系
Collection(单列)
List(有序,可重复)
Set(无序,唯一)
ArrayList： 底层数据结构是数组，查询快，增删慢。线程不同步，效率高。
LinkedList：底层数据结构是链表，查询慢，增删快。线程不同步，效率高。
Vector： 底层数据结构是数组，查询快，增删慢。线程同步，效率低。
HashSet：底层数据结构是哈希表。线程不同步，效率高。 怎么保证唯一性的呢?它依赖两个方法：hashCode()和equals()顺序：首先判断hashCode()值是否相同。同：继续走equals()，看返回值如果true：就不添加到集合。如果false：就添加到集合。不同：就添加到集合。
TreeSet：底层数据结构是二叉树。 线程不同步，效率高。 怎么保证唯一性的呢?是根据返回是否是0。
怎么保证排序的呢?两种方式
一、自然排序(元素具备比较性) 实现Comparable接口
二、比较器排序(集合具备比较性) 实现Comparator接口
Map(双列 底层结构是针对键有效，跟值无关)
HashMap：底层数据结构是哈希表。线程不同步，效率高。
怎么保证唯一性的呢?
它依赖两个方法：hashCode()和equals()顺序：首先判断hashCode()值是否相同。同：继续走equals()，看返回值如果true：就不添加到集合。如果false：就添加到集合。不同：就添加到集合。
Hashtable：底层数据结构是哈希表。线程安全，效率低。
怎么保证唯一性的呢?
它依赖两个方法：hashCode()和equals()顺序：首先判断hashCode()值是否相同。同：继续走equals()，看返回值如果true：就不添加到集合。如果false：就添加到集合。不同：就添加到集合。
TreeMap：底层数据结构是二叉树。线程不同步，效率高。
怎么保证唯一性的呢?是根据返回是否是0。
怎么保证排序的呢?两种方式自然排序(元素具备比较性)实现Comparable接口比较器排序(集合具备比较性)实现Comparator接口
集合常见应用功能
(添加功能，判断功能，删除功能，获取功能，长度功能)
集合那么多什么时候该用谁?
是否键值对?
是：Map
是否对键排序?
是：TreeMap
否：HashMap
不懂的情况下，使用HashMap。
否：Collection
是否唯一?
是：Set
是否对元素进行排序?
是：TreeSet
是否需要有序？
是：LinkedSet
否：HashSet
不懂的情况下，使用HashSet
否：List
是否要安全?
是：Vector(真正开发中也不用)
否：ArrayList，LinkedList
注意：查询多：ArrayList
增删多：LinkedList
不懂的情况下，使用ArrayList
583
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
