集合类的由来：
对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。
就使用集合容器进行存储。
集合特点：
1，用于存储对象的容器。
2，集合的长度是可变的。
3，集合中不可以存储基本数据类型值。
集合容器因为内部的数据结构不同，有多种具体容器。
不断的向上抽取，就形成了集合框架。
框架的顶层Collection接口：
Collection的常见方法：
1，添加
boolean add(Object obj):
c1.add("abc1");
boolean addAll(Collection coll):
c1.addAll(c2);//将c2中的元素添加到c1中。
2，删除
boolean remove(object obj)://删除单个元素
boolean removeAll(Collection coll);
boolean b = c1.removeAll(c2);//将两个集合中的相同元素从调用removeAll的集合中删除。
void clear();//清空元素
3，判断：
boolean contains(object obj)://判断集合中是否有这个元素
boolean containsAll(Colllection coll);//判断集合中是否包含另一个集合中的元素
boolean isEmpty():判断集合中是否有元素。
4，获取：
int size()://获取集合中元素的长度（个数）
Iterator iterator():取出元素的方式：迭代器。
该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
所以该迭代器对象是在容器中进行内部实现的。
对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，也就是iterator方法。
Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
其实就是抓娃娃游戏机中的夹子！
//使用了Collection中的iterator()方法。 调用集合中的迭代器方法，是为了获取集合中的迭代器对象。
第一种写法：
Iterator it = coll.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
第二种写法：如果不对it对象进行操作，可这样写，节省内存
for(Iterator it = coll.iterator(); it.hasNext(); ){
System.out.println(it.next());
}
5，其他：
boolean retainAll(Collection coll);取交集。
c1.retainAll(c2);//取交集，保留和指定的集合相同的元素，而删除不同的元素。
//和removeAll功能相反
Object[] toArray():将集合转成数组。
Collection
|--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。
|--Set：元素不能重复,无序。
List:特有的常见方法：有一个共性特点就是都可以操作角标。
1，添加
void add(index,element);//在指定位置插入元素
boolean addAll(index,collection);//在指定位置插入一个集合
2，删除；
Object remove(index)://删除指定位置元素
3，修改：
Object set(index,element);//用指定元素替换列表中指定位置的元素
4，获取：
Object get(index);//返回列表中指定位置的元素。
int indexOf(object);//返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
int lastIndexOf(object);//返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
List subList(from,to);//返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
list集合是可以完成对元素的增删改查。
List:
|--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！
|--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。
|--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。
list集合具有的迭代器
ListIterator it = list.listIterator();//获取列表迭代器对象
//它可以实现在迭代过程中完成对元素的增删改查。
//注意：只有list集合具备该迭代功能.
ListIterator 的方法：
void add(E e)
将指定的元素插入列表（可选操作）。
boolean hasNext()
以正向遍历列表时，如果列表迭代器有多个元素，则返回true
（换句话说，如果next 返回一个元素而不是抛出异常，则返回true）。
boolean hasPrevious()
如果以逆向遍历列表，列表迭代器有多个元素，则返回true。
E next()
返回列表中的下一个元素。
int nextIndex()
返回对next的后续调用所返回元素的索引。
E previous()
返回列表中的前一个元素。
int previousIndex()
返回对previous的后续调用所返回元素的索引。
void remove()
从列表中移除由next或previous返回的最后一个元素（可选操作）。
void set(E e)
用指定元素替换 next或previous返回的最后一个元素（可选操作）。
Iterator it = list.iterator();
while(it.hasNext()){
Object obj = it.next();//java.util.ConcurrentModificationException
//在迭代器过程中，不要使用集合操作元素，容易出现异常。
//可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作。
if(obj.equals("abc2")){
list.add("abc9");
}
else
System.out.println("next:"+obj);
}
System.out.println(list);
Vector的改变：
public static void main(String[] args) {
Vector v = new Vector();
v.addElement("abc1");
v.addElement("abc2");
v.addElement("abc3");
v.addElement("abc4");
\\两种迭代方法，改良后都用第二种
Enumeration en = v.elements();
while(en.hasMoreElements()){
System.out.println("nextelment:"+en.nextElement());
}
Iterator it = v.iterator();
while(it.hasNext()){
System.out.println("next:"+it.next());
}
}
LinkedList:
特有的方法：
addFirst();
addLast():
jdk1.6之后增加了：
offerFirst();
offetLast();
getFirst();.//获取但不移除，如果链表为空，抛出NoSuchElementException.
getLast();
jdk1.6之后增加了：
peekFirst();//获取但不移除，如果链表为空，返回null.
peekLast():
removeFirst();//获取并移除，如果链表为空，抛出NoSuchElementException.
removeLast();
jdk1.6之后增加了：
pollFirst();//获取并移除，如果链表为空，返回null.
pollLast();
/*
* 请使用LinkedList来模拟一个堆栈或者队列数据结构。
*
* 堆栈：先进后出 First In Last Out FILO //只要将如下代码中addLast换成addFirst就变成堆栈
*
* 队列：先进先出 First In First Out FIFO
*
* 我们应该描述这样一个容器，给使用提供一个容器对象完成这两种结构中的一种。
*/
public class DuiLie {
private LinkedList link;
public DuiLie() {
link = new LinkedList();
}
/**
* 队列的添加元素的功能。
*/
public void myAdd(Object obj) {
link.addLast(obj);
}
public Object myGet() {
return link.removeFirst();
}
public boolean isNull() {
return link.isEmpty();
}
}
ArrayList注意事项
public static void main(String[] args) {
Person p1 = new Person("lisi1",21);
ArrayList al = new ArrayList();
al.add(p1);
al.add(new Person("lisi2",22));
al.add(new Person("lisi3",23));
al.add(new Person("lisi4",24));
Iterator it = al.iterator();
while(it.hasNext()){
// System.out.println(((Person) it.next()).getName()+"::"+((Person) it.next()).getAge());
Person p = (Person) it.next();//遍历时next()只能出现一次
System.out.println(p.getName()+"--"+p.getAge());
}
Set:元素不可以重复，是无序。
Set接口中的方法和Collection一致。
|--HashSet: 内部数据结构是哈希表 ，是不同步的。
hashset存储的元素是无序的，且元素唯一。
linkedhashset是hashset的子类，它存储的元素是有序的，且元素唯一。
如何保证该集合的元素唯一性呢？
是通过对象的hashCode和equals方法来完成对象唯一性的。
如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。
记住：如果相同元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。
建立对象判断是否相同的依据。
**|--TreeSet:可以对Set集合中的元素进行排序。是不同步的。 **
判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。
TreeSet对元素进行排序的方式一：
让元素自身具备比较功能，元素需要实现Comparable接口。覆盖compareTo方法。
例如：
//自己重写compareTo方法，根据年龄大小排序
public int compareTo(Object o) {
Person p = (Person)o;
int temp = this.age-p.age;
return temp==0?this.name.compareTo(p.name):temp;
// int temp = this.name.compareTo(p.name);
// return temp==0?this.age-p.age:temp;
/*
if(this.age>p.age)
return 1;
if(this.age<p.age)
return -1;
else{
return this.name.compareTo(p.name);
}
*/
}
如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？
可以使用TreeSet集合第二种排序方式二：
让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。将该类对象作为参数传递给TreeSet集合的构造函数。
TreeSet ts = new TreeSet(new ComparatorByName());
TreeSet ts = new TreeSet(new ComparatorByLength());
import java.util.Comparator;
import cn.itcast.p.bean.Person;
/**
* 创建了一个根据Person类的name进行排序的比较器。
*/
public class ComparatorByName implements Comparator {
@Override
public int compare(Object o1, Object o2) {
Person p1 = (Person)o1;
Person p2 = (Person)o2;
int temp = p1.getName().compareTo(p2.getName());
return temp==0?p1.getAge()-p2.getAge(): temp;
// return 1;//有序。
}
import java.util.Comparator;
public class ComparatorByLength implements Comparator {
@Override
public int compare(Object o1, Object o2) {
String s1 = (String)o1;
String s2 = (String)o2;
int temp = s1.length()-s2.length();
return temp==0? s1.compareTo(s2): temp;
}
}
TreeSet内部是一个二叉树结构。如果想要让该集合变成有序的，则只要改写compare方法，直接返回一个正数就行，如：return 1；如果返回一个负数在，就是倒序排列的。此时该集合能够存相同元素。
![]()
二叉树.jpg
if(this.hashCode()== obj.hashCode() && this.equals(obj))
哈希表确定元素是否相同
1，判断的是两个元素的哈希值是否相同。
如果相同，在判断两个对象的内容是否相同。
2，判断哈希值相同，其实判断的是对象的hashCode的方法。判断内容相同，用的是equals方法。
注意：如果哈希值不同，是不需要判断equals。
集合的一些技巧：
需要唯一吗？
需要：Set
需要制定顺序：
需要： TreeSet
不需要：HashSet
但是想要一个和存储一致的顺序(有序):LinkedHashSet
不需要：List
需要频繁增删吗？
需要：LinkedList
不需要：ArrayList
如何记录每一个容器的结构和所属体系呢？
看名字！
List
|--ArrayList
|--LinkedList
Set
|--HashSet
|--TreeSet
后缀名就是该集合所属的体系。
前缀名就是该集合的数据结构。
看到array：就要想到数组，就要想到查询快，有角标.
看到link：就要想到链表，就要想到增删快，就要想要 add get remove+frist last的方法
看到hash:就要想到哈希表，就要想到唯一性，就要想到元素需要覆盖hashcode方法和equals方法。
看到tree：就要想到二叉树，就要想要排序，就要想到两个接口Comparable，Comparator 。
而且通常这些常用的集合容器都是不同步的。
Map：一次添加一对元素。Collection 一次添加一个元素。
Map也称为双列集合，Collection集合称为单列集合。
其实map集合中存储的就是键值对。
map集合中必须保证键的唯一性。
常用方法：
1，添加。
value put(key,value):返回前一个和key关联的值，如果没有返回null.
2，删除。
void clear():清空map集合。
value remove(key):根据指定的key翻出这个键值对。
3，判断。
boolean containsKey(key):
boolean containsValue(value):
boolean isEmpty();
4，获取。
value get(key):通过键获取值，如果没有该键返回null。当然可以通过返回null，来判断是否包含指定键。
int size(): 获取键值对的个数。
Map集合的两种迭代方式
Set<K> keySet()方法，返回此映射中包含的键的 Set视图。
第一种：
//取出map中的所有元素。
//原理，通过keySet方法获取map中所有的键所在的Set集合，在通过Set的迭代器获取到每一个键，
//在对每一个键通过map集合的get方法获取其对应的值即可。
/*
Set<Integer> keySet = map.keySet();
Iterator<Integer> it = keySet.iterator();
while(it.hasNext()){
Integer key = it.next();
String value = map.get(key);
System.out.println(key+":"+value);
}
entrySet()方法：返回值为：Set<Map.Entry<K,V>>
返回此映射中包含的映射关系的 Set视图。
Map.Entry<K,V>中的方法：
boolean equals(Object o)：比较指定对象与此项的相等性。
K getKey()： 返回与此项对应的键。
V getValue()： 返回与此项对应的值。
int hashCode()： 返回此映射项的哈希码值。
V setValue(V value)： 用指定的值替换与此项对应的值（可选操作）。
/*
第二种
* 通过Map转成set就可以迭代。
* 找到了另一个方法。entrySet。
* 该方法将键和值的映射关系作为对象存储到
了Set集合中，而这个映射关系的类型就是Map.Entry类型(结婚证)
*
*
*/
Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
Iterator<Map.Entry<Integer, String>> it = entrySet.iterator();
while(it.hasNext()){
Map.Entry<Integer, String> me = it.next();
Integer key = me.getKey();
String value = me.getValue();
System.out.println(key+"::::"+value);
}
Map.Entry<k,v>
这里的Entry是一个静态内部接口，大致结构看如下代码：
interface MyMap{
public static interface MyEntry{//内部接口
void get();
}
}
class MyDemo implements MyMap.MyEntry{
public void get(){}
}
** Collection<V> values():返回此映射中包含的值的 Collection视图。**
Collection<String> values = map.values();
Iterator<String> it2 = values.iterator();
while(it2.hasNext()){
System.out.println(it2.next());
}
Map常用的子类：
|--Hashtable :内部结构是哈希表，是同步的。不允许null作为键，null作为值。
Properties：用来存储键值对型的配置文件的信息，可以和IO技术相结合。
HashMap : 内部结构是哈希表，不是同步的。允许null作为键，null作为值。
由于内部结构是哈希表结构，所有判断元素是否相同的依据依然是hashcode()和equals()方法。这里会对键：key进行判断。key不能有重复元素
TreeMap : 内部结构是二叉树，不是同步的。可以对Map集合中的键进行排序。
内部结构是二叉树，可进行排序。方式依然是二种：
- 对象自身实现comparable接口，覆盖compareTo方法。
- 让集合自身具备比较功能，定义一个类实现comparator接口，覆盖compare方法，将该类对象作为参数传递给TreeMap的构造函数。
