java容器---集合总结
思考为什么要引入容器这个概念？
Java有多种方式保存对象（应该是对象的引用），例如使用数组时保存一组对象中的最有效的方式，如果你想保存一组基本类型的数据，也推荐使用这种方式，但大家知道数组是具有固定尺寸的，你必须事先知道你要需要多少个对象。但是在一般的情况中，你在写程序中并不知道将需要多少个对象，或者是否需要更加复杂的方式来存储对象，因此数组尺寸固定很不爽！
为了解决上述问题，引入了容器的概念。容器提供了完善的方法来保存对象，你可以使用这些工具来解决数量惊人的问题。Java容器类可以自动调整自己的尺寸，因此与数组不同，你可以将任意数量的对象放到容器中，并不担心容器设置为多大。
集合特点：
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"));//1 System.out.println(list.lastIndexOf("abc3"));//2 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); } } }