思考为什么要引入容器这个概念？
Java有多种方式保存对象（应该是对象的引用），例如使用数组时保存一组对象中的最有效的方式，如果你想保存一组基本类型的数据，也推荐使用这种方式，但大家知道数组是具有固定尺寸的，你必须事先知道你要需要多少个对象。但是在一般的情况中，你在写程序中并不知道将需要多少个对象，或者是否需要更加复杂的方式来存储对象，因此数组尺寸固定很不爽！
为了解决上述问题，引入了容器的概念。容器提供了完善的方法来保存对象，你可以使用这些工具来解决数量惊人的问题。Java容器类可以自动调整自己的尺寸，因此与数组不同，你可以将任意数量的对象放到容器中，并不担心容器设置为多大。
aaarticlea/png;base64,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" alt="" />
集合特点：
1，用于存储对象的容器。
2，集合的长度是可变的。
3，集合中不可以存储基本数据类型值。
java容器类库用途是保存对象。分为2类：
1. Collection
一个独立元素的序列，这些元素都服从一条或多条规则。List必须按照插入的顺序保存元素，Set不能有重复元素。Queue按照排队规则来确定对象产生的顺序（通常与插入的顺序相同）。
2. Map
一组成对的键值对对象，允许使用键来查找值，将数字和对象关联到一起。映射表允许我们使用另一个对象来查找某个对象，也被称为关联数组或字典。Map很强大
List类型
List接口在Collection的基础上添加了大量的方法，使得可以在List中间插入和移除元素。
1 ArrayList和 LinkedList
都按照被插入的顺序保存元素，区别在于执行某些操作时的性能。且LinkedList包含的操作也多于ArrayList.
（1）ArrayList ：优势随机访问元素比较快，有连续的数组空间，但是在List的中间插入和移除元素时较慢，需要大量的移动内部的元素。
你可以把ArrayList 当做“可以自动扩充自身的数组”来看待，使用ArrayList也相当简单：创建一个实例，用add（）插入对象；然后用get（）访问这些对象，此时需要索引，就像数组一样，但是不需要方括号。ArrayList还有一个size()方法，使你知道有多少个元素添加进来，从而不会不小心因索引越界而引发错误。
（2）LinkedList：在LinkedList中间插入删除较快，提供优化的顺序访问。随机访问时较慢，特性集较ArrayList 大。各种Queue以及栈的行为，由LinkedList提供支持。
Set类型
1.HashSet TreeSet LinkedHashSet
输出显示在Set中，每个相同的项只保存一次，但存储的方式不同：
(1) Hashset存储方式复杂，但保证了最快的获取速度
（2）TreeSet按照升序保存对象
（3）LinkedHashSet按照添加的顺序保存对象
Map
可以使用键来查找对象，类似于数组下标。Map.put(key,value)插入数据，Map.get(key)查找数据。键要求唯一。存储方式不是顺序存储，速度快。不必指定Map的尺寸，因为它自己会自动的调整。
（1）HashMap使用最快的查找技术，存储无顺序。
（2）TreeMap按照比较结果升序保存。
（3）LinkedHashMap按照插入顺序保存键，同时保留HashMap的查询速度。
迭代器（也是一种设计模式）
容器缺点：使用容器，必须对容器的确切类型进行编程，但若像更换或扩展至其他容器，必须重写代码。迭代器可以解决这个问题，实现代码的重用。它是一个对象，它的工作是遍历并选择序列中的对象，而客户端程序员不必知道或关心该序列底层的结构。它是轻量级对象，创建的代价小。
因此经常对迭代器有些奇怪的限制：
1)使用方法Iterator()要求容器返回一个Iterator。Iterator将准备好返回序列中的第一个元素。
2)使用next()获得序列的下一个元素。
3)使用hasNext()检查序列中是否还有元素。
4)使用remove()将迭代器新近返回的元素删除。
迭代器能够将遍历序列的操作与序列底层的结构分离，它统一了对容器的访问方式，这是它的威力所在。
框架的顶层Collection接口：
Collection的常见方法：
1，添加。
boolean add(Object obj):
boolean addAll(Collection coll):
2，删除。
boolean remove(object obj):
boolean removeAll(Collection coll);
void clear();
3，判断：
boolean contains(object obj):
boolean containsAll(Colllection coll);
boolean isEmpty():判断集合中是否有元素。
4，获取：
int size():
Iterator iterator():取出元素的方式：迭代器。
该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
所以该迭代器对象是在容器中进行内部实现的。
对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，
也就是iterator方法。
Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
5，其他：
boolean retainAll(Collection coll);取交集。
Object[] toArray():将集合转成数组。
package cn.itcast.p3.collection.demo; import java.util.ArrayList;
import java.util.Collection; public class CollectionDemo { /**
* @param args
*/
public static void main(String[] args) {
/*Collection coll = new ArrayList();
show(coll);
*/
Collection c1 = new ArrayList();
Collection c2 = new ArrayList();
show(c1,c2); } public static void show(Collection c1,Collection c2){ //给c1添加元素。
c1.add("abc1");
c1.add("abc2");
c1.add("abc3");
c1.add("abc4"); //给c2添加元素。
c2.add("abc2");
c2.add("abc5");
c2.add("abc6"); System.out.println("c1:"+c1);//c1:[abc1, abc2, abc3, abc4]
System.out.println("c2:"+c2);//c2:[abc2, abc5, abc6] //将c2中的元素添加到c1集合中,添加一堆
c1.addAll(c2);
System.out.println(c1);//[abc1, abc2, abc3, abc4, abc2, abc5, abc6] //演示removeAll
//将两个集合中的相同元素从调用removeAll的集合中删除,从c1中删除c1和c2相同的元素
/* boolean b = c1.removeAll(c2);
System.out.println("removeAll:"+b);
System.out.println("c1"+c1);//c1[abc1, abc3, abc4]
*/
//演示containsAll，c1集合中是否包含C2中的所有元素，包含返回true
boolean b1 = c1.containsAll(c2);
System.out.println("containsAll:"+b1);
//演示retainAll 取交集，保留和指定的集合相同的元素，而删除不同的元素。和removeAll功能相反 。
//c2:[abc2, abc5, abc6],
//addAll后的C1:[abc1, abc2, abc3, abc4, abc2, abc5, abc6]
// boolean b = c1.retainAll(c2);
// System.out.println("retainAll:"+b);
// System.out.println("c1:"+c1);//c1:[abc2, abc2, abc5, abc6]
}
/**
* 测试集合 Collection集合中的方法
* @param coll
*/
public static void show(Collection coll){ //1,添加元素。add.
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
System.out.println(coll); //2，删除元素。remove
if(coll.contains("abc2")){
coll.remove("abc2");//会改变集合的长度
}
//清空集合
//coll.clear();//清空集合中的元素，但是集合还在，集合为[]空
System.out.println(coll.contains("abc3"));
System.out.println(coll); } }
Collection集合的遍历：使用Iterator
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator; public class IteratorDemo { /**
* java.util.NoSuchElementException
*/
public static void main(String[] args) { Collection coll = new ArrayList();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");
System.out.println(coll);//[abc1, abc2, abc3, abc4]
//使用了Collection中的iterator()方法。 调用集合中的迭代器方法，是为了获取集合中的迭代器对象。
Iterator it = coll.iterator();
while(it.hasNext()){
System.out.println(it.next());
} /* for(Iterator it = coll.iterator(); it.hasNext(); ){
System.out.println(it.next());
}*/ } }
Collection
|--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。
|--Set：元素不能重复,无序。
import java.util.ArrayList;
import java.util.List;
/**
*
List:特有的常见方法：有一个共性特点就是都可以操作角标。 1，添加
void add(index,element);
void add(index,collection); 2，删除；
Object remove(index): 3，修改：
Object set(index,element); 4，获取：
Object get(index);
int indexOf(object);获取指定元素的索引
int lastIndexOf(object);
List subList(from,to);
*
*
*/
public class ListDemo { /**
* @param args
*/
public static void main(String[] args) {
List list = new ArrayList();
show(list);
} public static void show(List list) { //添加元素
list.add("abc1");
list.add("abc2");
list.add("abc3");
System.out.println(list);//[abc1, abc2, abc3] //插入元素,在列表的指定位置插入元素
list.add(1,"abc9"); System.out.println(list);//[abc1, abc9, abc2, abc3] //删除元素。
System.out.println("remove:"+list.remove(2));//remove:abc2 //修改元素。
System.out.println("set:"+list.set(1, "abc8"));//set:abc9 //获取元素。
System.out.println("get:"+list.get(0));//get:abc1
System.out.println(list);//[abc1, abc8, abc3]
//获取子列表。
System.out.println("sublist:"+list.subList(1, 3));//sublist:[abc8, abc3]
//根据对象获取位置
System.out.println(list.indexOf("abc8"));//
System.out.println(list.lastIndexOf("abc3"));//
System.out.println(list);//[abc1, abc8, abc3]
}
}
List的遍历方式以及使用，使用Iterator接口的子接口ListIterator来完成在迭代中对集合元素进行的增删改查，不会抛出并发修改的异常
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator; public class ListDemo2 { /**
* @param args
*/
public static void main(String[] args) { List list = new ArrayList();
showListIterator(list);
} /**
* 可以使用Iterator接口的子接口ListIterator来完成在迭代中对集合元素进行的增删改查，不会抛出并发修改的异常
* 线程只操作迭代对象，不修改集合，这就不是并发的操作，是迭代对象ListIterator中自己的增删改方法，而不是调用集合中的方法
* @param list
*/
public static void showListIterator(List list){
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
list.add("abc5");
System.out.println("list:"+list); ListIterator it = list.listIterator();
while(it.hasNext()){
Object obj = it.next();
if(obj.equals("abc4")){
//it.add("abc9");//不是list.add
it.set("abc9");
}
else
System.out.print(" "+obj);
}
System.out.print("\n");
System.out.println("********************************");
//System.out.println("hasnext:"+it.hasNext());
//System.out.println("hasPrevious:"+it.hasPrevious());
//System.out.println("previous:"+it.previous());
//逆向遍历
while(it.hasPrevious()){
System.out.print(" "+it.previous());//输出 abc5 abc9 abc3 abc2 abc1
}
System.out.print("\n");
System.out.println("********************************");
System.out.println(list); }
/**
* java.util.ConcurrentModificationException:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常
* 集合和迭代器同时对元素进行修改，就会产生异常，一个线程对collection集合迭代，另一个对Collection进行修改的时候，
* 就会出现上面的异常
* @param list
*/
public static void showConcurrentModificationException(List list){
list.add("abc1");
list.add("abc2");
list.add("abc3");
System.out.println("list:"+list); 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); }
/**
* List集合的遍历，下面两种方法都可以
* @param list
*/
public static void show(List list) { list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
//第一种使用iterator
Iterator it = list.iterator();
while(it.hasNext()){
System.out.println("next:"+it.next());
} //list特有的取出元素的方式之一。 for(int x=0; x<list.size(); x++){
System.out.println("get:"+list.get(x));
}
} }
List:
|--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！
|--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。
|--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。
Vector：
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector; public class VectorDemo { /**Enumeration枚举接口的功能和Iterator迭代器接口的功能是重复的，Iterator接口添加了一个可选的移除方法，并使用较短的方法名
* java1.2开始，使用Iterator替代Enumeration
* @param args
*/
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());
} } }
ArrayList
package cn.itcast.p.bean;
public class Person {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString(){
return name+":"+age;
}
}
}
import java.util.ArrayList;
import java.util.Iterator; import cn.itcast.p.bean.Person; public class ArrayListTest { /**
* @param args
*/
public static void main(String[] args) {
ArrayList<Person> al = new ArrayList<Person>();
al.add(new Person("listP1",21));
al.add(new Person("listP1",22));
al.add(new Person("listP2",23));
al.add(new Person("listP3",24)); System.out.println(al);//[listP1:21, listP1:22, listP2:23, listP3:24] Iterator it = al.iterator();
while(it.hasNext()){
Person p = (Person) it.next();
System.out.println(p.getName()+"--"+p.getAge());
}
}
}
输出：
[listP1:21, listP1:22, listP2:23, listP3:24]
listP1--21
listP1--22
listP2--23
listP3--24
LinkedList:
addFirst();
addLast():
jdk1.6
offerFirst();
offetLast();
getFirst();.//获取但不移除，如果链表为空，抛出NoSuchElementException.
getLast();
jdk1.6
peekFirst();//获取但不移除，如果链表为空，返回null.
peekLast():
removeFirst();//获取并移除，如果链表为空，抛出NoSuchElementException.
removeLast();
jdk1.6
pollFirst();//获取并移除，如果链表为空，返回null.
pollLast();
import java.util.Iterator;
import java.util.LinkedList; public class LinkedListDemo { /**
* @param args
*/
public static void main(String[] args) { LinkedList link = new LinkedList(); link.addFirst("abc1");
link.addFirst("abc2");
link.addFirst("abc3");
link.addFirst("abc4");
System.out.println(link); System.out.println("使用getFirst---"+link.getFirst());//获取第一个但不删除。当链表为空的时候会抛出抛出NoSuchElementException
System.out.println("使用getLast---"+link.getLast());//获取最后一个元素，当链表为空的时候会抛出抛出NoSuchElementException
System.out.println("使用peekFirst---"+link.peekFirst());//获取第一个元素，当链表为为空的时候不会报异常
System.out.println("使用peekLast---"+link.peekLast());//获取最后一个元素 // System.out.println("使用link.removeFirst---"+link.removeFirst());//获取第一个元素但是会删除。abc4，当链表为空的时候会抛出抛出NoSuchElementException
// System.out.println("使用removeFirst---"+link.removeFirst());//abc3
// System.out.println("使用removeLast---"+link.removeLast());//获取最后一个元素，并移除abc1
System.out.println("使用pollFirst---"+link.pollFirst());//获取第一个元素并从集合中移除（1.6，出来的新方法，当链表为为空的时候不会报异常）
System.out.println("使用pollFirst---"+link.pollFirst());
System.out.println("使用pollLast---"+link.pollLast());//获取最后一个元素并从集合中移除
System.out.println("使用pollLast---"+link.pollLast());
// while(!link.isEmpty()){
// System.out.println(link.removeLast());
// } System.out.println(link);
// Iterator it = link.iterator();
// while(it.hasNext()){
// System.out.println(it.next());
// }
} }
Set:元素不可以重复，是无序。
Set接口中的方法和Collection一致。
|--HashSet: 内部数据结构是哈希表 ，是不同步的。
如何保证该集合的元素唯一性呢？
是通过对象的hashCode和equals方法来完成对象唯一性的。
如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。
记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。
建立对象判断是否相同的依据。
如果HashSet不覆盖equal和hashCode方法的话，默认的是使用Object中的equal和hashCode方法
Object中的equal方法比较地址的，而不是比较内容，如果添加重复的对象，地址不同，就会认为没有重复的对象
所以比较对象是否相同，必须覆盖equal和hashCode方法
package cn.itcast.p.bean;
public class Person /*extends Object*/ {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString(){
return name+":"+age;
}
@Override
public boolean equals(Object obj) {//判断人的内容是否相同
System.out.println("调用了equals方法---------------");
if(this == obj) //this只是否为Person对象
return true;
if(!(obj instanceof Person)){
throw new ClassCastException("类型转化错误！");
}
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;//字符创name的内容相同吗
}
@Override
public int hashCode() { //判断人的hash值是否相同
System.out.println("调用了hashCode方法---------------");
return name.hashCode()+ age;
}
}
往hashSet里面添加元素，进行遍历：
package cn.itcast.p4.hashset.test; import java.util.HashSet;
import java.util.Iterator; import cn.itcast.p.bean.Person; /*
* 往hashSet集合中存储Person对象。如果姓名和年龄相同，视为同一个人。视为相同元素。
*/
public class HashSetTest { /**
* @param args
*/
public static void main(String[] args) { HashSet hs = new HashSet(); /*
* HashSet集合数据结构是哈希表，所以存储元素的时候，我们需要覆盖hashCode方法和equal方法，来确保放入的对象的唯一性
* 使用的元素的hashCode方法来确定位置，如果位置相同，
* 在通过元素的equals来确定是否相同,如果相同的话，就不往set里面存
*/ hs.add(new Person("lisi4",24));
hs.add(new Person("lisi7",27));
hs.add(new Person("lisi1",21));
hs.add(new Person("lisi9",29));
hs.add(new Person("lisi7",27)); Iterator it = hs.iterator(); while(it.hasNext()){
Person p = (Person)it.next();
//System.out.println(p);
System.out.println(p.getName()+"...."+p.getAge());
}
} }
输出：
调用了hashCode方法---------------
调用了hashCode方法---------------
调用了hashCode方法---------------
调用了hashCode方法---------------
调用了hashCode方法---------------
调用了equals方法---------------
lisic....21
lisia....24
lisid....29
lisib....27
结果说明调用了5次hashCode，调用了一次equals方法，说明当执行到这句话的时候，hs.add(new Person("lisi7",27));调用了equal方法，因为hash表里面已经有了一个name为lisi7，年龄为27的对象，hash值相同，需要判断内容是否相同，调用equal方法判断内容是否相同，相同，不往hashset里面存储。
TreeSet
自然排序，如果存放的是自定义对象，使用TreeSet，必须实现Comparable接口，覆盖里面的compareTo方法，添加元素的时候进行比较；如果添加的是字符串
就不需要覆盖compareTo方法，因为字符串有自己的compareTo方法；
自定义对象在TreeSet存储时候，如果不覆盖，就会报 java.lang.ClassCastException: cn.itcast.p.bean.Person cannot be cast to java.lang.Comparable异常
public class Person /*extends Object*/ implements Comparable{
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString(){
return name+":"+age;
}
@Override
public boolean equals(Object obj) {//判断人的内容是否相同
System.out.println("调用了equals方法---------------");
if(this == obj) //this只是否为Person对象
return true;
if(!(obj instanceof Person)){
throw new ClassCastException("类型转化错误！");
}
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;//字符创name的内容相同吗
}
@Override
public int hashCode() { //判断人的hash值是否相同
System.out.println("调用了hashCode方法---------------");
return name.hashCode()+ age;
}
@Override
public int compareTo(Object o) {
if(!(o instanceof Person))
throw new ClassCastException("类型转化错误");
Person p = (Person)o;
int temp = this.age-p.age;
return temp==0 ? (this.name.compareTo(p.name)) : temp;//temp等于0表示年龄相等。
}
}
import java.util.Iterator;
import java.util.TreeSet; import cn.itcast.p.bean.Person; public class TreeSetDemo { /**
* @param args
*/
public static void main(String[] args) {
demo2();
} /*
* 自定义对象，使用TreeSet，进行自然排序的时候，
* 需要实现Comparable接口，添加元素的时候进行比较,
* 以Person对象年龄进行排序，如果年龄相同，就按照姓名排序
*
*/ public static void demo2(){
TreeSet ts = new TreeSet();
ts.add(new Person("zhangsan",28));
ts.add(new Person("lisi",21));
ts.add(new Person("zhouqi",29));
ts.add(new Person("zhaoliu",25));
ts.add(new Person("wangu",24));
ts.add(new Person("zhouqi",29)); Iterator it = ts.iterator();
while(it.hasNext()){
Person p = (Person)it.next();
System.out.println(p.getName()+":"+p.getAge());
}
}
/**
* 添加的是字符串对象，因为字符串内部实现了compareTo方法，
* 所以不需要实现Comparable接口里面的
*/
public static void demo1() {
TreeSet ts = new TreeSet(); ts.add("abc");
ts.add("zaa");
ts.add("aa");
ts.add("nba");
ts.add("cba"); Iterator it = ts.iterator(); while(it.hasNext()){
System.out.println(it.next());
}
} }
输出结果：先以年龄进行排序，再以姓名进行排序。
lisi:21
wangu:24
zhaoliu:25
zhangsan:28
zhouqi:29 还可以使用TreeSet(Comparator<? super E> comparator)构造一个新的空 TreeSet，它根据指定比较器进行排序。实现Comparator比较器接口进行比较。
代码：
public class Person{
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString(){
return name+":"+age;
}
}
Comparator比较器：
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;//有序。
} }
package cn.itcast.p5.treeset.demo; import java.util.Iterator;
import java.util.TreeSet; import cn.itcast.p.bean.Person;
import cn.itcast.p5.comparator.ComparatorByName; public class TreeSetComparator { /**
* @param args
*/
public static void main(String[] args) { TreeSet ts = new TreeSet(new ComparatorByName()); /*
* 自定义对象，使用TreeSet，进行自然排序的时候，
* 需要实现Comparable接口，添加元素的时候进行比较
*
* 以Person对象年龄进行排序，如果年龄相同，就按照姓名排序
*
*/
ts.add(new Person("zhangsan",28));
ts.add(new Person("lisi",21));
ts.add(new Person("zhouqi",29));
ts.add(new Person("zhaoliu",25));
ts.add(new Person("wangu",24)); Iterator it = ts.iterator();
while(it.hasNext()){
Person p = (Person)it.next();
System.out.println(p.getName()+":"+p.getAge());
}
} }
输出：
lisi:21
wangu:24
zhangsan:28
zhaoliu:25
zhouqi:29
package cn.itcast.p5.treeset.test; import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet; import cn.itcast.p.bean.Person;
import cn.itcast.p5.comparator.ComparatorByLength; /*
* 对字符串进行长度排序，比较内容
*
* "20 18 -1 89 2 67"
*/ public class TreeSetTest { /**
* @param args
*/
public static void main(String[] args) {
//接口内部类
TreeSet ts = new TreeSet(new Comparator<String>() { @Override
public int compare(String o1, String o2) {
int temp = o1.length()-o2.length();
return temp==0 ? o1.compareTo(o2):temp;
}
}); ts.add("aaaaa");
ts.add("zz");
ts.add("nbaq");
ts.add("cba");
ts.add("abc");
ts.add("abc"); Iterator it = ts.iterator(); while(it.hasNext()){
System.out.println(it.next());
}
} }
输出：
zz
abc
cba
nbaq
aaaaa
Map
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set; public class MapDemo { public static void main(String[] args) { Map<Integer,String> map = new HashMap<Integer,String>();
method(map);
}
/**
*
* Set<Map.Entry<K,V>> entrySet()方法：返回一个set集合，里面装的是Map.Entry接口类型的键值对象
*
* 第二种遍历map的方式：通过看API:Set<Map.Entry<K,V>> entrySet()：Map.Entry<K,V>接口类型，
* 里面有K getKey() 返回与此项对应的键。 V getValue() 返回与此项对应的值。 * 思路：通过把map转化为set，进行迭代
* 通过使用entrySet方法吧键和值的映射关系作为对象，存储到set集合中，这个映射关系的类型为Map.Entry类型
*
*
*/
public static void method_3(Map<Integer,String> map){
map.put(8,"lisi");
map.put(2,"zhaoliu");
map.put(7,"wangwu");
map.put(6,"wangwang");
Set<Map.Entry<Integer, String>>entrySet = map.entrySet();
System.out.println(entrySet);//[2=zhaoliu, 6=wangwang, 7=wangwu, 8=lisi]
Iterator<Map.Entry<Integer, String>>it = entrySet.iterator();
//System.out.println(it.next());
while(it.hasNext()){
Map.Entry<Integer, String> entryMap = it.next();
Integer key = entryMap.getKey();//获取键
String value = entryMap.getValue();//获取值
System.out.println(key+":"+value);
}
}
/*
* 第一种遍历的方法
* Set<K> keySet()：返回键的set集合
* 取出map中的所有元素。
* 原理，通过keySet方法获取map中所有的键所在的Set集合，在通过Set的迭代器获取到每一个键，
在对每一个键通过map集合的get方法获取其对应的值即可。 */
public static void method_2(Map<Integer,String> map){ map.put(8,"zhaoliu");
map.put(2,"zhaoliu");
map.put(7,"xiaoqiang");
map.put(6,"wangcai"); Set<Integer> keySet = map.keySet();
System.out.println(keySet);//键的set集合[2, 6, 7, 8]
Iterator<Integer> it = keySet.iterator();//迭代keySet
while(it.hasNext()){
Integer key = it.next();
String value = map.get(key);
System.out.println(key+":"+value);
}
}
/**
* 常用方法：
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(): 获取键值对的个数。 5.特殊方法： Collection<V> values() 包含的值的 Collection 视图。
* @param map
*/
public static void method(Map<Integer,String> map){//学号和姓名
// 添加元素。
System.out.println(map.put(8, null));//null
System.out.println(map.put(8, "xiaoqiang"));//wangcai 存相同键，值会覆盖。
map.put(2,"zhangsan");
map.put(7,"zhaoliu"); /*System.out.println(map);
//删除。
System.out.println("remove:"+map.remove(2));
//判断。
System.out.println("containskey:"+map.containsKey(6));
System.out.println("containsValue:"+map.containsValue("zhaoliu")); //获取。
System.out.println("get:"+map.get(7));
System.out.println(map);*/
//返回key对应的所有value的集合
Collection<String>values = map.values();
System.out.println(values);
Iterator<String>it = values.iterator();
while(it.hasNext()){
String value = it.next();
System.out.println(value);
}
} } interface MyMap{
public static interface MyEntry{//内部接口
void get();
}
} class MyDemo implements MyMap.MyEntry{
public void get(){}
} class Outer{
static class Inner{
static void show(){}
}
}
HashMap
public class Person {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person:"+getName()+":"+getAge();
}
}
package cn.itcast.p2.bean;
public class Student extends Person {
public Student() {
super();
}
public Student(String name, int age) {
super(name, age);
}
@Override
public String toString() {
return "Student:"+getName()+":"+getAge();
}
}
package cn.itcast.p7.hashmap.demo; import java.util.HashMap;
import java.util.Iterator;
import java.util.Set; import cn.itcast.p2.bean.Student; public class HashMapDemo { /**
* @param args
*/
public static void main(String[] args) { /*
* 将学生对象和学生的归属地通过键与值存储到map集合中。
*
*/ HashMap<Student,String> hm = new HashMap<Student,String>(); hm.put(new Student("lisi",38),"北京");
hm.put(new Student("zhaoliu",24),"上海");
hm.put(new Student("xiaoqiang",31),"沈阳");
hm.put(new Student("wangcai",28),"大连");
hm.put(new Student("zhaoliu",24),"铁岭"); // Set<Student> keySet = hm.keySet();
// Iterator<Student> it = keySet.iterator(); Iterator<Student> it = hm.keySet().iterator(); while(it.hasNext()){
Student key = it.next();
String value = hm.get(key);
System.out.println(key.getName()+":"+key.getAge()+"---"+value);
} } }
结果：
xiaoqiang:31---沈阳
wangcai:28---大连
lisi:38---北京
zhaoliu:24---铁岭
HashMap要比较自定义对象也必须重写equal方法和hashCode方法。
TreeMap
排序，实现Comparator接口
package cn.itcast.p3.comparator;
import java.util.Comparator;
import cn.itcast.p2.bean.Person;
public class ComparatorByName implements Comparator<Person> {
@Override
public int compare(Person o1, Person o2) {
int temp = o1.getName().compareTo(o2.getName());
return temp==0? o1.getAge()-o2.getAge(): temp;
}
}
package cn.itcast.p8.treemap.demo; import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap; import cn.itcast.p2.bean.Student;
import cn.itcast.p3.comparator.ComparatorByName; public class TreeMapDemo { /**
* @param args
*/
public static void main(String[] args) { TreeMap<Student,String> tm = new TreeMap<Student,String>(new ComparatorByName()); tm.put(new Student("lisi",38),"北京");
tm.put(new Student("zhaoliu",24),"上海");
tm.put(new Student("xiaoqiang",31),"沈阳");
tm.put(new Student("wangcai",28),"大连");
tm.put(new Student("zhaoliu",24),"铁岭"); Iterator<Map.Entry<Student, String>> it = tm.entrySet().iterator(); while(it.hasNext()){
Map.Entry<Student,String> me = it.next();
Student key = me.getKey();
String value = me.getValue();
System.out.println(key.getName()+":"+key.getAge()+"---"+value);
}
}
}
输出结果：
lisi:38---北京
wangcai:28---大连
xiaoqiang:31---沈阳
zhaoliu:24---铁岭
LinkedHashMap
package cn.itcast.p1.map.demo; import java.io.File;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map; public class LinkedHashMapDemo { /**
* LinkedHashMap 按顺序存入，按顺序取出
*/
public static void main(String[] args) { File f= null;
HashMap<Integer,String> hm = new LinkedHashMap<Integer,String>(); hm.put(7, "zhouqi");
hm.put(3, "zhangsan");
hm.put(1, "qianyi");
hm.put(5, "wangwu"); Iterator<Map.Entry<Integer,String>> it = hm.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);
}
} }