集合框架的遍历.docx

资源描述

集合框架的遍历.docx

《集合框架的遍历.docx》由会员分享，可在线阅读，更多相关《集合框架的遍历.docx（18页珍藏版）》请在冰豆网上搜索。

集合框架的遍历.docx

集合框架的遍历

类集框架及容器遍历

·类框架的最大接口：

Collection、Map、Iterator、Enumeration

·Collection：

存放单值

|-List：

允许重复值

|-ArrayList：

异步处理，非线程安全，新的

|-Vector:

同步处理，线程安全，支持Enumeration输出，旧的

|-Set：

不允许有重复内容，考hashCode（）和equals（）进行重复验证

|-HashSet：

无序存放

|-TreeSet：

有序存放，按Comparable排序

·Map：

存放一对值

|-HashMap：

新的类，异步处理，非线程安全，允许null

|-HashTable:

旧的类，同步处理，非线程安全，不允许null

|-TreeMap：

有序排列，按key排序，按Comparable排序

·Iterator：

|-迭代输出，依靠Collection和Map中的Iterator方法输出，是新的输出标准

·Enumeration：

旧的输出操作

所有的Collection都可以用一下3种方法遍历：

1.for（inti=0;i

Strings=c.get（i）;

System.out.println（s）;

}

2.for（Strings:

c）{

System.out.println（s）;

}

3.Iteratori=c.iterator（）;

while（i.hasNext（））{

System.out.println（i.next（））;

}

而Map可用一下2种方法

//JDK1.5

Mapmap=newHashMap（）;

for（Objectobj:

map.keySet（））{

Objectkey=obj;

Objectvalue=map.get（obj）;

}

//JDK1.4

Mapmap= newHashMap（） ;

Iteratoriter=map.entrySet（）.iterator（）;

while（iter.hasNext（））{

Map.Entryentry=（Map.Entry）iter.next（）;

Objectkey=entry.getKey（）;

Objectvalue=entry.getValue（）;

}

一、Map的遍历

viewplaincopytoclipboardprint?

·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150

importjava.util.HashMap;

importjava.util.Iterator;

importjava.util.Map;

/**

*Map的遍历，这个遍历比较特殊，有技巧

*@authorleizhimin2009-7-2215:

15:

publicclassTestMap{

publicstaticvoidmain（String[]args）{

Mapmap=newHashMap（）;

map.put（"1","a"）;

map.put（"2","b"）;

map.put（"3","c"）;

//最简洁、最通用的遍历方式

for（Map.Entryentry:

map.entrySet（））{

System.out.println（entry.getKey（）+"="+entry.getValue（））;

}

//Java5之前的比较简洁的便利方式1

System.out.println（"----1----"）;

for（Iterator>it=map.entrySet（）.iterator（）;it.hasNext（）;）{

Map.Entryentry=it.next（）;

System.out.println（entry.getKey（）+"="+entry.getValue（））;

}

//Java5之前的比较简洁的便利方式2

System.out.println（"----2----"）;

for（Iteratorit=map.keySet（）.iterator（）;it.hasNext（）;）{

Stringkey=it.next（）;

System.out.println（key+"="+map.get（key））;

}}}

importjava.util.HashMap;

importjava.util.Iterator;

importjava.util.Map;

/**

*Map的遍历，这个遍历比较特殊，有技巧

*@authorleizhimin2009-7-2215:

15:

publicclassTestMap{

publicstaticvoidmain（String[]args）{

Mapmap=newHashMap（）;

map.put（"1","a"）;

map.put（"2","b"）;

map.put（"3","c"）;

//最简洁、最通用的遍历方式

for（Map.Entryentry:

map.entrySet（））{

System.out.println（entry.getKey（）+"="+entry.getValue（））;

}

//Java5之前的比较简洁的便利方式1

System.out.println（"----1----"）;

for（Iterator>it=map.entrySet（）.iterator（）;it.hasNext（）;）{

Map.Entryentry=it.next（）;

System.out.println（entry.getKey（）+"="+entry.getValue（））;

}

//Java5之前的比较简洁的便利方式2

System.out.println（"----2----"）;

for（Iteratorit=map.keySet（）.iterator（）;it.hasNext（）;）{

Stringkey=it.next（）;

System.out.println（key+"="+map.get（key））;}}}

二、Queue的遍历

viewplaincopytoclipboardprint?

importjava.util.Queue;

importjava.util.concurrent.LinkedBlockingQueue;

/**

*队列的遍历

*@authorleizhimin2009-7-2215:

05:

publicclassTestQueue{

publicstaticvoidmain（String[]args）{

Queueq=newLinkedBlockingQueue（）;

//初始化队列

for（inti=0;i<5;i++）{

q.offer（i）;

}

System.out.println（"-------1-----"）;

//集合方式遍历，元素不会被移除

for（Integerx:

q）{

System.out.println（x）;

}

System.out.println（"-------2-----"）;

//队列方式遍历，元素逐个被移除

while（q.peek（）!

=null）{

System.out.println（q.poll（））;}

}

importjava.util.Queue;

importjava.util.concurrent.LinkedBlockingQueue;

/**

*队列的遍历

*@authorleizhimin2009-7-2215:

05:

publicclassTestQueue{

publicstaticvoidmain（String[]args）{

Queueq=newLinkedBlockingQueue（）;

//初始化队列

for（inti=0;i<5;i++）{

q.offer（i）;

}

System.out.println（"-------1-----"）;

//集合方式遍历，元素不会被移除

for（Integerx:

q）{

System.out.println（x）;

}

System.out.println（"-------2-----"）;

//队列方式遍历，元素逐个被移除

while（q.peek（）!

=null）{

System.out.println（q.poll（））;}}}

三、Stack的遍历

viewplaincopytoclipboardprint?

importjava.util.Stack;

/**

*栈的遍历

*@authorleizhimin2009-7-2214:

55:

publicclassTestStack{

publicstaticvoidmain（String[]args）{

Stacks=newStack（）;

for（inti=0;i<10;i++）{

s.push（i）;

}

//集合遍历方式

for（Integerx:

s）{

System.out.println（x）;

}

System.out.println（"------1-----"）;

//栈弹出遍历方式

//while（s.peek（）!

=null）{//不健壮的判断方式，容易抛异常，正确写法是下面的

while（!

s.empty（））{

System.out.println（s.pop（））;

}

System.out.println（"------2-----"）;

//错误的遍历方式

//for（Integerx:

s）{

//System.out.println（s.pop（））;

//}

}

importjava.util.Stack;

/**

*栈的遍历

*@authorleizhimin2009-7-2214:

55:

publicclassTestStack{

publicstaticvoidmain（String[]args）{

Stacks=newStack（）;

for（inti=0;i<10;i++）{

s.push（i）;

}

//集合遍历方式

for（Integerx:

s）{

System.out.println（x）;

}

System.out.println（"------1-----"）;

//栈弹出遍历方式

//while（s.peek（）!

=null）{//不健壮的判断方式，容易抛异常，正确写法是下面的

while（!

s.empty（））{

System.out.println（s.pop（））;}

System.out.println（"------2-----"）;

//错误的遍历方式

//for（Integerx:

s）{

//System.out.println（s.pop（））;

//}}}

4。

ArrayList遍历的4种方法

viewplaincopytoclipboardprint?

packagecom.test;

importjava.util.ArrayList;

importjava.util.Iterator;

importjava.util.List;

publicclassArrayListDemo{

publicstaticvoidmain（Stringargs[]）{

Listlist=newArrayList（）;

list.add（"luojiahui"）;

list.add（"luojiafeng"）;

//方法1

Iteratorit1=list.iterator（）;

while（it1.hasNext（））{

System.out.println（it1.next（））;

}

//方法2

for（Iteratorit2=list.iterator（）;it2.hasNext（）;）{

System.out.println（it2.next（））;

}

//方法3

for（Stringtmp:

list）{

System.out.println（tmp）;

}

//方法4

for（inti=0;i

System.out.println（list.get（i））;}}}

Java集合框架（Collection）和数组的排序

首先要知道两个类:

java.util.Arrays和java.util.Collections（注意和Collection的区别）Collection是集合框架的顶层接口，而Collections是包含了许多静态方法。

我们使用Arrays对数组进行排序，使用Collections对结合框架容器进行排序，如ArraysList,LinkedList等。

1.对数组进行排序

　　比如有一个整型数组:

viewplaincopytoclipboardprint?

int[]intArray=newint[]{4,1,3,-23};

　　我们如何进行排序呢？

你这个时候是否在想快速排序的算法？

看看下面的实现方法:

viewplaincopytoclipboardprint?

importjava.util.*;

publicclassSort{

publicstaticvoidmain（String[]args）{

int[]intArray=newint[]{4,1,3,-23};

Arrays.sort（intArray）;}}

importjava.util.*;

publicclassSort{

publicstaticvoidmain（String[]args）{

int[]intArray=newint[]{4,1,3,-23};

Arrays.sort（intArray）;}}

　　这样我们就用Arrays的静态方法sort（）对intArray进行了升序排序，现在数组已经变成了{-23,1,3,4}.

　　如果是字符数组:

viewplaincopytoclipboardprint?

String[]strArray=newString[]{"z","a","C"};

　　我们用:

viewplaincopytoclipboardprint?

Arrays.sort（strArray）;

　　进行排序后的结果是{C,a,z},sort（）会根据元素的自然顺序进行升序排序。

如果希望对大小写不敏感的话可以这样写:

viewplaincopytoclipboardprint?

Arrays.sort（strArray,String.CASE_INSENSITIVE_ORDER）;

　　当然我们也可以指定数组的某一段进行排序比如我们要对数组下表0-2的部分（假设数组长度大于3）进行排序，其他部分保持不变，我们可以使用:

viewplaincopytoclipboardprint?

Arrays.sort（strArray,0,2）;

　　这样，我们只对前三个元素进行了排序，而不会影响到后面的部分。

　　当然有人会想，我怎样进行降序排序？

在众多的sort方法中有一个

viewplaincopytoclipboardprint?

sort（T[]a,Comparator

superT>c）

sort（T[]a,Comparator

superT>c）

　　我们使用Comparator获取一个反序的比较器即可，Comparator会在稍后讲解，以前面的intArray[]为例:

viewplaincopytoclipboardprint?

Arrays.sort（intArray,Comparator.reverseOrder（））;

　　这样，我们得到的结果就是{4,3,1,-23}。

如果不想修改原有代码我们也可以使用:

viewplaincopytoclipboardprint?

Collections.reverse（Arrays.asList（intArray））;

　　得到该数组的反序。

结果同样为4,3,1,-23}。

　　现在的情况变了，我们的数组里不再是基本数据类型（primtivetype）或者String类型的数组，而是对象数组。

这个数组的自然顺序是未知的，因此我们需要为该类实现Comparable接口，比如我们有一个Name类:

viewplaincopytoclipboardprint?

classNameimplementsComparable{

publicStringfirstName,lastName;

publicName（StringfirstName,StringlastName）{

this.firstName=firstName;

this.lastName=lastName;}

publicintcompareTo（Nameo）

展开阅读全文