[t]java集合类[/t]
上述类图中，实线边框的是实现类，比如ArrayList，LinkedList，HashMap等，折线边框的是抽象类，比如AbstractCollection，AbstractList，AbstractMap等，而点线边框的是接口，比如Collection，Iterator，List等。
发现一个特点，上述所有的集合类，都实现了Iterator接口，这是一个用于遍历集合中元素的接口，主要包含hashNext(),next(),remove()三种方法。它的一个子接口LinkedIterator在它的基础上又添加了三种方法，分别是add(),previous(),hasPrevious()。也就是说如果是先Iterator接口，那么在遍历集合中元素的时候，只能往后遍历，被遍历后的元素不会在遍历到，通常无序集合实现的都是这个接口，比如HashSet，HashMap；而那些元素有序的集合，实现的一般都是LinkedIterator接口，实现这个接口的集合可以双向遍历，既可以通过next()访问下一个元素，又可以通过previous()访问前一个元素，比如ArrayList。

		是否有序	是否允许元素重复
Collection		否	是
List		是	是
Set	AbstractSet	否	否
	HashSet	否
	TreeSet	是（用二叉排序树）
Map	AbstractMap	否	使用key-value来映射和存储数据，key必须唯一，value可以重复
	HashMap	否
	TreeMap	是（用二叉排序树）

[t]HashSet[/t]

HashSet是Set接口的一个子类，主要的特点是：里面不能存放重复元素，而且采用散列的存储方法，所以没有顺序。这里所说的没有顺序是指：元素插入的顺序与输出的顺序不一致。

package cn.bcoder; import java.util.*; public class Example5 {


public static void main(String[] args) {

Set<String>set=new HashSet<String>();

Iterator<String>iter=set.iterator(); //使用迭代器输出

set.add("b");

set.add("c");

set.add("o");

set.add("d");

set.add("e");

set.add("r");

set.add("r");

while(iter.hasNext()){

System.out.println(iter.next()+" ");

}
//使用ForEach输出

for(String e:set )

System.out.println(e+" ");

System.out.println(set); //调用toString输出
}

}

[t]ArrayList[/t]

ArrayList是List的子类，它和HashSet想法，允许存放重复元素，因此有序。集合中元素被访问的顺序取决于集合的类型。如果对ArrayList进行访问，迭代器将从索引0开始，每迭代一次，索引值加1。然而，如果访问HashSet中的元素，每个元素将会按照某种随机的次序出现。虽然可以确定在迭代过程中能够遍历到集合中的所有元素，但却无法预知元素被访问的次序。

package cn.bcoder;


import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;
public class Example {

public static void main(String[] args) {

List<String> arrList=new ArrayList<String>();
arrList.add("a");

arrList.add("b");

arrList.add("c");

arrList.add("c");

arrList.add("d");
//使用Iterator输出集合

Iterator<String> iter=arrList.iterator();

while(iter.hasNext())

{

System.out.print(iter.next()+" ");

}

System.out.println();

//使用For Each输出结合

for(String e:arrList)

{

System.out.print(e+" ");

}

System.out.println();

//使用toString输出集合 System.out.println(arrList); } }

[t]LinkedList[/t]

LinkedList是一种可以在任何位置进行高效地插入和删除操作的有序序列。

package cn.bcoder; import java.util.*; public class Example1 {


public static void main(String[] args) {

//@author Coder.bng

List <String>list=new LinkedList<String>();

list.add("Coder.bing");

list.add("wangzheng");

list.add("bingfeng");

list.add("bcoder");

ListIterator <String>iter=list.listIterator();

iter.next();

iter.remove(); //remove Coder.bing
for(String s:list)

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

iter.add("小学生");
iter=list.listIterator();

while(iter.hasNext()){

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

}

} }

package cn.bcoder; import java.util.Iterator; import java.util.LinkedList; public class Example2 { public static void main(String args[]){ LinkedList <Integer>lin=new LinkedList<Integer>();


for(int i=0;i<10;i++)

lin.add(i);

System.out.println(lin.getFirst());

System.out.println(lin.getLast());

System.out.println(lin.peek()); // ==getLast

System.out.println(lin.remove());
}

}

[t]HashMap – 散列映射[/t]

HashMap<K,V>泛型类实现了泛型接口Map<K,V>，HashMap<K,V>类中绝大部分方法都是Map<K,V>接口方法的实现。

HashMap<K,V>对象采用散列表这种数据结构存储数据，习惯上称HashMap<K,V>对象为散列映射。散列映射用于存储键/值对.

——MapDemo.java——————————————————————————–
package cn.bcoder;


import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;
public class MapDemo {
	public static void main(String[] args) {

		Mapmap=new HashMap();
		map.put("name","wangzheng");

		map.put("ID","8221113023");

		map.put("qq","739696033");

		System.out.println(map);  // 调用toString()

		String str=map.get("name");

		System.out.println(str);  // output: wangzheng
		if(map.containsKey("name"))  //判断键是否存在

			System.out.println("键存在");

		else

			System.out.println("键不存在");

		if(map.containsValue("739696033"))  //判断值是否存在

			System.out.println("值存在");

		else

			System.out.println("不存在");
	Collectionc=map.values();   //values(): 返回此映射中包含的值的 Collection 视图。

	Iteratori=c.iterator();  //迭代器输出hashmap的值

	while(i.hasNext()){

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

	}
	}

}

——Example7.java———–

package cn.bcoder;


public class Example7 {
public static void main(String[] args) {

WindowWord win=new WindowWord();

win.setTitle("英-汗小字典");
}

}

——WindowWord.java———-

package cn.bcoder; import java.awt.FlowLayout; import java.awt.event.ActionListener;


import javax.swing.JFrame;

import javax.swing.JTextField;
public class WindowWord extends JFrame{

JTextField inputText,showText;

WordPolice police;

WindowWord(){

setLayout(new FlowLayout());

inputText=new JTextField(6);

showText=new JTextField(6);

add(inputText);

add(showText);

police=new WordPolice();

police.setJTextField(showText);

inputText.addActionListener((ActionListener) police);

setBounds(100,100,400,280);

setVisible(true);

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}

}

——-WordPolice.java———-

package cn.bcoder; import java.util.HashMap; import java.util.Scanner;


import javax.swing.JTextField;

import javax.swing.JTextField;

import java.io.File;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;
public class WordPolice implements ActionListener{

JTextField showText;

HashMap<String,String>hashtable;

File file=new File("word.txt");

Scanner sc=null;

WordPolice() {

hashtable=new HashMap<String,String >();

try{sc=new Scanner(file);

while(sc.hasNext()){

String englishWord=sc.next();

String chineseWord=sc.next();

hashtable.put(englishWord,chineseWord);

}
}

catch(Exception e) {
}
}

@Override

public void actionPerformed(ActionEvent e) {

// TODO 自动生成的方法存根

String englishWord=e.getActionCommand();

if(hashtable.containsKey(englishWord)){

String chineseWord=hashtable.get(englishWord);

showText.setText(chineseWord);

}

else

{

showText.setText("没有此单词.");

}
}

public void setJTextField(JTextField showText) {

// TODO 自动生成的方法存根

this.showText=showText;
}