黑马程序员——java第十四、五、六天：集合框架（一：Collection、Map）

------- android培训、java培训、期待与您交流！ ----------

Collection体系描述

对象可以放在数组和集合中。

集合的特点：

1、  集合中只用来存储对象，

2、  集合长度是可变的

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

 

集合体系：                             

集合框架：

         为什么会出现这么多的容器呢？

因为每个容器对数据的存储方式都有不同，这个存储方式称为数据结构。

 

共性方法

创建一个集合容器，示例使用Collection接口的子类——ArrayList。

ArrayList al1=new ArrayList();

1、  添加元素：add(Objectob);

al1.add(“java01”);

al1.add(“java02”);

al1.add(“java03”);

al1.add(“java04”);

2、  获取个数，集合长度

al1.size();

 

内存结构：

 

（1）      add方法的参数类型是Object（add（Object ob），以便于接收任意类型对象。

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

 

打印集合：System.out.println(al1);

 

3、  删除元素：

al1.remove(“java01”);

al1.clear();//清空集合

al1.removeAll(al2);al1中只会保留在al2中没有的元素。

4、  判断元素

al1.contains(“java01”);al1中有没有java01对象

al1.isEmpty（）；//al1是否为空。

5、  取交集

ArrayList al2=new ArrayList（）；

al2.add(“java01”);

al2.add(“java02”);

al2.add(“java05”);

al2.add(“java06”);

al1.retainAll(al2);//取交集al1中只会保留和al2中相同的元素。

迭代器

什么是迭代器？

         其实就是集合取出元素的方式。

 

Iterator it=al1.iterator（）；//获取迭代，用于取出集合中的元素。

while（it.hasNext()）{

         System.out.println(it.nex());

}

it.hasNext();//判断如果仍有元素可迭代，则返回true。

开发是通常不用while循环而用for循环，因为it迭代以后就没用了所以定义成局部变量比较合适。

for（Iteratorit=al1.iterator();it.hasNext();）{

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

}

List集合共性方法

List：元素是有序的；元素可以重复，因为该集合体有索引。

set：元素无序，元素不可以重复

 

List特有方法：凡可以操作脚标的方法都是该体系特有方法。

1、  增：

add(index,element);

addAll(index,Collection);

2、  删：

remove(index);

3、  改：

set(index,element);

4、  查：

get(index);

subList(from,to);

listIterator();

例：

for（int x=0;x<al1.size();x++）{

           System.out.println(al1.get(x));

}

上例所实现得到的功能用Collection中的方法实现

for（Iterator it=al1.Iterator();it.hasNext();）{

           System.out.println(it.nex（）);

}

ListIterator

通过indexOf获取对象的位置。

例如:al1.indexOf(“java02”);

获得子集合：List sub=al1.subList(1,3);

 

当操作一个集合元素时，只能用一种方式操作（要么是迭代器的方法，要么是集合对象的方法），因为不能并发进行，否则会出现异常。

例如：Interator it=al1.iterator();

while(it.hasNext()){

         Objectobj=it.Next();//迭代器的方法

         if(obj==”java02”)

                   //al1.add(“java008”);//集合对象的方法，这样会异常,所以用下面迭代器方法

                   it.remove();

         System.out.println(al1);//测试打印的是没有移除前的集合元素，因为it.remove();

//时只删除了集合中”java02”的引用，但”java02”还在obj中所使//用，所以才打印出来了

}

System.out.println(al1);//此时打印是删除后的集合元素。

 

List集合特有的迭代器——ListIterator是Iterator的子接口。

 

在迭代时，不可以通过集合对象的方法操作集合中的元素。

因为会发生ConcurrentModificationException异常。

 

所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，

只能对元素进行判断，取出，删除的操作，

如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。

 

该接口只能通过List集合的listIterator方法获取。

 

用ListIterator迭代器修改后的代码：

ListInterator li=al1.listIterator();

while(li.hasNext()){

         Objectobj=it.Next();

         if(obj.equals(“java02”))

                   li.set(“java008”);

}

在List集合中在操作指针之前，指针是在最右边元素的右边一个位置上的。

所以用hasNext()和Next()是会右移。

在ListIterator中有个方法与hasNext()和Next()完全相反的方法——hasPrevious（）和Previous（）。他是倒叙迭代的，因为指针（如上），所以迭代时注意。

 

List集合具体对象的特点

|--List:元素是有序的，元素可以重复。因为该集合体系有索引。

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

|--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。

                   |--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。

 

注意：ArrayList和Vector因为是数组结构，数组长度不可变，所以当往里添加元素超过数组长度时他们会创建新的数组，把旧数组的元素拷过去。ArrayList初始长度是10，每延长一次数组长度增加50%；Vector初始长度是10，每延长一次数组长度增加100%；

 

Vector:

在API中Vector下的方法带有element的方法都是其特有方法。

枚举（Enumeration）: Elements下的Enumeration的方法hasMoreElements();nextElements();此方法为Vector特有的取出方式。发现枚举和迭代器很像，其实枚举和迭代器是一样的。因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。

        

LinkedList:

         LinkedList:特有方法：

addFirst();

addLast();

 

getFirst();

getLast();

获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

 

removeFirst();

removeLast();

获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException

 

 

在JDK1.6出现了替代方法。

 

offerFirst();代替addFirst（）；

offerLast();代替addLast（）；

 

 

peekFirst();代替getFirst（）；

peekLast();代替getLast（）；

获取元素，但不删除元素。如果集合中没有元素，会返回null。

 

pollFirst();代替removeFirst（）；

pollLast();代替RemoveLast（）；

获取元素，但是元素被删除。如果集合中没有元素，会返回null。

 

例题：

/*

使用LinkedList模拟一个堆栈或者队列数据结构。

 

堆栈：先进后出  如同一个杯子。

队列：先进先出 First in First out  FIFO 如同一个水管。

*/

 

import java.util.*;

class DuiLie

{

         privateLinkedList link;

 

         DuiLie()

         {

                   link= new LinkedList();

         }

         

         publicvoid myAdd(Object obj)

         {

                   link.addFirst(obj);

         }

         publicObject myGet()

         {

                   returnlink.removeFirst();

         }

         publicboolean isNull()

         {

                   returnlink.isEmpty();

         }

 

}

 

 

 

class LinkedListTest

{

         publicstatic void main(String[] args) 

         {

                   DuiLiedl = new DuiLie();

                   dl.myAdd("java01");

                   dl.myAdd("java02");

                   dl.myAdd("java03");

                   dl.myAdd("java04");

 

                   while(!dl.isNull())

                   {

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

                   }

         }

}

 

 

 

例二：

package exception;

import java.util.*;

 

class Person{

   private String name;

   privateintage;

   Person(Stringname,intage){

      this.name=name;

      this.age=age;

   }

   publicboolean equals(Object obj){//由于Object中定义的equals

                               //方法只是比较地址值，此处重写比

//较姓名和年龄。

      if(!(obj instanceof Person)){

         returnfalse;

      }

      Personp=(Person)obj;

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

   }

   public String getName() {

      returnname;

   }

   publicint getAge() {

      returnage;

   }     

}

 

 

publicclassArrayListText2 {

   

   publicstaticvoid sop(Object obj){

      System.out.println(obj);

   }

      

   publicstatic ArrayListsingleElement(ArrayList al){

      ArrayListnewAl=newArrayList();

      Iteratorit=al.iterator();

      while(it.hasNext()){

         Objectobj=it.next();

         if(!newAl.contains(obj)){//contains方法中用到了equals

//方法，因为比较姓名和年龄所以上面才重写了equals方法。因为newAl中的

//对象都是Person的对象所以调用时也是Person类中的equals，所以才在

//Person中重写equals的

            newAl.add(obj);

         }

      }

      return newAl;

      

   }

   publicstaticvoid main(String[] args) {

      ArrayListal=newArrayList();

      al.add(new Person("lisi01",30));

      al.add(new Person("lisi01",30));

      al.add(new Person("lisi02",31));

      al.add(new Person("lisi03",32));

      al.add(new Person("lisi03",32));

      al.add(new Person("lisi04",33));

      

      

      al=singleElement(al);

       

      Iteratorit=al.iterator();

      

      while(it.hasNext()){

         Personp=(Person)it.next();//因为add(Object obj)接收的

//对象时用到了多态的上转型，所以要想用到Person中的方法getName等所以

//要向下转型。

         sop(p.getName()+"::"+p.getAge());

         

      }

 

   }

 

}

 

 

HashSet

|--Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。、

         |--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。

                            HashSet是如何保证元素唯一性的呢？

                            是通过元素的两个方法，hashCode和equals来完成。

                            如果元素的HashCode值相同，才会判断equals是否为true。

                            如果元素的hashcode值不同，不会调用equals。

 

 

                            注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

所以在自定义对象时如果要存放在hashSet集合中，通常要复写hashCade和equals方法。

 

 

例子：

class HashSetTest 

{

         publicstatic void sop(Object obj)

         {

                   System.out.println(obj);

         }

         publicstatic void main(String[] args) 

         {

                   HashSeths = new HashSet();

 

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

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

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

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

//               hs.add(newPerson("a4",14));

 

                   //sop("a1:"+hs.contains(newPerson("a2",12)));

                            

//               hs.remove(newPerson("a4",13));

                   

 

                   Iteratorit = hs.iterator();

 

                   while(it.hasNext())

                   {

                            Personp = (Person)it.next();

                            sop(p.getName()+"::"+p.getAge());

                   }

         }

}

class Person

{

         privateString name;

         privateint age;

         Person(Stringname,int age)

         {

                   this.name= name;

                   this.age= age;

         }

         

         publicint hashCode()

         {

                   System.out.println(this.name+"....hashCode");

                   returnname.hashCode()+age*37;

         }

 

         publicboolean equals(Object obj)

         {

 

                   if(!(objinstanceof Person))

                            returnfalse;

 

                   Personp = (Person)obj;

                   System.out.println(this.name+"...equals.."+p.name);

 

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

         }

 

         

         publicString getName()

         {

                   returnname;

         }

         publicint getAge()

         {

                   returnage;

         }

}

|--

TreeSet：

         |--TreeSet：底层数据结构是二叉树。

 

 

TreeSet排序的第一种方式：让元素自身具备比较性。

                                     元素需要实现Comparable接口，覆盖compareTo方法。

                                     也种方式也成为元素的自然顺序，或者叫做默认顺序。

 

public interface Comparable：此接口强行对实现他的每个类的对象进行整体自然排序。

返回：保证元素唯一性的依据是compareTo方法返回0.可以对Set集合中的元素进行自然排序。

负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。

要放进TreeSet集合中的对象所属的类必须实现Comparable接口，并实现这个接口中的int comparable（T o）方法o为比较的对象。以规定按对象的什么属性排序。

TreeSet集合在往这个集合中添加元素时，会在底层调用comparableTo方法。

 

 

 

                                     TreeSet的第二种排序方式。

                                     当元素自身不具备比较性时，或者具备的比较性不是所需要的。

                                     这时就需要让集合自身具备比较性。

                                     在集合初始化时，就有了比较方式。

 

当元素自身不具备比较性，或者具备的比较性不是所需要的。

这时需要让容器自身具备比较性。

定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

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

定义一个类，实现Comparator接口，覆盖compare方法。

 

排序第一种示例：

需求：

往TreeSet集合中存储自定义对象学生。

想按照学生的年龄进行排序。

 

 

记住，排序时，当主要条件相同时，一定判断一下次要条件。

 

 

*/

 

class TreeSetDemo 

{

         publicstatic void main(String[] args) 

         {

                   TreeSetts = new TreeSet();

 

                   ts.add(newStudent("lisi02",22));

                   ts.add(newStudent("lisi007",20));

                   ts.add(newStudent("lisi09",19));

                   ts.add(newStudent("lisi08",19));

 

                   Iteratorit = ts.iterator();

                   while(it.hasNext())

                   {

                            Studentstu = (Student)it.next();

                            System.out.println(stu.getName()+"..."+stu.getAge());

                   }

         }

}

 

 

class Student implements Comparable//该接口强制让学生具备比较性。

{

         privateString name;

         privateint age;

 

         Student(Stringname,int age)

         {

                   this.name= name;

                   this.age= age;

         }

 

         publicint compareTo(Object obj)

         {

 

                   //return0;

                   

                   if(!(objinstanceof Student))

                            thrownew RuntimeException("不是学生对象");

                   Students = (Student)obj;

 

                   System.out.println(this.name+"....compareto....."+s.name);

                   if(this.age>s.age)

                            return1;

                   if(this.age==s.age)

                   {

                            returnthis.name.compareTo(s.name);

                   }

                   return-1;

                   /**/

         }

 

         publicString getName()

         {

                   returnname;

 

         }

         publicint getAge()

         {

                   returnage;

         }

}

 

排序第二种示例：

 

import java.util.*;

class Student implements Comparable//该接口强制让学生具备比较性。

{

         privateString name;

         privateint age;

 

         Student(Stringname,int age)

         {

                   this.name= name;

                   this.age= age;

         }

 

         publicint compareTo(Object obj)

         {

 

                   //return0;

                   

                   if(!(objinstanceof Student))

                            thrownew RuntimeException("不是学生对象");

                   Students = (Student)obj;

                   if(this.age>s.age)

                            return1;

                   if(this.age==s.age)

                   {

                            returnthis.name.compareTo(s.name);

                   }

                   return-1;

         }

 

         publicString getName()

         {

                   returnname;

         }

         publicint getAge()

         {

                   returnage;

         }

}

class TreeSetDemo2 

{

         publicstatic void main(String[] args) 

         {

                   TreeSetts = new TreeSet(new MyCompare);// 当两种排序都存在时，以比较器为主。//newMyCompare为定义的比较器类。空参数的为compareTo方法比较。

                   ts.add(newStudent("lisi02",22));

                   ts.add(newStudent("lisi02",21));

                   ts.add(newStudent("lisi007",20));

                   ts.add(newStudent("lisi09",19));

                   ts.add(newStudent("lisi06",18));

                   ts.add(newStudent("lisi06",18));

                   ts.add(newStudent("lisi007",29));

 

                   Iteratorit = ts.iterator();

                   while(it.hasNext())

                   {

                            Studentstu = (Student)it.next();

                            System.out.println(stu.getName()+"..."+stu.getAge());

                   }

         }

}

 

class MyCompare implements Comparator//定义比较器

{

         publicint compare(Object o1,Object o2)

         {

                   Students1 = (Student)o1;

                   Students2 = (Student)o2;

 

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

                   if(num==0)

                   {

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

                            /*

                            if(s1.getAge()>s2.getAge())

                                     return1;

                            if(s1.getAge()==s2.getAge())

                                     return0;

                            return-1;

                            */

                   }

                   returnnum;

         }

}

 

 

泛型

基本数据类型可以放在add（Object obj）中做参数，因为1.5jdk以后基本数据类型可以自动装箱封装成对象。

 

泛型：jdk1.5版本出现的新的特性。

         用于解决安全问题，是一个安全机制。

         因为集合中可以存放许多类型的对象，而这些对象有有不同的方法。

比如：

         求字符串的长度，当it.Next()从集合中取出对象时势必要向下转型为在string类型再调用String特有的length（）方法求长度，当其中集合中有一个基本数据类型对象被取出再转成String类型时会出现异常，所以演化出来泛型。

 

泛型：ArrayList<String> al=new ArrayList<String>();定义一个ArrayList容器，容器中的元素为String类型，这样在add()时就有了赛选。

 

泛型好处：

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

2、  避免了强制转换麻烦。

 

实例1：

class GenericDemo 

{

         publicstatic void main(String[] args) 

         {

 

                   ArrayList<String> al = new ArrayList<String>();

 

                   al.add("abc01");

                   al.add("abc0991");

                   al.add("abc014");

 

                   //al.add(4);//al.add(newInteger(4));

                   

 

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

                   while(it.hasNext())

                   {

                            Strings = it.next();

 

                            System.out.println(s+":"+s.length());

                   }

         }

}

 

 

 

实例二：

import java.util.*;

class GenericDemo2 

{

         publicstatic void main(String[] args) 

         {

                   TreeSet<String>ts = new TreeSet<String>(new LenComparator());

 

                   ts.add("abcd");

                   ts.add("cc");

                   ts.add("cba");

                   ts.add("aaa");

                   ts.add("z");

                   ts.add("hahaha");

 

 

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

 

                   while(it.hasNext())

                   {

                            Strings = it.next();

                            System.out.println(s);

                   }

         }

}

 

class LenComparator implementsComparator<String>//遇上个实力比较的亮点

{

         publicint compare(String o1,String o2)

         {

                   intnum = new Integer(o2.length()).compareTo(new Integer(o1.length()));

 

                   if(num==0)

                            returno2.compareTo(o1);

                   returnnum;

         }

}

 

 

泛型格式：通过<>来定义要曹祝的应用数据类型。

 

在使用java提供的对象时，什么时候写泛型呢？

         通常在集合框架中常见，只要在jdk中见到<>就要定义泛型。其实<>就是用来接收类型的。

         当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

 

泛型类

什么时候定义泛型类？

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

例：

 

class Work{

         

}

class Student{

}

class Utils<QQ>{

         privateQQ q;

         publicvoid setObject(QQ q){

                   this.q=q;

}

public QQgetObject(){

         return q;

}

}

class GenericDemo{

         publicstatic void main(String[] args){

                   Utils<Worker>u=new Utils<Worker>();

                   u.setObject(newWorker());

                   Workw=u.getObject();

         }

}

 

 

以上事例是：泛型类定义的泛型在整个类中有效。如果北方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定。

 

泛型方法

为了让不同方法可以操作不同类型，而且类型还不确定，呢么可以将泛型定义在方法上。

 

特殊之处：静态方法不可以访问类上定义的泛型，如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

泛型定义在方法上时要放在返回值前面，修饰符后面。

示例：

class Demo<t>{

         publicvoid show(T t){

                   System.out.println(“show:”+t);

         }

         public<Q> void print(Q q){

                   System.out.println(“print”+9);

         }

         publicstatic <w> void method(W t){

                   Systm.put.println(“method:”+t);

         }

}

class GenericDemo4{

         publicstatic void main(String[] args){

                   Demo<String>d=new Demo<String>();

                   d.show(“haha”);

                   d.print(5);

                   d.print(“hehe”);

                   Demo.method(“hahahh”);

         }

}

 

 

泛型定义在接口上。

interface Inter<T>

{

         voidshow(T t);

}

 

/*//实现方法一：知道操作什么对象

class InterImpl implementsInter<String>

{

         publicvoid show(String t)

         {

                   System.out.println("show:"+t);

         }

}

 

*/

//实现方法二：不知道操作什么对象

class InterImpl<T> implementsInter<T>

{

         publicvoid show(T t)

         {

                   System.out.println("show:"+t);

         }

}

class GenericDemo5 

{

         publicstatic void main(String[] args) 

         {

 

                   InterImpl<Integer>i = new InterImpl<Integer>();

                   i.show(4);

                   //InterImpli = new InterImpl();

                   //i.show("haha");

         }

}

 

 

泛型限定

<?>:通配符或占位符。

泛型的限定：

         ？ extends E ：为上限定—可以接收E类型或E类型的子类型。

         ？ super E:为下限定——可以接收E类型或E的父类型。

 

例一：<?>

class GenericDemo{

         publicstatic void main(String[] args){

                   ArrayList<String>al=new ArrayList<String>();

                   al.add(“abc1”);

                   al.add(“abc2”);

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

                   al1.add(4);

                   al1.add(0);

         }

         publicstatic void printColl(ArrayList<?> al){// <?>不知道要传入什么类型对象，

//但什么类型都能接收,相当于占着位置

                   //此处也可写publicstatic <t> void printColl(ArrayList<T> al){

                   //这样写他可以做到：Tt=it.next();t.toString();而<?>不行。还不能使用类型特有方法。

                   for(Iterator<?>it=al.iterator();it.HasNext();){

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

}

         }

}

 

 

 

例二：只接收父类及其子类

 

class Person{

         Person(Stringname){

                   this.name=neme;

         }

         publicSreing getName(){

                   returnname();

         }

}

class Student extends Person{

         Student（String name）{

                   super(name);

         }

}

class GenericDemo6

{

         publicstatic void main(String[] args) 

         {ArrayList<Person> al = new ArrayList<Person>();

                   al.add(newPerson("abc1"));

                   al.add(newPerson("abc2"));

                   al.add(newPerson("abc3"));

ArrayList<Student> al1 = newArrayList<Student>();

                   al1.add(newStudent("abc--1"));

                   al1.add(newStudent("abc--2"));

                   al1.add(newStudent("abc--3"));

                   printColl(al1);printColl(al)

}

         publicstatic void printColl(Collection<? extends Person> al)

         {

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

                   while(it.hasNext())

                   {

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

                   }

         };

 

 

Map概述

Map集合：该集合存储键值对，一对一对的存储，而且保证建的唯一性。

1、  添加

a)        put(K key,V value);

b)        putAll(Map<? extendsK,?extends V> m);

2、  删除

a)        clear();

b)        remove(Object key);

3、  判断

a)        containsValue(Object value);

b)        containsKey(Object key);

c)        isEmpty();

4、  获取

a)        get(Object key);

b)        size();

c)        values();//获取map集合中所有的值，并返回Collection对象。

d)        entrySet();

e)        keyset();

 

Map|--Hashtable

         |--HashMap

         |--TreeMap

Map子类对象特点

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

HashMap：的底层是哈希表数据结构，允许使用null键null值，该集合是不同步的。jdk1.2开始。效率高。其他功能与Hashtable相同。

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

Map的共性方法

可以通过get方法的返回值来判断一个键是否存在，通过返回null来判断。

 

在添加元素时，如果出现添加相同的键值，那么后添加的值会覆盖原有键值对应的值。

Map-keySet

Set<K> keyset:将Map中所有的键存入到Set集合。因为Set具备迭代器，所以可以迭代方式取出所有的键，再根据get方法获取每一个键对应的值。

 

示例：

import java.util.*;

publicclassMapDemo2 {

   publicstaticvoid main(String[] args) { 

      Map<String,String>map=newHashMap<String,String>();

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

      map.put("3", "zhangsan3");

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

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

//先获取map集合的所有键的Set集合,keySet(); 

      Set<String>keySet=map.keySet();

//有了Set集合。就可以获取其迭代器。

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

      while(it.hasNext()){

         Stringkey=it.next();

//有了键可以通过map集合的get方法获取其对应的值。

         Stringvalue=map.get(key);

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

      }

   }

}

 

 

 

Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。

Map-entrySet

2，Set<Map.Entry<k,v>>entrySet：将map集合中的映射关系存入到了set集合中，

                                     而这个关系的数据类型就是：Map.Entry

 

                                     Entry其实就是Map中的一个static内部接口。

                                     为什么要定义在内部呢？

                                     因为只有有了Map集合，有了键值对，才会有键值的映射关系。

                                     关系属于Map集合中的一个内部事物。

                                     而且该事物在直接访问Map集合中的元素。

 

示例：

import java.util.*;

publicclassMapDemo2 {

   publicstaticvoid main(String[] args) { 

      Map<String,String>map=newHashMap<String,String>();

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

      map.put("3", "zhangsan3");

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

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

//将Map集合中的映射关系取出。存入到Set集合中。        

      Set<Map.Entry<String,String>> entrySet=map.entrySet();

      Iterator<Map.Entry<String,String>> it=entrySet.iterator();

      while(it.hasNext()){

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

         Stringkey=me.getKey();

         Stringvalue=me.getValue();

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

      }

   }

}

 

 

注意：一般和Hash…(哈希表)有关的集合在其存放的对象的类里一般要覆写hashCode和equals方法。

         一般和Tree…(二叉树)有关的集合，在其存放的对象的类里一般要继承Comparable并覆写compareTo方法。或写个比较，在用到时，创建集合对象时传入构造方法中。

 

扩展题：

捷答一：

/*

map扩展知识。

map集合被使用是因为具备映射关系。

"yureban"   Student("01" "zhangsan");

"yureban"Student("02" "lisi");

"jiuyeban""01" "wangwu";

"jiuyeban""02" "zhaoliu";

一个学校有多个教室。每一个教室都有名称。

*/

import java.util.*;

class  MapDemo31

{

   publicstaticvoid main(String[] args) 

   {     

      HashMap<String,HashMap<String,String>>czbk = newHashMap<String,HashMap<String,String>>();

      HashMap<String,String>yure = newHashMap<String,String>();

      HashMap<String,String>jiuye = newHashMap<String,String>();

      czbk.put("yureban",yure);

      czbk.put("jiuyeban",jiuye);

      yure.put("01","zhagnsan");

      yure.put("02","lisi");

      jiuye.put("01","zhaoliu");

      jiuye.put("02","wangwu");

      //遍历czbk集合。获取所有的教室。

      Iterator<String>it = czbk.keySet().iterator();

      while(it.hasNext())

      {

         StringroomName = it.next();

         HashMap<String,String>room = czbk.get(roomName);

         

         System.out.println(roomName);

         getStudentInfo(room);

      }     

      getStudentInfo(jiuye);

      getStudentInfo(yure);    

   }

   publicstaticvoidgetStudentInfo(HashMap<String,String> roomMap)

   {

      Iterator<String>it = roomMap.keySet().iterator();

      while(it.hasNext())

      {

         Stringid = it.next();

         Stringname = roomMap.get(id);

         System.out.println(id+":"+name);

      }

   }

}

 

 

 

 

 

解答二：

import java.util.*;

class Student1{

   private String id;

   private String name;

   Student1(Stringid,String name){

      this.name=name;

      this.id=id; 

   }

   public String toString(){

      returnid+"...."+name;

   }

}

publicclassMapDemo3 {

   publicstaticvoid demo() {

      HashMap<String,List<Student1>>czbk=newHashMap<String,List<Student1>>();

      List<Student1>reyu=newArrayList<Student1>();

      List<Student1>jiuye=newArrayList<Student1>();

      czbk.put("yureban",reyu);

      czbk.put("jiuyeban",jiuye);

      reyu.add(new Student1("01","zhangsan"));

      reyu.add(new Student1("02","lisi"));

      jiuye.add(new Student1("01","zhaoliu"));

      jiuye.add(new Student1("02","wangwu"));

      Iterator<String>it=czbk.keySet().iterator();

      while(it.hasNext()){

         StringroomName=it.next();

         List<Student1>room=czbk.get(roomName);

         getInfos(room);

      }  

   }

   privatestaticvoidgetInfos(List<Student1> room) {

      Iterator<Student1>it=room.iterator();

      while(it.hasNext()){

         Student1s=it.next();

         System.out.println(s);//此处打印student的对象，打印的是对象的地址，因为打印地址要调用toString方法，所以上面覆写了toString这里写s与写s.toString 一样。

      }     

   }

   publicstaticvoid main(String args[]){

      demo();

   }

}

 

 

什么时候用Map集合呢？

当数据之间存在着映射关系时就要先想Map集合。

Map集合被使用是因为其具备映射关系。

------- android培训、java培训、期待与您交流！ ----------详细请查看：http://edu.csdn.net