Java集合框架详解与应用-优快云博客

本文链接：https://blog.youkuaiyun.com/eayonh2013/article/details/46870057

1、概述

（1）集合类是对对象进行存储的最常用的一种方式。

（2）集合类与数组的区别：

－数组也可以存储对象，但长度是固定的，集合长度是可变的

－数组中可以存储基本数据类型，集合只能存储对象。

（3）集合类的特点：

－集合只用于存储对象。

－集合长度是可变。

－集合可以存储不同类型的对象。

－集合中存储的都是对象的引用（地址）。

2、Collection

（1）Collection是集合框架中的根接口，该接口不提供任何直接实现，它提供更具体的子接口（如List和Set）实现。

（2）Collection接口提供的主要共性方法：

－boolean add(E e)：添加元素。

－boolean addAll(Collection<? extends E>c): 将指定 collection 中的所有元素都添加到此 collection 中。

－void clear()：移除此 collection 中的所有元素。

－boolean contains(Object o)：如果此 collection 包含指定的元素，则返回 true。

－boolean containsAll(Collect<?> c)：如果此 collection 包含指定 collection 中的所有元素，则返回 true。

－boolean equals(Object o)：比较此 collection 与指定对象是否相等。

－boolean isEmpty()：如果此 collection 不包含元素，则返回 true。

－Iterator<E> iterator()：返回在此 collection 的元素上进行迭代的迭代器。

－boolean remove(Object o)：从此 collection 中移除指定元素的单个实例，如果存在的话。

－boolean removeAll(Collection<? > c): 移除此 collection 中那些也包含在指定 collection 中的所有元素。

－boolean retainAll(Collection<? > c): 仅保留此 collection 中那些也包含在指定 collection 的元素。

－int size()：返回此 collection 中的元素数。

－Object[] toArray()：返回包含此 collection 中所有元素的数组。

3、迭代器

（1）迭代器（Iterator）是一个接口，可以对集合进行迭代，用于取出集合中的元素。

（2）Iterator 中的方法：

－boolean hasNext()：如果仍有元素可以迭代，则返回 true。

－E next()：返回迭代的下一个元素。

－void remove()：从迭代器指向的 collection 中移除迭代器返回的最后一个元素。

（3）迭代器为每一个集合提供了元素的取出方式，因为集合中把取出方式定义为对象定义在集合内部，这样取出方式就可以直接访问集合的元素，那么取出方式就被定义成了内部类，而每一个容器的数据结构不同，所以取出的动作细节也不一样，但是都有共性内容（判断和取出），那么就将这些共性抽取。通过一个对外提供的方法获取集合的取出对象即iterator()。

4、List

（1）List是Collection的一个子接口，此接口的元素是有序的，元素可以重复，因为该集合体系有索引。

（2）List中的特有方法：

－void add(int index,E element)：在列表的指定位置插入指定元素。

－boolean addAll(int index,Collection<?extend E> c)：添加指定 collection 中的所有元素到此列表的结尾。

－E get(int index)：返回列表中指定位置的元素。

－int indexOf(Object o)：返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。

－int lastIndexOf(Object o)：返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。

－ListIterator listIterator()：返回此列表元素的列表迭代器。

－E set(int index,E element)：用指定元素替换列表中指定位置的元素，返回以前在指定位置的元素。

－List<E> subList(int fromIndex,inttoIndex)：返回列表中指定的 fromIndex（包括）和 toIndex（不包括）之间的部分视图。

（3）List集合的迭代器：List集合特有的迭代器ListIterator是Iterator的子接口，在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生异常，所以在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断、取出和删除操作，如果想要其他的操作如添加、修改等就需要使用其子接口ListIterator中的方法，该接口只能通过List集合的ListIterator方法获取。

（4）ListIterator中定义的特有方法：

－void add(E e)：将指定的元素插入列表。该元素直接插入到 next 返回的下一个元素的前面（如果有），或者 previous 返回的下一个元素之后（如果有）；如果列表没有元素，那么新元素就成为列表中的唯一元素。

－boolean hasPrevious()：如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。

－E previous()：返回列表中的前一个元素。

－int nextIndex()：返回对 next 的后续调用所返回元素的索引。

－int previousIntdex()：返回对 previous 的后续调用所返回元素的索引。

－void set(E e)：用指定元素替换 next 或 previous 返回的最后一个元素。

（5）List集合有3个主要子类：

－ArrayList：底层的数据结构使用的是数组结构，特点：查询速度很快，但增删稍慢，线程不同步。

－LinkedList：底层使用的是链表数据结构，特点：增删速度很快，查询稍慢。

－Vector：底层是数组数据结构，线程同步，但查询增删很慢，被ArrayList替代了。

5、Vector

（1）Vector中特有方法：

－Enumeration elements()：返回此向量的组件的枚举。

（2）Enumeration是一个接口，它生成一系列元素，一次生成一个。连续调用 nextElement 方法将返回一系列的连续元素。枚举是Vector特有的取出方式，其实枚举和迭代是一样的，因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。

（3）Enumeration中的方法：

－boolean hasMoreElements()：测试此枚举是否包含更多的元素。

－E nextElement()：如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

6、LinkedList

（1）LinkedList特有方法：

－void addFirst(E e)：将指定元素插入此列表的开头。

－void addLast(E e)：将指定元素添加到此列表的结尾。

－boolean offerFirst(E e)：在此列表的开头插入指定的元素。

－boolean offerLast(E e)：在此列表末尾插入指定的元素。

－E getFirst()：返回此列表的第一个元素。但不会删除该元素。

－E getLast()：返回此列表的最后一个元素。但不会删除该元素。

－E removeFirst()：移除并返回此列表的第一个元素。如果此列表为空抛出NoSuchElementException

－E removeLast()：移除并返回此列表的最后一个元素。如果此列表为空抛出NoSuchElementException

－E pollFirst()：获取并移除此列表的第一个元素；如果此列表为空，则返回 null。

－E pollLast()：获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

－E peekFirst()：获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。

－E peekLast()：获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

（2）LinkedList练习：使用LinkedList模拟一个队列数据结构：

import java.util.*;

class DuiLie//定义DuiLie类

{

private LinkedList list;

public DuiLie()

{

list=new LinkedList();

}

public void myAdd(Object obj)//定义向队列添加元素的方法

{

list.addLast(obj);

}

public Object myGet()//定义获取队列元素的方法

{

return list.removeFirst();

}

public boolean isNull()//判断队列是否为空

{

return list.isEmpty();

}

public String toString()//复写toString方法

{

return list.toString();

}

public class LinkedListTest

{

public static void main(String[] args)

{

DuiLie dl=new DuiLie();//创建一个队列

//向队列添加元素

dl.myAdd("java01");

dl.myAdd("java02");

dl.myAdd("java03");

while(!dl.isNull())

{

System.out.println(dl.myGet());

}

7、ArrayList练习

（1）去除ArrayList集合中重复的元素

import java.util.*;

public class ArrayListTest

{

public static void main(String[] args)

{

ArrayList al=new ArrayList(); //创建一个ArrayList对象

//向ArrayList添加元素

al.add("java01");

al.add("java02");

al.add("java03");

al.add("java01");

al.add("java02");

System.out.println(al); //打印原ArrayList

al=singleElement(al);//调用方法去除重复元素

System.out.println(al);//打印新ArrayList

}

public static ArrayListsingleElement(ArrayList al)//定义去除ArrayList 中重复元素的方法

{

ArrayList newAl=new ArrayList();//创建一个新ArrayList用于存放非重复的元素

Iterator it=al.iterator();//获取迭代器

//遍历ArrayList中元素并去除重复元素

while(it.hasNext())

{

Object obj=it.next();

if(!newAl.contains(obj))

newAl.add(obj);

}

return newAl; //返回没有重复元素的ArrayList

}

（2）将自定义对象作为元素存到ArrayList集合中，并去除重复元素。

import java.util.*;

class Person

{

privateString name;

privateint age;

publicPerson(String name,int age)

{

this.name=name;

this.age=age;

}

publicboolean equals(Object obj)//复写equals方法以判断两个对象是否相同

{

if(!(objinstanceof Person))

thrownew RuntimeException("wrong");

Personp=(Person)obj;

returnthis.name.equals(p.name)&&this.age==p.age;

}

publicString toString()

{

returnname+"::"+age;

}

publicString getName()

{

returnname;

}

publicint getAge()

{

returnage;

}

public class ArrayListTest2

{

publicstatic void main(String[] args)

{

ArrayListal=new ArrayList();//创建一个ArrayList

//向ArrayList中添加Person对象

al.add(newPerson("zhangsan",22));

al.add(newPerson("lisi",25));

al.add(newPerson("zhangsan",22));

al.add(newPerson("wangwu",23));

al.add(newPerson("zhangsan",22));

al=singleElement(al);

Iteratorit=al.iterator();//获取迭代器

//遍历ArrayList元素

while(it.hasNext())

{

Objectobj=it.next();

Personp=(Person)obj;

System.out.println(p);

}

publicstatic ArrayList singleElement(ArrayList al)//定义去除重复元素的方法

{

ArrayListnewAl=new ArrayList();

Iteratorit=al.iterator();

while(it.hasNext())

{

Objectobj=it.next();

if(!newAl.contains(obj))

newAl.add(obj);

}

returnnewAl;

}

结论：List集合判断元素是否相同，依据的是元素的equals方法。

8、Set集合

（1）Set集合是Collection集合的一个子接口，其元素是无序（存入和取出的顺序不一定一致）的且元素不可以重复。

（2）Set集合的常见子类：

－HashSet：底层数据结构是哈希表，线程是非同步的。HashSet通过元素的两个方法，即hashCode和equals来保证元素唯一性，如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals判断。同样，对于判断元素是否存在及删除等操作，依赖的方法也是HashCode和equals。先比较HashCode再比较equals。

－TreeSet：底层数据结构是二叉树，可以对set集合中的元素进行排序。排序时，当主要条件相同时，一定要判断一下次要条件。保证集合中元素唯一性的依据是compareTo方法的返回值，若返回值为0则表示两元素相同。

（3）HashSet练习

importjava.util.*;

publicclass HashSetTest

{

public static void main(String[] args)

{

HashSet hs=new HashSet();//创建一个HashSet

//向集合中添加元素

hs.add(newPerson("a1",11));

hs.add(newPerson("a2",12));

hs.add(newPerson("a3",13));

hs.add(newPerson("a2",12));

Iterator it=hs.iterator();//获取迭代器

//遍历集合元素

while(it.hasNext())

{

Personp=(Person)(it.next());

System.out.println(p);

}

classPerson

{

private String name;

private int age;

public Person(String name,int age)

{

this.name=name;

this.age=age;

}

public int hashCode()

{

returnthis.name.hashCode()+age;

}

public boolean equals(Object obj)

{

if(!(obj instanceof Person))

throw newRuntimeException("wrong");

Person p=(Person)obj;

returnthis.name.equals(p.name)&&this.age==p.age;

}

public String toString()

{

returnname+"::"+age;

}

public String getName()

{

return name;

}

public int getAge()

{

return age;

}

结论：当用HashSet存储自定义对象时，要复写hashCode和equals方法。

（4）TreeSet集合特有方法：

－E ceiling(E e)：返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。

－E higher(E e)：返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。

－E first()：返回此 set 中当前第一个（最低）元素。

－E floor(E e)：返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。

－Comparator<? supre E> comparator()：返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回null。

－SortedSet<E> subset(E fromElement,E toElement)：返回此 set 的部分视图，其元素从 fromElement（包括）到toElement（不包括）。

－SortedSet<E> tailSet(E fromElement)：返回此 set 的部分视图，其元素大于等于 fromElement。

－SortedSet headset(E toElement)：返回此 set 的部分视图，其元素严格小于 toElement。

（5）Comparable接口

此接口强行对实现它的每个类的对象进行整体排序，这种排序被称为类的自然排序。接口的Int compareTo(T o)方法可以比较对象与指定对象的顺序，根据对象小于、等于或大于指定对象而返回负数、零或正数。若定义一个类时希望该具有比较性，则可以让该类实现Comparabler接口并重写该接口的compareTo方法。

（6）TreeSet集合存储自定义对象时，则自定义对象定义时需实现Comparable接口并重写其compareTo方法以实现比较性。下面例中，在TreeSet集合中存储Student对象，根据Student对象的年龄进行排序，若年龄相同则根据姓名排序。

import java.util.*;

public class TreeSetDemo

{

publicstatic void main(String[] args)

{

TreeSetts=new TreeSet();//创建一个TreeSet

//向集合添加元素

ts.add(newStudent("s1",15));

ts.add(newStudent("s2",12));

ts.add(newStudent("s3",16));

ts.add(newStudent("s4",15));

Iteratorit=ts.iterator();//获取迭代器

//遍历集合元素

while(it.hasNext())

{

Students=(Student)(it.next());

System.out.println(s);

}

class Student implements Comparable//实现Comarable接口使Student类具有比较性

{

privateString name;

privateint age;

publicStudent(String name,int age)

{

this.name=name;

this.age=age;

}

//复写compareTo方法

public int compareTo(Object obj)

{

if(!(objinstanceof Student))

thrownew RuntimeException("not Student");

Students=(Student)obj;

if(this.age>s.age)

return1;

elseif(this.age==s.age)

returnthis.name.compareTo(s.name);

else

return-1;

}

publicString toString()

{

returnthis.name+"..."+this.age;

}

结论：TreeSet排序的第一种方式：让元素自身具备比较性，元素需要实现Compparable接口，覆盖compareTo方法，这种方式也成为元素的自然顺序，或者叫做默认顺序。

（7）Comparator接口

该接口的子类对象可以作为TreeSet 集合的构造函数的参数去初始化TreeSet集合，从而使TreeSet集合具备比较性，实现对TreeSet集合中元素进行排序。该接口的方法：

－int compare(T o1,To2)：根据第一个参数小于、等于或大于第二个参数分别返回负数、零或正数。

（8）在TreeSet集合中存储Student对象，根据Student的姓名进行排序，若姓名相同则根据年龄排序。

import java.util.*;

public class TreeSetDemo2

{

publicstatic void main(String[] args)

{

TreeSet ts=new TreeSet(new MyComparator()); //创建TreeSet时传入比较器对象使集合具有比较性

ts.add(newStudent("s1",15));

ts.add(newStudent("s3",12));

ts.add(newStudent("s3",16));

ts.add(newStudent("s4",15));

System.out.println(ts);

Iteratorit=ts.iterator();

while(it.hasNext())

{

Students=(Student)(it.next());

System.out.println(s);

}

class Student implements Comparable

{

privateString name;

privateint age;

publicStudent(String name,int age)

{

this.name=name;

this.age=age;

}

publicint compareTo(Object obj)

{

if(!(objinstanceof Student))

thrownew RuntimeException("not Student");

Students=(Student)obj;

if(this.age>s.age)

return1;

elseif(this.age==s.age)

returnthis.name.compareTo(s.name);

else

return-1;

}

publicString toString()

{

returnthis.name+"..."+this.age;

}

publicString getName()

{

returnthis.name;

}

publicint getAge()

{

returnthis.age;

}

class MyComparator implementsComparator// 定义一个比较器

{

publicint compare(Object o1,Object o2)//复写compare方法

{

if(!(o1instanceof Student)||!(o2 instanceof Student))

thrownew RuntimeException("not Student");

Students1=(Student)o1;

Students2=(Student)o2;

intnum=s1.getName().compareTo(s2.getName());

if(num==0)

returnnew Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));

else

returnnum;

}

结论：TreeSet排序的第二种排序方式：当元素自身不具备比较性，或具备的比较性不是所需要的，这时就需要让集合自身具备比较性。让集合一初始化时就有了比较方式，定义比较器，通过定义一个类实现 Comparator接口覆盖compare方法，将比较器对象作为参数传递给TreeSet集合的构造函数。

当两种排序都存在时以比较器为主。

（9）TreeSet练习：按照字符串的长度排序。因为字符串体具备按自然顺序排序的比较性，所以这时需要使用比较器。

import java.util.*;

public class TreeSetTest

{

publicstatic void main(String[] args)

{

TreeSetts=new TreeSet(new StrLenComparator());//创建TreeSet集合

//添加元素

ts.add("acn");

ts.add("accddw");

ts.add("abcd");

ts.add("acfg");

Iteratorit=ts.iterator();//获取迭代器

//遍历元素

while(it.hasNext())

{

Strings=(String)(it.next());

System.out.println(s);

}

class StrLenComparator implements Comparator//定义比较器

{

publicint compare(Object o1,Object o2)//复写compare方法

{

if(!(o1instanceof String)||!(o2 instanceof String))

thrownew RuntimeException("not String");

Strings1=(String)o1;

Strings2=(String)o2;

intnum=new Integer(s1.length()).compareTo(new Integer(s2.length()));

if(num==0)

returns1.compareTo(s2);

else

returnnum;

}

9、泛型

（1）泛型是JDK1.5版本以后出现的新特性，用于解决安全问题，是一个安全机制。通过<>来定义要操作的引用数据类型，其实<>就是用来接收类型的，当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

（2）格式：集合类型<数据类型> 集合名＝new集合类型<数据类型>();

（3）泛型好处：

－将动行时出现的问题ClassCastException，转移到了编译时期，方便于程序员解决问题，让运行时问题减少、安全。

－避免了强制转换麻烦。

示例：

classGenericDemo

{

ArrayList<String> al=newArrayList<String>();//创建集合时指定集合存储的类型为String

al.add(“a1”);

al.add(“a2”);

Iterator<String>it=al.iterator();

while(it.hasNext())

{

String s=it.next();

System.out.println(s);

}

（4）泛型类：当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在可以定义泛型来完成扩展。

比如定义一个操作对象的泛型类：

class Utils<T>

{

private T t;

public void setObject(T t)

{

this.t=t;

}

public T getObject()

{

return t;

}

（5）泛型方法：泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

如：

classDemo

{

pubic <T> void show(T t)

{

System.out.println(t);

}

调用时可以show方法参数可以是不同类型，如：

newDemo().show(“abc”);

newDemo().show(new Integer(2));

（6）可以在泛型类中再定义泛型方法。如：

classDemo<T>

{

pubic void show(T t)

{

System.out.println(t);

}

pubic <Q> void print(Q q)

{

System.out.println(q);

}

上例中，show方法只能操作Demo类对象初始化时明确的数据类型的数据，而print方法可以操作不同的数据类型。

注意：静态方法不可以访问类上定义的泛型，如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。在方法上定义泛型时，<>在放在方法的返回值类型前面。

（7）泛型接口：当一个接口为泛型接口时，其子类在实现该泛型接口时明确要操作的数据类型，也可以在实现该接口时定义为泛型类。如：

interfaceInter<T>

{

public void show(T t);

}

classInterImp1 implements Inter<String>

{

public void show(String t)

{

System.out.println(t);

}

classInterImp2<T> implements Inter<T>

{

public void show(T t)

{

System.out.println(t);

}

（8）泛型限定

泛型限定的两种使用：

－? extends E：表示可以接收E类型或者E的子类型。

－? super E：表示可以接收E类型或者E的父类型。

注意：在泛型中，?表示通配符，也可理解为占位符。当泛型中用?时，表示可接受所有类型。

示例：

importjava.util.*;

public class GenericDemo

{

public static void main(String[] args)

{

//创建集合时指定集合存储的类型是Person

ArrayList<Person>al1=new ArrayList<Person>();

ArrayList<Student>al2=new ArrayList<Student>();

//添加元素

al1.add(newPerson("p1"));

al2.add(newStudent("s1"));

al2.add(newStudent("s2"));

printColl(al1);

printColl(al2);

}

public static void printColl(ArrayList<?extends Person> al)//定义方法用于遍历集合

{

Iterator<? extendsPerson> it=al.iterator();

while(it.hasNext())

{

System.out.println(it.next().getName());

}

classPerson

{

private String name;

public Person(String name)

{

this.name=name;

}

public String getName()

{

return name;

}

classStudent extends Person

{

public Student(String name)

{

super(name);

}

10、Map集合

（1）Map是一个接口，该集合存储键值对，一对一对往里存，而且要保证键的唯一性。当数据之间存在有映射关系时，要先想到map集合，因为map集合中存放的就是映射关系。

（2）Map集合方法

－ void clear()：从此映射中移除所有映射关系。

－boolean containsKey(Object key)：如果此映射包含指定键的映射关系，则返回 true。

－boolean containsValue(Object value)：如果此映射将一个或多个键映射到指定值，则返回 true。

－Set(Map.Entry<K,V>) entrySet()：返回此映射中包含的映射关系的Set视图。

－boolean equals(Object o)：比较指定的对象与此映射是否相等。

－V get(Object ket)：返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。

－boolean isEmpty()：如果此映射未包含键-值映射关系，则返回 true。

－Set<K> ketSet()：返回此映射中包含的键的Set视图。

－V put(K key,V value)：将指定的值与此映射中的指定键关联，如果此映射以前包含一个该键的映射关系，则用指定值替换旧值，返回以前与 key 关联的值，如果没有针对 key 的映射关系，则返回 null。

-void putAll(Map<? extends K,?extends V> m)：从指定映射中将所有映射关系复制到此映射中。

－Vremove(Object o)：如果存在一个键的映射关系，则将其从此映射中移除，返回以前与 key 关联的值；如果没有 key 的映射关系，则返回 null。

－int size()：返回此映射中的键-值映射关系数。

－Collection<V> values()：返回此映射中包含的值的Collection视图。

（3）Map有3个常见子类：

－Hashtable：底层是哈希表数据结构的，不可以存入null键和null值，该集合是线程同步的，效率较低。

－HashMap：底层是哈希表数据结构的，允许使用null键和null值，该集合是线程同步的，效率较高。

－TreeMap：底层是二叉树数据结构的，线程不同步，可以用于给Map集合中的键进行排序。

（4）通过keySet方式取出Map集合：将map中所有的键取出存入到Set集合，因为Set具备迭代器，所以可以用迭代方式取出所有的键，再根据get方法获取每一个键对应的值。

过程：通过map集合的keySet方法获取集合的所有键的集合-->获取keySet集合的迭代器-->取出键后可以通过map集合的get方法获取其对应的值。

示例：

import java.util.*;

public class MapDemo

{

public staticvoid main(String[] args)

{

Map<String,String>map=new HashMap<String,String>();//创建Map对象

//添加元素

map.put("01","map1");

map.put("03","map3");

map.put("04","map4");

map.put("02","map2");

Set<String>keySet=map.keySet();//获致键的集合

Iterator<String>it=keySet.iterator();//获取键集合的迭代器

//取出键值对

while(it.hasNext())

{

String key=it.next();

System.out.println(key+"="+map.get(key));

}

（5）通过entrySet方式取出Map集合：将map集合中的映射关系存入到Set集合中，而这个关系的数据类型是Map.Entry。

过程：通过map集合的entrySet方法将map集合中的映射关系取出放入类型为Map.Entry的Set集合中-->获取Set集合的迭代器-->通过迭代器获取Map.Entry后通过Map.Entry中的getKey和getValue方法获取映射关系中的键和值。

Map.Entry：Map.entrySet 方法返回映射的 collection 视图，其中的元素属于此类。

Map.Entry中的方法：

－K getKey()：返回与此项对应的键。

－V getValue()：返回与此项对应的值。

－V setValue(V value)：用指定的值替换与此项对应的值，返回与此项对应的旧值。

－int hashCode()：返回此映射项的哈希码值。

示例：

import java.util.*;

public class MapDemo2

{

public staticvoid main(String[] args)

{

Map<String,String>map=new HashMap<String,String>();//创建Map对象

map.put("01","map1");

map.put("03","map3");

map.put("04","map4");

map.put("02","map2");

Set<Map.Entry<String,String>>entrySet=map.entrySet();//获取Map.Entry集合

Iterator<Map.Entry<String,String>>it=entrySet.iterator();//获取Map.Entry集合迭代器

//取出键值对

while(it.hasNext())

{

Map.Entry<String,String>me=it.next();

Stringkey=me.getKey();

Stringvalue=me.getValue();

System.out.println(key+"::"+value);

}

（6）Map练习：将Student对象和其对应地址存入Map集合，当Student中姓名和年龄相同时视为同一个学生。

import java.util.*;

public class MapTest

{

public staticvoid main(String[] args)

{

HashMap<Student,String>hm=new HashMap<Student,String>();//创建HashMap对象

//添加元素

hm.put(newStudent("s1",11),"bj");

hm.put(newStudent("s2",22),"sz");

hm.put(newStudent("s3",33),"wh");

hm.put(newStudent("s4",44),"nc");

Set<Student>keySet=hm.keySet();//获取键的集合

Iterator<Student>it=keySet.iterator();//获取迭代器

//取出键值对

while(it.hasNext())

{

Students=it.next();

Stringaddr=hm.get(s);

System.out.println(s+"..."+addr);

}

Set<Map.Entry<Student,String>>entrySet=hm.entrySet();//获取Map.Entry集合

Iterator<Map.Entry<Student,String>>it1=entrySet.iterator();获取Map.Entry集合迭代器

//取出键值对

while(it1.hasNext())

{

Map.Entry<Student,String>me=it1.next();

Students=me.getKey();

Stringaddr=me.getValue();

System.out.println(s+"..."+addr);

}

class Student implements Comparable<Student>

{

privateString name;

private intage;

publicStudent(String name,int age)

{

this.name=name;

this.age=age;

}

public intcompareTo(Student s)//复写compareTo方法

{

intnum=this.name.compareTo(s.name);

if(num==0)

{

returnnew Integer(this.age).compareTo(new Integer(s.age));

}

else

returnnum;

}

publicboolean equals(Object obj)//复写equals方法

{

if(!(objinstanceof Student))

thrownew RuntimeException("not Studrnt");

Students=(Student)obj;

returnthis.name.equals(s.name)&&this.age==s.age;

}

public inthashCode()//复写hashCode方法

{

returnname.hashCode()+age*34;

}

public StringtoString()

{

returnthis.name+"::"+this.age;

}

（7）TreeMap练习：将Student对象和其对应地址存入Map集合，当Student中姓名和年龄相同时视为同一个学生。按学习年龄的升序排序。

import java.util.*;

public class TreeMapTest

{

public staticvoid main(String[] args)

{

TreeMap<Student,String>tm=new TreeMap<Student,String>(new MyComparator());

tm.put(newStudent("s2",12),"sz");

tm.put(newStudent("s1",13),"bj");

tm.put(newStudent("s4",22),"nc");

tm.put(newStudent("s3",33),"wh");

Set<Student>keySet=tm.keySet();

Iterator<Student>it=keySet.iterator();

while(it.hasNext())

{

Student s=it.next();

Stringaddr=tm.get(s);

System.out.println(s+"..."+addr);

}

class MyComparator implementsComparator<Student>//定义比较器

{

public intcompare(Student s1,Student s2)

{

intnum=new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));

if(num==0)

returns1.getName().compareTo(s2.getName());

else

returnnum;

}

class Student implements Comparable<Student>

{

privateString name;

private intage;

publicStudent(String name,int age)

{

this.name=name;

this.age=age;

}

public intcompareTo(Student s)

{

intnum=this.name.compareTo(s.name);

if(num==0)

{

returnnew Integer(this.age).compareTo(new Integer(s.age));

}

else

returnnum;

}

publicboolean equals(Object obj)

{

if(!(objinstanceof Student))

thrownew RuntimeException("not Studrnt");

Students=(Student)obj;

returnthis.name.equals(s.name)&&this.age==s.age;

}

public inthashCode()

{

returnname.hashCode()+age*34;

}

public StringtoString()

{

returnthis.name+"::"+this.age;

}

public StringgetName()

{

returnthis.name;

}

public intgetAge()

{

returnthis.age;

}

11、Collections类

（1）Collections类是对集合进行操作的工具类，该类定义了许多对集合进行操作的静态方法。

（2）Collections的常用方法：

－static<T extends Comparable<? super T>> voidsort(List<T> list)：根据元素的自然顺序 对指定列表按升序进行排序。

－static <T> void sort(List<T>list,Comparator<? super T> c)：根据指定比较器产生的顺序对指定列表进行排序。

－static <T extendsObject&Comparable<? super T> T max(Collection<? extends T> c)：根据元素的自然顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须实现Comparable 接口。

－static <T> T max(Collection<?extends T> c,Comparator<? super T> com)：根据指定比较器产生的顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须可通过指定比较器相互比较。

－static<T> int binarySearch(List<? extends Comparable<？super T>> list,T key)：使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的自然顺序对列表进行升序排序。

－static <T> int binarySearch(List<?extends T>list,T key,Comparator<? super T> c)：使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据指定的比较器对列表进行升序排序。

－static <T> void copy(List<? superT> dest,List<? extends T> src)：将所有元素从一个列表复制到另一个列表。

－static<T> void fill(List<? superT> List,T obj)：使用指定元素替换指定列表中的所有元素。

－static <T> Boolean replaceAll(List<T>list,T oldVal,T newVal)：使用另一个值替换列表中出现的所有某一指定值。

－static void reverse(List<?> list)：反转指定列表中元素的顺序。

－static <T> Comparator<T> reverseOrder()：返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

－static <T> Comparator<T>reverseOrder(Comparator<T> cmp)：返回一个比较器，它强行逆转指定比较器的顺序。

－static void swap(List<?> list,int I,intj)：在指定列表的指定位置处交换元素。

12、Array类

（1）Array类是用于操作数组的工具类，该类中的都是静态方法。