黑马程序员-----程序员之路_____集合框架

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

一、集合类框架

集合框架图

二、集合类容器

1、Collection 

package day14;/* 1,add方法的参数类型是Object。以便于接收任意类型对象 2集合中存储的都是对象的引用（地址）*/import java.util.*;class CollectionDemo {public static void main(String[] args) {//创建一个集合容器，使用Collection接口的子类，ArrayListArrayList a1=new ArrayList();//1，添加元素a1.add("java01");a1.add("java02");a1.add("java03");a1.add("java04");//打印原集合sop(a1);//3，删除元素//a1.clear();a1.remove("java02");//2获取个数，集合长度。sop("size:"+a1.size());//打印改变后的集合sop(a1);//判断元素sop("java03是否存在"+a1.contains("java03"));sop("集合是否为空？"+a1.isEmpty());}public static void sop(Object obj){System.out.println(obj);}}

2、集合框架的工具类Collections：

package day17;/* 集合框架的工具类。 Collections： */import java.util.*;class CollectionsDemo {public static void main(String[] args) {// TODO Auto-generated method stub//binarySearchDemo();sortDemo();}public static void binarySearchDemo(){List<String>list=new ArrayList<String>();list.add("aaaa");list.add("afs");list.add("sfsggdg");list.add("zz");list.add("afs");Collections.sort(list,new StrLenComparator());sop(list);//int index=Collections.binarySearch(list, "afs");//int index=halfSearch(list,"aaaaa");int index=halfSearch(list,"aaaaa",new StrLenComparator());sop("index="+index);}public static int halfSearch(List<String>list,String key){int max,min,mid;max=list.size()-1;min=0;while(min<=max){mid=(max+min)>>1;//    /2String str=list.get(mid);str.compareTo(key);int num=str.compareTo(key);if(num>0)max=mid-1;else if(num<0)min=mid+1;elsereturn mid;}return-min -1;}public static int halfSearch(List<String>list,String key,Comparator<String>cmp){int max,min,mid;max=list.size()-1;min=0;while(min<=max){mid=(max+min)>>1;//    /2String str=list.get(mid);str.compareTo(key);int num=cmp.compare(str, key);if(num>0)max=mid-1;else if(num<0)min=mid+1;elsereturn mid;}return-min -1;}public static void maxDemo(){List<String>list=new ArrayList<String>();list.add("aaaa");list.add("afs");list.add("sfsggdg");list.add("zz");list.add("afs");Collections.sort(list);sop(list);String max=Collections.max(list,new StrLenComparator());sop("max=:"+max);}public static void sortDemo(){List<String>list=new ArrayList<String>();list.add("aaaa");list.add("afs");list.add("sfsggdg");list.add("cd");list.add("afs");sop(list);//Collections.sort(list);//Collections.sort(list,new StrLenComparator());Collections.swap(list, 1, 2);//角标1和角标2交换位置。sop(list);}public static void sop(Object obj){System.out.println(obj);}}class StrLenComparator implements Comparator<String>{public int compare(String s1,String s2){if(s1.length()>s2.length())return 1;if(s1.length()<s2.length())return -1;return s1.compareTo(s2);}}/*class Student{}list.add(new Student());public static <T extends Comparable<? super T)>>void sort(List<T> list){}*/

3、什么是迭代器呢？其实就是集合的取出元素的方式

package day14;import java.util.ArrayList;import java.util.Iterator;/* * 什么是迭代器呢？ * 其实就是集合的取出元素的方式 * */class CollectionDemo1{public static void main(String[] args){//method_2();method_get();}public static void method_get(){//创建一个集合容器，使用Collection接口的子类，ArrayListArrayList al=new ArrayList();//添加元素al.add("java01");al.add("java02");al.add("java03");al.add("java04");/*Iterator it=al.iterator();//获取迭代去，用于取出集合中的元素。while(it.hasNext()){sop(it.next());}*/for(Iterator it=al.iterator();it.hasNext();){sop(it.next());}}public static void method_2(){ArrayList al1=new ArrayList();al1.add("java01");al1.add("java02");al1.add("java03");al1.add("java04");ArrayList al2=new ArrayList();al2.add("java01");al2.add("java02");al2.add("java05");al2.add("java06");//al1.retainAll(al2);//区交集,al1中只会保留和al2中相同的元素al1.removeAll(al2);sop("al1"+al1);sop("al2"+al2);}public static void base_method(){//创建一个集合容器，使用Collection接口的子类，ArrayListArrayList al=new ArrayList();//1，添加元素al.add("java01");al.add("java02");al.add("java03");al.add("java04");//打印原集合sop(al);//3，删除元素//a1.clear();al.remove("java02");//2获取个数，集合长度。sop("size:"+al.size());//打印改变后的集合sop(al);//判断元素sop("java03是否存在"+al.contains("java03"));sop("集合是否为空？"+al.isEmpty());}public static void sop(Object obj){System.out.println(obj);}}

三、Set集合

 |---Set:元素是无序的（存入和取出的顺序不一致），元素不可以重复
  |--Hashset：底层数据结构是哈希表。
  HashSet是如何保证元素唯一性的呢？
  是通过元素的两个方法，HashCode和equals来完成的
  如果元素的HashCode值相同，才会判断equals是否是ture
  如果元素的hashcode值不同，才会调用equals
  注意，对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
 
  |--Treeset：可以对Set集合中的元素进行排序。
Set集合的功能和Collection是一致的

class HashSetDemo{public static void sop(Object obj){System.out.println(obj);}public static void main(String[] args){//先创立集合。HashSet hs=new HashSet();sop(hs.add("java01"));sop(hs.add("java01"));//内容对象都是一样的判断就不存了//添加失败就为假hs.add("java02");hs.add("java03");hs.add("java04");hs.add("java03");Iterator it=hs.iterator();while(it.hasNext()){sop(it.next());}}}

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

如果两元素的hashCode值不同，则不会调用equals方法

如果两元素的hashCode值相同，则继续判断equals是否返回true；

hashCode和equals方法虽然定义在自定义对象类里面，但不是我们手动调用

而是往HashSet集合里面存储元素的时候，集合底层自己调用hashCode

和equals它自己拿对象去判断，自己判断两元素是否是同一个元素。

往hashSet集合中存入自定义对象，姓名和年龄相同为同一个人，重复元素

import java.util.*; class HashSetTest {public static void sop(Object obj){System.out.println(obj);}public static void main(String[] args){HashSet hs=new HashSet();hs.add(new Person_1("a1",11));hs.add(new Person_1("a2",12));hs.add(new Person_1("a3",13));//hs.add(new Person_1("a1",12));//hs.add(new Person_1("a1",14));//sop("a1:"+hs.contains(new Person_1("a1",11)));//先判断哈希值，然后在比较equalshs.remove(new Person("a3",13));Iterator it=hs.iterator();while(it.hasNext()){Person_1 p=(Person_1)it.next();sop(p.getName()+":::"+p.getAge());}}} class Person_1 { private String name; private int age; Person_1(String name,int age) { this.name=name; this.age=age; }   public int hashCode() { System.out.println(this.name+"...hashCode"); return name.hashCode()+age*21;//保证哈希值的唯一性 } public boolean equals(Object obj) { if(!(obj instanceof Person_1)) return false; Person_1 p=(Person_1)obj;  System.out.println(this.name+"..equals"+p.name);//这句话打印就说明equals被调用了 return this.name.equals(p.name)&&this.age==p.age; } public String getName()   { return name; } public int getAge() { return age; } }

2、TreeSet:

TreeSet要求往里面存的元素具备比较性，否则会报错。

TreeSet排序的第一种方式:

让元素自身具备比较性，定义对象类，实现Compareble接口,复写compareTo方法，此方式是元素的自然顺序

package day15;/* 需求： 往TreeSet集合中存储自定义对象学生 想按照学生的年龄进行排序。 记住，排序时，当主要条件相同时，一定判断一下次要条件*/import java.util.*;class TreeSetDemo {public static void main(String[] args) {TreeSet ts=new TreeSet();ts.add(new Student("lisio2",22));ts.add(new Student("lisio3",20));ts.add(new Student("lisio4",24));ts.add(new Student("lisio5",19));ts.add(new Student("lisio9",20));//ts.add(new Student("lisio6",18));Iterator it=ts.iterator();while(it.hasNext()){Student stu=(Student)it.next();System.out.println(stu.getName()+"...."+stu.getAge());}}}class Student implements Comparable//该接口强制让学生具备比较性{private String name;private int age;Student(String name,int age){this.name=name;this.age=age;}public int compareTo(Object obj){if(!(obj instanceof Student))throw new RuntimeException("不是学生对象");Student s=(Student)obj;System.out.println(this.name+"....complareto.."+s.name);if(this.age>s.age)return 1;if(this.age==s.age){return this.name.compareTo(s.name);}return -1;}public String getName(){return name;}public int getAge(){return age;}}

3、TreeSet排序的第二种方式:

        让集合具备比较性当元素自身不具备比较性(比如存储学生对象时)或者具备的比较性不是我们所需要的比较性时(比如想字符串的长度排序),此时就需要让集合自身具备自定义的比较性。 那如何让集合自身具备比较性呢？可在集合初始化时，就让集合具备比较方式。即定义一个类，实现Comparator接口，覆盖compare方法。

class StringLengthComparator implements Comparator{public int compare(Object obj1,Object obj2){String s1 = (String)obj1;String s2 = (String)obj2;int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));if(num==0)return s1.compareTo(s2);return num;} }class TreeSetTest{public static void main(String[] args){TreeSet ts = new TreeSet(new StringLengthComparator());ts.add("addfg");ts.add("dfg");ts.add("agtuug");ts.add("vgjkg");sop(ts);} } 注意：基本数据类型或字符串对象均实现了Comparable接口，故同种类型基本数据间具备比较性，即自然顺序。

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

(1)List:列表，元素是有序的(元素带角标索引)，可以有重复元素,可以有null 元素     

1）ArrayList(JDK1.2):底层的数据结构是数组数据结构，特点是查询速度快(因 为带角标)，但是增删速度稍慢,因为当元素多时，增删一个元素则所有元素的角标都得改变，线程不同步。默认长度是10，当超过长度时，按50%延长集合长度。   2）LinkedList(JDK1.2):底层数据结构式链表数据结构(即后面一个元素记录前一个)，特点：查询速度慢，因为每个元素只知道前面一个元素，但增删速度快，因为元素再多，增删一个，只要让其前后的元素重新相连即可，线程是不同步的。 3）Vector(JDK1.0):底层数据结构是数组数据结构.特点是查询和增删速度都很慢。默认长度是10，当超过长度时,按100%延长集合长度。线程同步。(Vector功能跟ArrayList功能一模一样，已被ArrayList替代)。

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

1、ArrayList:

package day14;import java.util.ArrayList;import java.util.Iterator;/* * 将自定义对象作为元素存到ArrayList集合中，并去除重复元素， * 比如: 存人对象。同姓名同年龄，视为同一个人，为重复元素 * 思路： * 1，对人描述，将数据封装进人对象。 * 2，定义容器，将人存入 * 3，取出 * List集合判断元素是否相同，依据的是元素的equals方法。 */class Person{private String name;private int age;Person(String name,int age){this.name=name;this.age=age;}public boolean equals(Object obj){if(!(obj instanceof Person))return false;Person p=(Person)obj;System.out.println(this.name+"....."+p.name);return this.name.equals(p.name)&&this.age==p.age;}/**/public String getName(){return name;}public int getAge(){return age;}}class ArrayListTest2 {public static void sop(Object obj){System.out.println(obj);}public static void main(String[] args){ArrayList al=new ArrayList();al.add(new Person("lisi01",30));//al.add(new Person("lisi02",32));al.add(new Person("lisi03",33));al.add(new Person("lisi04",35));al.add(new Person("lisi02",32));//al.add(new Person("lisi03",33));//al=singleElement(al);//去除重复元素//contains、、remove用的全是equal进行比较的sop("remove 03:"+al.remove(new Person("lisi03",33)) );//删除（“lisi03”，33）这个对象Iterator it=al.iterator();while(it.hasNext()){Person p=(Person)it.next();sop(p.getName()+"...."+p.getAge());}}public static ArrayList singleElement(ArrayList al){//定义一个临时容器ArrayList newAl=new ArrayList();Iterator it =al.iterator();while(it.hasNext()){Object obj=it.next();if(!newAl.contains(obj))//调用一次contains则contains在内部调用一次equals比较一次  newAl.add(obj);}return newAl;}}

2、LinkedList

package day14;/* LinkedList:特有方法： addFrist(); addLast();  getFrist(); getLast(); 获取元素，但是不删除元素  removeFrist(); removeLast()； 获取元素，但是元素被删除了,如果集合中没有元素会出现异常  在TDK1.6出现了替代方法  offerFirst()； offerLast();   peekFrist(); peekLast(); 获取元素，但不元素被删除了,如果集合中没有元素返回null  pollFist(); pollList(); 获取元素，但是元素被删除了,如果集合中没有元素返回null*/import java.util.LinkedList;class LinkedListDemo {public static void main(String[] args) {LinkedList link=new LinkedList();link.addLast("java01");link.addLast("java02");link.addLast("java03");link.addLast("java04");//sop(link)//sop(link.getFirst());//sop(link.getFirst());//sop(link.getLast());  //sop(link.removeFirst());//sop(link.removeFirst());//sop("size="+link.size());while(!link.isEmpty()){sop(link.removeLast());}}public static void sop(Object obj){System.out.println(obj);}}

1）使用LinkedList模拟一个堆栈或者一个队列数据结构
 堆栈：先进后出  如同一个杯子
 队列：先进先出 Fist in Fist out FIFo 如同一个水管。

class DuiLie{private LinkedList link;DuiLie(){link=new LinkedList();}public void myAdd(Object obj){link.addFirst(obj);}public Object myGet(){return link.removeFirst();}public boolean isNull(){return link.isEmpty();}}class LinkedListTest {public static void main(String[] args){DuiLie dl=new DuiLie();dl.myAdd("java01");dl.myAdd("java02");dl.myAdd("java03");dl.myAdd("java04");while(!dl.isNull()){System.out.println(dl.myGet());}}}

2、
  |--Lise：元素是有序的，元素师可以重复的，因为该集合体系有索引
  |--ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快，但是增减稍慢。线程不同步
  |--LinkedList:底层使用的是链表数据结构。特点：查询速度稍慢，增删速度很快。
  |--Vector：底层是数组数据结构，线程时同步的。
  |--Set：元素是无需的，元素不可以重复
  List：
  特有方法：凡是可以操作角标的方法都是该体系特有的方法
 增
 add(index,element);
 addAll(index,Collection);
 删
 remove(index);
 改
 set(index,element); 
 查
  get(index);
  subList(form,to);
  ListIterator();
List集合特有的迭代器，ListIterator是Inerator的子接口，在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生异常，所以，在迭代式，只能用迭代器的方法错做元素，可是Interator方法是有限的，只能对元素进行判断，取出，删除的操作，如果想要其他的操作如，修改，添加就需要使用其子接口，ListIterator，该接口只能通过List集合listIterator方法获取

import java.util.*;class ListDemo {public static void sop(Object obj){System.out.println(obj);}public static void method(){//创建一个集合容器，使用Collection接口的子类，ArrayListArrayList al=new ArrayList();//添加元素al.add("java01");al.add("java02");al.add("java03");al.add("java04");sop("原集合是："+al);//在指定位置添加元素。al.add(1,"java00");//删除指定位置的元素//al.remove(2);//修改元素al.set(2, "java0_0");//通过角标获取元素sop("get(1)"+al.get(1));sop(al);//获取所有元素for(int x=0;x<al.size();x++){System.out.println("al("+x+")="+al.get(x));}Iterator it=al.iterator();while(it.hasNext()){sop("next:"+it.next());}//通过indexof获取对象的位置sop("index=:"+al.indexOf("java0_0"));List sub=al.subList(1, 3);sop("sub="+sub);}public static void main(String[] args){//演示列表迭代器。ArrayList al=new ArrayList();//添加元素al.add("java01");al.add("java02");al.add("java03");al.add("java04");sop(al);ListIterator li=al.listIterator();//sop("hasPrevious:"+li.hasPrevious());while(li.hasNext()){Object obj=li.next();if(obj.equals("java02"))//li.add("java009");li.set("java006");}while(li.hasPrevious()){sop("prev::"+li.previous());}//sop("haeNext():"+li.hasNext());//sop("hasPrevious():"+li.hasPrevious());sop(al);/*//在迭代过程过中，准备添加或者删除元素Iterator it=al.iterator();while(it.hasNext()){Object obj=it.next();if(obj.equals("java02"))it.remove();//将java02的引用从集合中删除了sop("obj="+obj);}sop(al);*/}}

1）枚举就是Vector特有的取出方式

枚举就是Vector特有的取出方式。
发现枚举和迭代器很像，其实枚举和迭代式一样的，因为枚举的名称以及方法的名称都过长，所以被迭代器取代了，枚举郁郁而终了。

import java.util.Enumeration;import java.util.Vector;class VectorDemo {public static void main(String[] args){Vector v=new Vector();v.add("java01");v.add("java02");v.add("java03");v.add("java04");Enumeration en=v.elements();while(en.hasMoreElements()){System.out.println(en.nextElement());}}}

五、 Map集合

Map集合：该集合存储键值对，一对一对往里存，而且要保证键的唯一性
1，添加
put(K key,V value)
putAll(Map<？ extends k,? extends V>m)
2，删除
clear()
remove(Object key)
3，判断
containsValue(Object value)
containsKey(Object key)
isEmpty()
4，获取
get(Object key)
size()
values()

entrySet()
keySet()

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

|--hashMap：底层是哈希表数据结构的，允许使用null值和null键，该集合是不同步的。

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

Map和Set很像
Set底层就是使用了Map集合。

import java.util.*;class MapDemo {public static void main(String[] args) {Map<String,String>map=new HashMap<String,String>();//添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键的对应值。System.out.println("put:"+map.put("01","zahngsan"));System.out.println("put:"+map.put("01","wangwu "));//添加元素map.put("01","lisi1");map.put("02","lisi2");map.put("03","lisi3");map.put("04","lisi4");System.out.println("containsKey:"+map.containsKey("090"));//System.out.println("remove:"+map.remove("02"));System.out.println("get:"+map.get("03"));//可以通过get方法的返回值来判断一个键是否存在，通过返回null来判断map.put("06",null);System.out.println("get:"+map.get("06"));//获取Map集合中所有的值Collection<String> coll=map.values();System.out.println(coll);System.out.println(map);}}

map集合的两种取出方式：
1，key<k>keySet：
将map中所有的键存入到Set集合，因为Set集合具备迭代器，
所以可以通过迭代方式取出所有的键在根据get方法获取每一个键对应的值。
Map集合的取出原理：将map集合转成Set集合，在 通过迭代器取出
2，Set<Map.Entry<k,v>> entrySet：将Map集合中的映射关系存入到了set集合中，
而这个关系的数据类型就是：Map.Entry

import java.util.*;public class MapDemo2 {public static void main(String[] args) {Map<String,String>map=new HashMap<String,String>();map.put("01","lisi01");map.put("02","lisi02");map.put("06","lisi06");map.put("04","lisi04");//将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();String key=me.getKey();String value=me.getValue();System.out.println(key+"::"+value);}/*//先获取map集合中所有键的Set集合，keySet();Set<String>keySet=map.keySet();//有了Set集合，就可以获取其迭代器。Iterator<String>it=keySet.iterator();while(it.hasNext()){String key=it.next();//有了键可以通过map集合的get方法获取其对应的值。String value=map.get(key);System.out.println("key:"+key+"value:"+value);}*/}}/*   Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口。  *//*interface Map{public static interface Entry{public abstract Object getKey();public abstract Object getValue();}}class HashMap implements Map{class Hahs implements Map.Entry{public abstract Object getKey(){}public abstract Object getValue(){}}}*/

 Map扩展知识。
 Map集合被使用时因为具备映射关系。
 “yureban” Student( “01”  “zhangsan”)
 “yureban” Student( “02”   “lisi” )
 
 “jiuye”   “01”   “wangwu”
 “jiuye”   “02”   “zhaoliu”
 一个学校有多个教室，每个教室都有名称。

import java.util.*;class MapDemo3{public static void main(String[] args) {HashMap<String,HashMap<String,String>>czbk=new HashMap<String,HashMap<String,String>>();//先创建学校HashMap<String,String>yure=new HashMap<String,String>();//再创建教室HashMap<String,String>jiuye=new HashMap<String,String>();//再创建教室czbk.put("yureban",yure);czbk.put("jiuye",jiuye);yure.put("01","zhangsan");yure.put("02","lisi");jiuye.put("01","zhaoliu");  jiuye.put("02","wangwu");//遍历czbk集合，获取所有的教室。Iterator<String>it=czbk.keySet().iterator();while(it.hasNext()){String roomName=it.next();HashMap<String,String>room=czbk.get(roomName);System.out.println(roomName);getStudentInfo(room);}//getStudentInfo(jiuye);}public static void getStudentInfo(HashMap<String,String>roomMap){Iterator<String>it=roomMap.keySet().iterator();while(it.hasNext()){String id=it.next();String name=roomMap.get(id);System.out.println(id+"::"+name);}}}

 需求：对学生对象的年龄进行升序排序
 因为要使用可以排序的Map集合。 TreeMap

import java.util.*;class StuNameComparator implements Comparator<Student>{public int compare(Student s1,Student s2){int  num=s1.getName().compareTo(s2.getName());if(num==0)return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));return num;}}class MapTest1{public static void main(String[] args) {TreeMap<Student,String>tm=new TreeMap<Student,String>(new StuNameComparator());tm.put(new Student("aisi1",21), "beijin");tm.put(new Student("disi6",26), "shanghai");tm.put(new Student("fisi3",23), "nanjing");tm.put(new Student("gisi2",22),"tianjin");tm.put(new Student("disi6",26), "shanghai");Set<Map.Entry<Student,String>>entrySet=tm.entrySet();Iterator<Map.Entry<Student,String>>it=entrySet.iterator();while(it.hasNext()){Map.Entry<Student,String> me=it.next();Student stu=me.getKey();String addr=me.getValue();System.out.println(stu+"--------"+addr);}}}

package day16;/* 每一个学生都有对应的归属地 学生属性：姓名，年龄 注意：姓名和年龄相同的视为同一个学生 保证学生的唯一性 1，描述学生。 2，定义Map容器，将学生作为键，地址作为值，存入 3，保证学生的唯一性。 */import java.util.*;class Student implements Comparable<Student>{private String name;private int age;Student(String name,int age){this.name=name;this.age=age;}public int compareTo(Student s){int num=new Integer(this.age).compareTo(new Integer(s.age));if(num==0){return this.name.compareTo(s.name);return num;}}public int hashCode(){return name.hashCode()+age*43;}public boolean equals(Object obj){if(!(obj instanceof Student))throw new ClassCastException("类型不匹配");Student s=(Student)obj;return this.name.equals(s.name)&&this.age==s.age;}public String getName(){return name;}public int getAge(){return age;}public String toString(){return name+"::"+age;}}class MapTest {public static void main(String[] args){HashMap<Student,String>hm=new HashMap<Student,String>();hm.put(new Student("lisi1",21), "beijin");hm.put(new Student("lisi2",22), "shanghai");hm.put(new Student("lisi3",23), "nanjing");hm.put(new Student("lisi4",24), "wuhan");//第一种取出方式 keySetSet<Student>keySet=hm.keySet();Iterator<Student>it=hm.keySet().iterator();while(it.hasNext()){Student stu=it.next();String addr=hm.get(stu);System.out.println(stu+"::"+addr);}//第二种取出方式 entrySetSet<Map.Entry<Student,String>>entrySet=hm.entrySet();Iterator<Map.Entry<Student, String>>iter=entrySet.iterator(); while(iter.hasNext()){Map.Entry<Student,String>me=iter.next();Student stu=me.getKey();String addr=me.getValue();System.out.println(stu+"........"+addr);}}}

集合变数组

package day17;/* 集合变数组。  */import java.util.*;class CollectionToArray {public static void main(String[] args) {ArrayList<String>al=new ArrayList<String>();al.add("absc01");al.add("absc02");al.add("absc03");al.add("absc04");/* 1,指定类型的数组到底要定义多长呢？ 当指定类型的数组长度小于集合的Size，那么该方法内部会创建一个新的数组。长度为集合的Size 当指定类型的数组长度大于了集合的size，就不会新创建数组了，而是使用传递进来的数组。 所以创建一个刚刚好的数组最优  2,为什么要将集合变数组呢？ 为了限定对元素的操作。不需要进行增删了。 */String[] arr=al.toArray(new String[al.size()]);System.out.println(Arrays.toString(arr));}}

六、迭代器与迭代列表

 1)迭代器：Iterator(Map集合没有迭代器)

(1)迭代器就是取出集合元素的方式

(2)迭代器的作用

因为每个集合中元素的取出方式都不一样，于是就把元素的取出方式进行抽取，并定义在集合内部，

这样取出方式就可以直接访问集合内部的元素；

而每个容器的数据结构不同，所以取出动作的细节也不一样，但是有共性内容：判断和取出。

那么就将共性内容进行抽取，从而形成了接口Iterater

(3)获取迭代器的方法：

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

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

(3)迭代器方法：

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

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

void remove() 从迭代器指向的collection中移除迭代器返回的最后一个元素（可选操作）。

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

while(it.hasNext())

{

Person p = it.next();

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

}

2)列表迭代器：（List集合特有的迭代器）ListIterator

(1)List集合特有的迭代器ListIterator是Iterator的子接口，在迭代时，不可以通过集合对象的

      方法操作集合中的元素，因为会发生ConcurrentModificationException(当方法检测到对象的并发修改，

       但不允许这种修改时，抛出此异常)

(2)Iterator方法有限，只能对元素进行判断、取出和删除的操作

       ListIterator可以对元素进行添加和修改动作等。

(3)获取列表迭代器方法：

ListIterator<E> listIterator() 返回此列表元素的列表迭代器（按适当顺序）。 

ListIterator<E> listIterator(int index) 

返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。 

(4)列表迭代器方法：

void add(E e) 将指定的元素插入列表（可选操作）。

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

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

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

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

void set(E e) 用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。 

　　public static void listIterator()　　{　　ArrayList al = ArrayList();　　al.add(“java01”);　　al.add(“java04”);　　　　ListIterator it = al.ListIterator();　　while(it.hasNext())//向前遍历　　{　　Object obj = it.next();　　if(ibj.equals(“java02”))　　it.add(“java03”);　　}　　while(it.hasPrevious())//向后遍历　　{　　System.out.println(“pre:”+it.previous());　　}　　　　}

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