Java数据结构

Java 数据结构

Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类：

枚举（Enumeration）
位集合（BitSet）
向量（Vector）
栈（Stack）
字典（Dictionary）
哈希表（Hashtable）
属性（Properties）

Java 枚举接口

Enumeration接口中定义了一些方法，通过这些方法可以枚举（一次获得一个）对象集合中的元素。

用作常量：

public enum color{
        red,white,orange,blcak; 
    }
    
public static void main(String args[]){
       color a = color.red;
       System.out.println(a);
    }

用于swicth：

public enum color{
        red,white,orange,blcak; 
    }
public static void main(String args[]){
       color a = color.blcak;
       switch (a){
       case red:
           System.out.println("this red");
           break;
       case orange:
           System.out.println("this is orange");
           break;
    default:
        System.out.println("this is other color");
        break;
    }
    }

给枚举添加方法

public class EnumerationTest {
    public enum color{
        red("redname",1),black("blackname",2);
        private String name ;
        private int index;
        private color(String name,int index){
            this.name=name;
            this.index=index;
        }
        public static String getName(int index){
            for(color c: color.values()){
                if(c.getIndex() ==index){
                    return c.name;
                }   
            }
            return null;
        }
        
        public String getName(){
            return this.name();
        }
        public void setName(String name){
            this.name = name();
        }
        public void setIndex(int index){
            this.index =index;
        }
        public int getIndex(){
            return this.index;
        }   
    }
    
    public static void main(String args[]){
       color a = color.black;
       switch (a){
       case red:
           System.out.println("this red");
           break;
       case black:
           System.out.println("this is black");
           break;
    default:
        System.out.println("this is other color");
        break;
    }
       System.out.println(a.getName());
       System.out.println(a.getIndex());
       System.out.println(a.getName(1));
    }

每个枚举对象成为一个带方法和属性的实例对象。

Java vector类

Vector类实现了一个动态数组。和ArrayList和相似，但是两者是不同的：

Vector是同步访问的。
Vector包含了许多传统的方法，这些方法不属于集合框架。

Vector类支持4种构造方法。

第一种构造方法创建一个默认的向量，默认大小为10：

Vector()

第二种构造方法创建指定大小的向量。

Vector(int size)

第三种构造方法创建指定大小的向量，并且增量用incr指定. 增量表示向量每次增加的元素数目。

Vector(int size,int incr)

第四中构造方法创建一个包含集合c元素的向量：

Vector(Collection c)

public class Vectortest {
    public static void main(String args[]){
        Vector  aVector  = new Vector(3,2);
        aVector.addElement(new Integer(1));
        aVector.addElement(new Integer(2));
        aVector.addElement(new Double(10.3));
        System.out.println(aVector.capacity());
        System.out.println(aVector.size());
        Enumeration enumeration =  aVector.elements();
        while(enumeration.hasMoreElements()){
            System.out.println(enumeration.nextElement());
        }
    }

}

此外，还支持在指定位置插入指定元素

Java Stack类

栈是Vector的一个子类，它实现了一个标准的后进先出的栈。

堆栈只定义了默认构造函数，用来创建一个空栈。堆栈除了包括由Vector定义的所有方法，也定义了自己的一些方法。

除了由Vector定义的所有方法，自己也定义了一些方法：

序号	方法描述
1	boolean empty() 测试堆栈是否为空。
2	Object peek( )查看堆栈顶部的对象，但不从堆栈中移除它。
3	Object pop( )移除堆栈顶部的对象，并作为此函数的值返回该对象。
4	Object push(Object element)把项压入堆栈顶部。
5	int search(Object element)返回对象在堆栈中的位置，以 1 为基数。

public class Stacltest {
    public static void main(String args[]){
        Stack a  = new Stack<>();
        a.push(new Double(10.9));
        System.out.println(a.peek());
        Double b = (Double)(a.pop());
        System.out.println(b);
        System.out.println(a.empty());
    }
}

Java HashTable 接口

像HashMap一样，Hashtable在哈希表中存储键/值对。当使用一个哈希表，要指定用作键的对象，以及要链接到该键的值。

public class HashTableTest {
    public static void main(String args[]){
        Hashtable a = new Hashtable();
        Enumeration names;
        a.put("wdp",new Double(12.2));
        a.put("ws",new Double(20.9));
        a.put("lhy",new Double(990.9));
        names = a.elements();
        while(names.hasMoreElements()){
            System.out.println(names.nextElement());
        }
        System.out.println(a.get("wdp"));   
    }
}

Java Properties 接口

Properties 继承于 Hashtable.表示一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。

public class PropertiesTest {
    public static void main(String args[]){
        Properties capital = new Properties();
        capital.put("China", "Beijing");
        capital.put("Japanese", "Tokyo");
        capital.put("USA", "hsd");
        System.out.println(capital.get("China")+" is the captial of"+"China");
        }
    }

Java泛型

Java泛型（generics）是JDK 5中引入的一个新特性,泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

使用Java泛型的概念，我们可以写一个泛型方法来对一个对象数组排序。然后，调用该泛型方法来对整型数组、浮点数数组、字符串数组等进行排序。

泛型方法:

写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。下面是定义泛型方法的规则：

所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的）。
每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
泛型方法方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。

public class FanxingTest {
    public static  void printarray(E[] array){
        for (E element: array){
            System.out.printf("%s",element);
        }
    }
    public static  void main(String args[]){
        Integer[] intarray = {1,2,3,4};
        Double[] doublearray ={1.1,2.2,3.3,4.4};
        Character[]  chararray ={'a','b','c','d'};
        printarray(doublearray);
    }

}

可以利用泛型来定义泛型类和泛型方法

Java序列化

想把一个对象写入到文件中，然后再从文件中读取信息还原一个对象，就要采用序列化的知识。被序列化的对象所属的类必须继承java.io.Serializable接口。分别用ObjectOutputStream和ObejctInputStream来实现序列化和反序列化

class Car implements java.io.Serializable{
    String name;
    String tag;
    int load;
    public Car(String name){
        this.name= name;
    }
}
public static void main(String args[]) throws IOException{
        Car aCar = new Car("BMW");
        FileOutputStream fileopt = new FileOutputStream("D:/a.txt");
        ObjectOutputStream objopt = new ObjectOutputStream(fileopt);
        objopt.writeObject(aCar);
        objopt.close();
        Car a = null;
        try{
        FileInputStream  filein = new FileInputStream("D:/a.txt");
        ObjectInputStream objin = new ObjectInputStream(filein);
         a =  (Car )objin.readObject();
        }
        catch (Exception e) {
            // TODO: handle exception
        }
        System.out.println(a.name);     
    }
}