java容器---集合总结
思考为什么要引入容器这个概念？
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);
}
} }
java容器---集合总结的更多相关文章
- java 容器 集合 用法
Set,List,Map,Vector,ArrayList的区别 JAVA的容器---List,Map,Set Collection ├List │├LinkedList │├ArrayList │└ ...
- java容器集合
java 集合分为 Collection 和 Map 两大类 Collection 是 Java 集合框架的顶层接口,它是对容器类进行增.删.改.查的定义,同时继承了 Iterable 接口,具有对集 ...
- Java编程技术之浅析Java容器技术
Java容器 集合是一种存储数据的容器,是Java开发中使用最频繁的对象类型之一. 或许提起Collection,都会第一时间意识到List和Set以及Map等相关关键词.因为这几乎是我们日常开发里接 ...
- Java各种集合容器的总结
Java容器指的是List,Set,Map这些类.由于翻译的问题,问到集合,Collection这些指的都是它们几个. List ArrayList 随机访问快 LinkedList 插入删除快 这个 ...
- 【Java心得总结七】Java容器下——Map
我将容器类库自己平时编程及看书的感受总结成了三篇博文,前两篇分别是:[Java心得总结五]Java容器上——容器初探和[Java心得总结六]Java容器中——Collection,第一篇从宏观整体的角 ...
- 【Java心得总结五】Java容器上——容器初探
在数学中我们有集合的概念,所谓的一个集合,就是将数个对象归类而分成为一个或数个形态各异的大小整体. 一般来讲,集合是具有某种特性的事物的整体,或是一些确认对象的汇集.构成集合的事物或对象称作元素或是成 ...
- Java 容器(list, set, map)
java容器类库的简化图: (虚线框表示接口, 实线框表示普通的类, 空心箭头表示特定的类实现了接口, 实心箭头表示某个类可以生成箭头所指的类对象) 继承Collection的主要有Set 和 Lis ...
- java的集合框架最全详解
java的集合框架最全详解(图) 前言:数据结构对程序设计有着深远的影响,在面向过程的C语言中,数据库结构用struct来描述,而在面向对象的编程中,数据结构是用类来描述的,并且包含有对该数据结构操作 ...
- java容器简要概述
java中集合框架的概述 java集合类主要用于保存对象的. 常用的集合对象: Colletion接口,Collection接口是集合中的顶层容器,表示的是一组对象,它的下面有两个子接口List接口和 ...
随机推荐
- autofac 初步学习
//数据处理接口 public interface IDal<T> where T : class { void Insert (T model); void Update(T model ...
- POI读写Excel简述之读取
一.POI读取Excel文件(以Excel2003版为例,2007版就是根据文件扩展名xlsx将HSSFWorkbook换为XSSFWorkbook,及其Sheet.Row.Cell也相应替换) // ...
- 修改php执行用户，并使其拥有root权限
useradd apachephp vi /etc/httpd/conf/httpd.conf 将组和用户修改成apachephp,重启apache,然后用lsof -i:80查看apache的执行用 ...
- jsp页面显示数据库乱码
如何页面是utf-8,数据库也是的话,页面显示数据库乱码的话,就是数据库的格式有问题
- 多一个“点”给IIS与ASP.NET带来的问题
[IIS] 一个网站如果用的是IIS(假设没有在前端7层负载均衡中对这种场景进行特殊处理),只要在浏览器地址栏中输入这个网站的域名并加上“.”,比如:www.cnblogs.com. ,就会引发“Ba ...
- 关于笔记本安装双系统windows and linux
ps1.安装完成后,补充下如何设在win7为默认启动系统, 大家也都知道,在linux 运行当软件都是以配置文件来设置参数当,当然grub菜单也不例外, 修改菜单可以进入grub.conf [root ...
- web安全防范
xss漏洞 原理:信任了用户输入或控制的字段(url),回显(jQuery.html)到页面.导致script代码执行 后果:可以在页面执行任何hack代码,比如死循环.发送cookie.钓鱼.页面显 ...
- 批量删除wordpress垃圾评论留言
wordpress博客的存在,垃圾评论注定会找上门来.大家还可以用Akismet.Bad Behavior.Spam Karma等一些其他的插件或者直接用程序写个验证码函数对留言进行验证来过滤 垃圾评 ...
- UIView中UIButton设置监听
红色框框是一个uibutton _priceValueLabel是他的父视图, 必须要把button的父视图设置userInteractionEnabled = YES, button的 监听才会生效 ...
- mac安装django1.5.4
http://www.iwangzheng.com/ 1.下载安装程序 打开终端输入以下命令 $ wget http://www.djangoproject.com/m/releases/1.5/Dj ...