java基础之数据结构

浅浅的花香味﹌ 2021-09-28 02:32 364阅读 0赞

java工具包提供了强大的数据结构。在java中的数据结构主要包括以下几种接口和类：  
1）枚举（Enumeration）  
2）位集合（BitSet）  
3）向量（Vector）  
4）栈（Stack）  
5）字典（Dictionary）  
6）哈希表（HashTable）  
7）属性（Properties）  
8）集合框架（Collection）

1、枚举：

枚举（Enumeration）接口虽然它本身不属于数据结构，但是在其他数据结构的范畴里应用很广。枚举（The Enumeration）接口定义了一种从数据结构中取回连续元素的方式。

import java.util.Vector;
    import java.util.Enumeration;
    
    public class EnumTest{
    	public static void main(String[] args) {
    		Enumeration<String> people;
    		Vector<String> peopleJob= new Vector<String>();
    		peopleJob.add("Teacher");
    		peopleJob.add("Doctor");
    		people = peopleJob.elements();
    		while(people.hasMoreElements()) {//测试此枚举是否包含更多的元素
    			System.out.println(days.nextElement());//如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素
    		}
    	}
    }

运行结果

Teacher
    Doctor

2、位集合（BitSet）  
位集合实现了一组可以单独设置和清除的位或标志。  
该类在处理一组布尔值的时候非常有用，只需要给每个值赋一“位”，然后对位进行适当的设置或清除，就可以对布尔值做操作了。  
1）示例说明：

package sjjg;
    
    import java.util.BitSet;
    
    /**
     * @ClassName: BitSetTest 
     * @Description: 位集合测试，位集合实现了一组可单独设置和清除的或标志
     * @author wxy 
     * @date 2019年1月9日 下午4:50:14 
     *
     */
    public class BitSetTest {
    	
    	public static void main(String args[]) {
    		BitSet bits1 = new BitSet(16);
    		BitSet bits2 = new BitSet(16);
    		
    		System.out.println("bits1 = " + bits1);
    		System.out.println("bits2 = " + bits2);
    		
    		//设置值
    		for(int i = 0; i < 16; i ++) {
    			if((i%2) == 0) bits1.set(i);
    			if((i%5) != 0) bits2.set(i);
    		}
    		System.out.println("=================");
    		System.out.println("bits1 = " + bits1);
    		System.out.println("bits2 = " + bits2);
    		
    		//与
    		System.out.println("=================");
    		bits2.and(bits1);
    		System.out.println("bits2 and bits1 --> bits2 = " + bits2);
    		
    		//或
    		System.out.println("=================");
    		bits2.or(bits1);
    		System.out.println("bits2 or bits1 --> bits2 = " + bits2);
    		
    		//异或
    		System.out.println("=================");
    		bits2.xor(bits1);
    		System.out.println("bits2 xor bits1 --> bits2 = " + bits2);
    		
    	}
    }

2）运行结果：

bits1 = {}
    bits2 = {}
    =================
    bits1 = {0, 2, 4, 6, 8, 10, 12, 14}
    bits2 = {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14}
    =================
    bits2 and bits1 --> bits2 = {2, 4, 6, 8, 12, 14}
    =================
    bits2 or bits1 --> bits2 = {0, 2, 4, 6, 8, 10, 12, 14}
    =================
    bits2 xor bits1 --> bits2 = {}
    =================
    bits2 xor bits1 --> bits2 = {}

3、向量（Vector）  
Vector类和传统的数组类似，和数组一样Vector对象的元素也能通过索引访问，它最主要的好处就是在创建对象的时候不必给对象指定大小，它的大小能够根据需要动态的变化。  
1）示例

package sjjg;
    
    import java.util.Vector;
    
    /**
     * @ClassName: VectorTest 
     * @Description: 向量测试，Vector类和传统的数组非常相似，但是Vector的大小能根据需要动态的变化。
     * 和数组一样，Vector对象的元素也能通过索引访问。
     * 使用Vector类最主要的好处就是在创建对象的时候不必给对象指定大小，它的大小会根据需要动态的变化
     * @author wxy 
     * @date 2019年1月9日 下午5:01:57 
     */
    public class VectorTest {
    	public static void main(String args[]) {
    		Vector v = new Vector(3,2);
    		//向量长度
    		System.out.println("长度：" + v.size());
    		//向量包含内容
    		System.out.println("容量：" + v.capacity());
    		
    		System.out.println("====================");
    		v.addElement(new Integer(1));
    		v.addElement(new Integer(2));
    		v.addElement(new Integer(3));
    		System.out.println("长度：" + v.size());
    		System.out.println("容量：" + v.capacity());
    		System.out.println("====================");
    		
    		v.addElement(new Double(6.06));
    		v.addElement(new Integer(7));
    		System.out.println("长度：" + v.size());
    		System.out.println("容量：" + v.capacity());
    		System.out.println("====================");
    		
    		v.addElement(new Float(2.1));
    		v.addElement(new Integer(10));
    		System.out.println("长度：" + v.size());
    		System.out.println("容量：" + v.capacity());
    		System.out.println("====================");
    		
    		v.addElement(new Integer(11));
    		v.addElement(new Integer(12));
    		System.out.println("长度：" + v.size());
    		System.out.println("容量：" + v.capacity());
    		System.out.println("====================");
    		
    		
    		System.out.println("第一个元素：" + v.firstElement());
    		System.out.println("====================");
    		
    		System.out.println("最后一个元素：" + v.lastElement());
    		System.out.println("====================");
    		
    		if(v.contains(new Integer(3))) {
    			System.out.println("包含3");
    			System.out.println("====================");
    		}
    	}
    }

2）运行结果

长度：0
    容量：3
    ====================
    长度：3
    容量：3
    ====================
    长度：5
    容量：5
    ====================
    长度：7
    容量：7
    ====================
    长度：9
    容量：9
    ====================
    第一个元素：1
    ====================
    最后一个元素：12
    ====================
    包含3
    ====================

4、栈（Stack）  
栈是Vector的一个子类，Stack实现了一个标准的后进先出的（LIFO）的数据结构  
1）示例

package sjjg;
    
    import java.util.EmptyStackException;
    import java.util.Stack;
    
    /**
     * @ClassName: StackTest 
     * @Description: 栈是Vector的一个子类，Stack实现了一个标准的后进先出（LIFO）的数据结构
     * @author wxy 
     * @date 2019年1月10日 上午10:37:40 
     */
    public class StackTest {
    	public static void main(String[] args) {
    		Stack<Integer> st = new Stack<Integer>();
    		System.out.println("stack: " + st);
    		System.out.println("=================");
    		showpush(st, 11);
    		showpush(st, 22);
    		showpush(st, 33);
    		
    		showpeek(st);
    		
    		showpop(st);
    		showpop(st);
    		showpop(st);
    		try {
    			showpop(st);
    		} catch (EmptyStackException e) {
    			System.out.println("stact is empty");
    		}
    	}
    	
    	public static void showpush(Stack<Integer> st, int a) {
    		st.push(a);
    		System.out.println("st push " + a);
    		System.out.println("push -> " + a + " -> stact: " + st);
    		System.out.println("=================");
    	}
    	
    	public static void showpop(Stack<Integer> st) {
    		System.out.print("st pop ");
    		Integer a = st.pop();
    		System.out.println("pop -> " + a + " -> stact: " + st);
    		System.out.println("=================");
    	}
    	
    	public static void showpeek(Stack<Integer> st) {
    		Integer a = st.peek();
    		System.out.println("peek -> " + a + " -> stact: " + st);
    		System.out.println("=================");
    	}
    }

2）运行结果

stack: []
    =================
    st push 11
    push -> 11 -> stact: [11]
    =================
    st push 22
    push -> 22 -> stact: [11, 22]
    =================
    st push 33
    push -> 33 -> stact: [11, 22, 33]
    =================
    peek -> 33 -> stact: [11, 22, 33]
    =================
    st pop pop -> 33 -> stact: [11, 22]
    =================
    st pop pop -> 22 -> stact: [11]
    =================
    st pop pop -> 11 -> stact: []
    =================
    st pop stact is empty

5、字典（Dictionary）  
字典类是一个抽象类，它定义了键映射到值的数据结构，由于它是抽象类，故只提供了键映射到值的数据结构，而没有提供特定的实现。  
在实际开发中，可以实现Map接口来获取键/值的存储功能。

6、哈希表（Hashtable）  
Hashtable类提供了一种在用户定义键结构的基础上来组织数据的手段。  
哈希表键的具体含义完全取决于哈希表的使用情景和它包含的数据  
Hashtable是原始的java.util的一部分，是一个Dictionary具体的实现  
java2重构的Hashtable实现了Map接口，因此，Hashtable现在集成到了集合框架中。它和Hashtable  
类很相似，但是它支持同步。像HashMap一样，Hashtable在哈希表中存储键/值对。当使用一个哈希表，要指定  
用作键的对象，以及要链接到该键的值。  
然后经过哈希处理，所得到的散列码被用作存储在该表中值的索引。  
1）示例

package sjjg;
    
    import java.util.Enumeration;
    import java.util.Hashtable;
    
    /**
     * @ClassName: HashTableTest 
     * @Description: Hashtable类提供了一种在用户定义键结构的基础上来组织数据的手段。
     * 哈希表键的具体含义完全取决于哈希表的使用情景和它包含的数据
     * Hashtable是原始的java.util的一部分，是一个Dictionary具体的实现
     * java2重构的Hashtable实现了Map接口，因此，Hashtable现在集成到了集合框架中。它和Hashtable
     * 类很相似，但是它支持同步。像HashMap一样，Hashtable在哈希表中存储键/值对。当使用一个哈希表，要指定
     * 用作键的对象，以及要链接到该键的值。
     * 然后经过哈希处理，所得到的散列码被用作存储在该表中值的索引。
     * @author wxy 
     * @date 2019年1月10日 上午10:54:20 
     *
     */
    public class HashTableTest {
    	public static void main(String[] args) {
    		Hashtable ht = new Hashtable();
    		Enumeration names;
    		String str;
    		double dd;
    		
    		ht.put("a", new Double(12.12));
    		ht.put("b", new Double(13.13));
    		ht.put("c", new Double(14.14));
    		ht.put("d", new Double(15.15));
    		ht.put("e", new Double(16.16));
    		
    		names = ht.keys();
    		while(names.hasMoreElements()) {
    			str = (String) names.nextElement();
    			System.out.println("Hashtable -> " + str + " = " + ht.get(str));
    		}
    	}
    }

2）运行结果

Hashtable -> b = 13.13
    Hashtable -> a = 12.12
    Hashtable -> e = 16.16
    Hashtable -> d = 15.15
    Hashtable -> c = 14.14

7、属性（Properties）  
Properties（属性）继承于Hashtable.Properties类表示了一个持久的属性类表中每个键及其对应的值都是一个字符串。  
Properties类被许多java类使用。在获取环境变量时它就作为System.getProperties()方法的返回值。  
Peroperties继承与Hashtable表示一个持久的属性集。属性列表中每个键及其对应值都是一个字符串。  
示例：

package sjjg;
    
    import java.util.Iterator;
    import java.util.Properties;
    import java.util.Set;
    
    /**
     * @ClassName: PropertiesTest 
     * @Description: Properties（属性）继承于Hashtable.Properties类表示了一个持久的属性类表中每个键及其对应的值都是一个字符串。
     * Properties类被许多java类使用。在获取环境变量时它就作为System.getProperties()方法的返回值。
     * Peroperties继承与Hashtable表示一个持久的属性集。属性列表中每个键及其对应值都是一个字符串。
     * @author wxy 
     * @date 2019年1月10日 上午11:38:20 
     */
    public class PropertiesTest {
    	public static void mian(String[] args) {
    		Properties pros = new Properties();
    		Set states;
    		String str;
    		
    		pros.put("port", "8080");
    		pros.put("url", "http://www.baidu.com");
    		pros.put("timeOut", "100");
    		
    		//展示
    		states = pros.keySet();
    		Iterator itr = states.iterator();
    		while(itr.hasNext()) {
    			str = (String) itr.next();
    			System.out.println("properties -> " + str + " = " + pros.getProperty(str));
    		}
    		
    	}
    	
    }