java常用的数据结构及其遍历方法

秃头第一步，开始写博客

ArrayList

package dataStructure;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ArrayListTest {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("拉菲");
		list.add("光辉");
		list.add("企业");
		System.out.println(list.size());
		
		//For-Each遍历List
		for (String str : list) {
			System.out.print(str+" ");
		}
		
		//把链表变为数组相关的内容进行遍历
		String[] strArray = new String[list.size()];
		list.toArray(strArray);
		System.out.println("\n"+strArray.length);
		for (int i = 0; i < strArray.length ; i++) {
			System.out.print(strArray[i]+" ");
		}
		
		//迭代器进行遍历
		System.out.println("\n"+list.size());
		//该方法可以不用担心在遍历的过程中会超出集合的长度
		Iterator<String> ite = list.iterator();
		while (ite.hasNext()) {
			System.out.print(ite.next()+" ");

		}
	}

}

BitSet

package dataStructure;

import java.util.BitSet;

/*
 * 位集合类实现了一组可以单独设置和清除的位或标志。
该类在处理一组布尔值的时候非常有用，你只需要给每个值赋值一"位"，然后对位进行适当的设置或清除，就可以对布尔值进行操作了。
*/
public class BitSetDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		/*
		 * 第一个构造方法创建一个默认的对象：
		 * BitSet()
		 * 第二个方法允许用户指定初始大小。所有位初始化为0。
		 * BitSet(int size)
		 */
		BitSet bits1 = new BitSet(16);
		BitSet bits2 = new BitSet(16);
		System.out.println(bits1+"\n"+bits2);
		
		for(int i=0;i<16;i++) {
			if((i%2)==0) bits1.set(i);
			if((i%2)!=0) bits2.set(i);//将指定索引处的位设置为 true
		}
		System.out.println(bits1+"\n"+bits2);
		
		bits2.and(bits1);
		System.out.println(bits1+"\n"+bits2);
		
		bits2.or(bits1);
		System.out.println(bits1+"\n"+bits2);
		
		bits2.xor(bits1);
		System.out.println(bits1+"\n"+bits2);
		
	}

}

Enumeration

package dataStructure;

import java.util.Enumeration;
import java.util.Vector;

/*枚举（The Enumeration）接口定义了一种从数据结构中取回连续元素的方式。*/
public class EnumerationTester {
	public static void main(String[] args) {
		Enumeration<String> days;
		
		Vector<String> dayNames = new Vector<String>();
		
		dayNames.add("one");
		dayNames.add("two");
		dayNames.add("three");
		
		days = dayNames.elements();
		
		while(days.hasMoreElements()) {
			System.out.println(days.nextElement());
		}

	}
}

Map

package dataStructure;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

public class MapTest {
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<String, String>();
		map.put("1", "欧根");
		map.put("2", "贝尔");
		map.put("3", "爱宕");
		
		//普遍使用，二次取值
		System.out.println("通过Map.keySet遍历key和value： ");
		for (String key : map.keySet()) {
			System.out.println("key= "+key+ " and value= "+map.get(key));
		}
		
		//第二种
		System.out.println("通过Map.entrySet使用iterator遍历key和value： ");
		Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
		while(it.hasNext()) {
			Map.Entry<String, String> entry =it.next();
			System.out.println("key= "+ entry.getKey() + " and value= "+entry.getValue());
		}
		
		//推荐，尤其容量大时
		System.out.println("通过Map.entrySet遍历key和value");
		for (Map.Entry<String, String> entry: map.entrySet()) {
			System.out.println("key= "+entry.getKey()+" and value= "+entry.getValue());
		}
		
		//第四种
		System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
		for (String v : map.values()) {
			System.out.println("value= "+v);
		}
	}

}

Stack

package dataStructure;

import java.util.EmptyStackException;
import java.util.Stack;

/*栈（Stack）实现了一个后进先出（LIFO）的数据结构。
你可以把栈理解为对象的垂直分布的栈，当你添加一个新元素时，就将新元素放在其他元素的顶部。
当你从栈中取元素的时候，就从栈顶取一个元素。换句话说，最后进栈的元素最先被取出。*/

/*栈是Vector的一个子类，它实现了一个标准的后进先出的栈。
堆栈只定义了默认构造函数，用来创建一个空栈。 
堆栈除了包括由Vector定义的所有方法，也定义了自己的一些方法。
Stack()*/

public class StackDemo {
	static void showpush(Stack<Integer> st, int a) {
		st.push(new Integer(a));
		System.out.println("push( "+ a+ " )");
		System.out.println("stack: "+st);
	}
	
	static void showpop(Stack<Integer> st) {
		System.out.println("pop -> ");
		Integer a = (Integer) st.pop();
		System.out.println(a);
		System.out.println("stack: "+st);
	}
	public static void main(String[] args) {
		Stack<Integer> st = new Stack<Integer>();
		System.out.println("stack: "+st);
		showpush(st, 42);
		showpush(st, 66);
		showpush(st, 99);
		showpop(st);
		showpop(st);
		showpop(st);
		try {
			System.out.println("异常");
			showpop(st);
		}catch (EmptyStackException e) {
			// TODO: handle exception
			System.out.println("空栈");
		}
	}
}

Vector

package dataStructure;

import java.util.Enumeration;
import java.util.Vector;

/*
 * 向量（Vector）类和传统数组非常相似，但是Vector的大小能根据需要动态的变化。、
 * 和数组一样，Vector对象的元素也能通过索引访问。
 * Vector 类实现了一个动态数组。和 ArrayList 很相似，但是两者是不同的：
Vector 是同步访问的。
Vector 包含了许多传统的方法，这些方法不属于集合框架。
Vector 主要用在事先不知道数组的大小，或者只是需要一个可以改变大小的数组的情况。
*/
/*
第一种构造方法创建一个默认的向量，默认大小为 10：
Vector()
第二种构造方法创建指定大小的向量。
Vector(int size)
第三种构造方法创建指定大小的向量，并且增量用 incr 指定。增量表示向量每次增加的元素数目。
Vector(int size,int incr)
第四种构造方法创建一个包含集合 c 元素的向量：
Vector(Collection c)
*/
public class VectorDemo {
	public static void main(String[] args) {
		
		Vector v = new Vector(3,2);
		System.out.println("返回此向量中的组件数: "+v.size());
		System.out.println("返回此向量的当前容量: "+v.capacity());
		
		v.addElement(new Integer(1));//将指定的组件添加到此向量的末尾，将其大小增加 1。
		v.addElement(new Integer(2));
		v.addElement(new Integer(3));
		v.addElement(new Integer(4));
		System.out.println("添上组件后当前容量1： "+v.capacity());
		
		v.addElement(new Double(5.45));
		System.out.println("添上组件后当前容量2: "+v.capacity());
		
		v.addElement(new Double(6.08));
		v.addElement(new Integer(7));
		System.out.println("添上组件后当前容量3: "+v.capacity());
		
		v.addElement(new Float(9.4));
	    v.addElement(new Integer(10));
	    System.out.println("添上组件后当前容量4: "+v.capacity());
	    
	    v.addElement(new Integer(11));
	    v.addElement(new Integer(12));
	    System.out.println("第一个元素： "+(Integer)v.firstElement());
	    System.out.println("末一位元素： "+(Integer)v.lastElement());
	    
	    if(v.contains(new Integer(3)))
	    	System.out.println("v包含3");
	    
	    //遍历向量v
	    Enumeration vEnum = v.elements();
	    System.out.println("向量中的元素： ");
	    while (vEnum.hasMoreElements()) {
			System.out.print(vEnum.nextElement()+"  ");
			
		}
	    }

}