八 Java_数据结构

简介

枚举，Enumeration类

Java.util.Enumeration 枚举（Enumeration）接口虽然它本身不属于数据结构,但它在其他数据结构的范畴里应用很广。 枚举（The Enumeration）接口定义了一种从数据结构中取回连续元素的方式。例如，枚举定义了一个叫nextElement 的方法，该方法用来得到一个包含多元素的数据结构的下一个元素。目前使用迭代器可以替代枚举的功能，且新增了从集合中移除元素的接口

位集合，BitSet类

Java.util.BitSet 位集合类实现了一组可以单独设置和清除的位或标志。该类在处理一组布尔值的时候非常有用，你只需要给每个值赋值一"位"，然后对位进行适当的设置或清除，就可以对布尔值进行操作。
参考：https://www.cnblogs.com/xiaozhang2014/p/6196437.html

向量，Vector类

java.util.vector 向量（Vector）类和传统数组非常相似，但是Vector的大小能根据需要动态的变化。和数组一样，Vector对象的元素也能通过索引访问。使用Vector类最主要的好处就是在创建对象的时候不必给对象指定大小，它的大小会根据需要动态的变化。Vector是有序、可重复的。

栈，Stack类

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

字典，Dictionary类

字典（Dictionary） 类是一个抽象类，它定义了键映射到值的数据结构。当你想要通过特定的键而不是整数索引来访问数据的时候，这时候应该使用Dictionary。由于Dictionary类是抽象类，所以它只提供了键映射到值的数据结构，而没有提供特定的实现。
Dictionary类已经过时，实际开发中一般实现Map接口。

哈希表，Hashtable类

Hashtable类提供了一种在用户定义键结构的基础上来组织数据的手段。例如，在地址列表的哈希表中，你可以根据邮政编码作为键来存储和排序数据，而不是通过人名。哈希表键的具体含义完全取决于哈希表的使用情景和它包含的数据。

属性，Properties类

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

数据结构使用

向量Vector

对于预先不知或者不愿预先定义数组大小，并且需要频繁地进行查找，插入，删除工作的情况，可以考虑使用向量类
(1) public vector() // 系统自动对向量进行管理
/*系统将根据参数设定向量对象的容量（即可存储数据的大小）
initialcapacity指定可存储数据大小，capacityincrement指定每次扩充的扩充值
当真正存放的数据个数超过容量时。系统会扩充向量对象存储容量。
capacityincrement为0时，则每次扩充一倍，利用这个功能可以优化存储/

(2) public vector(int initialcapacity,int capacityIncrement)

(3) public vector(int initialcapacity) // 指定向量对象的容量

插入功能：
(1)public final synchronized void adddElement(Object obj)
将obj插入向量的尾部。obj可以是任何类型的对象。对同一个向量对象亦可以在其中插入不同类的对象。但插入的应是对象而不是数值，所以插入数值时要注意将数组转换成相应的对象。
例如：要插入整数1时，不要直接调用v1.addElement(1),正确的方法为：
Vector v1 = new Vector();
Integer integer1 = new Integer(1);
v1.addElement(integer1);
(2) public final synchronized void setElementAt(Object obj,int index)
将index处的对象设置成obj，原来的对象将被覆盖。
(3) public final synchronized void insertElementAt(Object obj,int index)
在index指定的位置插入obj，原来对象以及此后的对象依次往后顺延。

删除功能：
(1) public final synchronized void removeElement(Object obj)
从向量中删除obj,若有多个存在，则从向量头开始试，删除找到的第一个与obj相同的向量成员。
(2) public final synchronized void removeAllElement();
删除向量所有的对象
(3) public fianl synchronized void removeElementAt(int index)
删除index所指的地方的对象

查询搜索功能：
(1)public final int indexOf(Object obj)
从向量头开始搜索obj,返回所遇到的第一个obj对应的下标，若不存在此obj,返回-1.
(2)public final synchronized int indexOf(Object obj,int index)
从index所表示的下标处开始搜索obj.
(3)public final int lastindexOf(Object obj)
从向量尾部开始逆向搜索obj.
(4)public final synchornized int lastIndex(Object obj,int index)
从index所表示的下标处由尾至头逆向搜索obj.
(5)public final synchornized firstElement()
获取向量对象中的首个obj
(6)public final synchornized Object lastElement()
获取向量对象的最后一个obj

其他功能：
(1) public final int size();
此方法用于获取向量元素的个数。它们返回值是向量中实际存在的元素个数，而非向量容量。可以调用方法capacity()来获取容量值。
(2) public final synchronized void setSize(int newsize);
此方法用来定义向量的大小，若向量对象现有成员个数已经超过了newsize的值，则超过部分的多余元素会丢失。

栈Stack

栈是向量Vector的子类，除支持Vector定义的方法外，新增了以下五种方法：
Empty() // 测试堆栈是否为空
Peek() // 查看堆栈顶部的对象，但不从堆栈中移除
Pop() // 移除堆栈顶部的对象，并作为此方法的值返回该对象
Push(Eite m) // 把项压入堆栈顶部
Search(Object o) // 返回对象在堆栈中的位置，以1为基数
Java中堆、栈、常量池参考：https://zhuanlan.zhihu.com/p/68711242

容器Map

Map以按键/数值对的形式存储数据，（ Map.Entry是Map的内部类，它用来描述Map中的键/值对）。 Map是一个接口，一般用其实现类HashMap。Map的按键必须是唯一的。
常用方法：
Clear() // 从 Map中删除所有映射
Remove(Object key) // 从map中删除关联的键和值
Get(Object key) // 获取给定key对应的值
Put(Object key,Object value) // 修改Map中的元素，会将原先可以所对应的键值对覆盖
containsKey(Object Key) // 是否包含某个元素，配合get、put方法实现匹配并修改元素
putAll(Map t) // 将指定Map中的所有映射复制到此map

Map遍历：
1.迭代 Map中的元素不存在直接方法。如果要查询某个 Map以了解其哪些元素满足特定查询，或如果要迭代其所有元素，则你必须首先获取该 Map的“视图”。共有三种视图
(1)entrySet()
返回 Map中所包含映射(所有键值对)的 Set视图。 Set 中的每个元素都是一个Map.Entry对象，可以使用 getKey()和 getValue()方法（还有一个 setValue()方法）访问后者的键元素和值元素
(2)keySet()
返回 Map中所包含键(所有键)的 Set 视图。删除 Set中的元素还将删除 Map中相应的映射（键和值）
(3)values()
返回 map中所包含值(所有值)的 Collection视图。删除 Collection中的元素还将删除 Map中相应的映射（键和值）

2.上述前两种视图返回Set对象，第三个视图返回Collection对象。无法直接迭代 Collection对象或 Set对象。若要进行迭代必须获得 Iterator对象。

IteratorkeyValuePairs = aMap.entrySet().iterator();
Iterator keys= aMap.keySet().iterator();
Iteratorvalues = aMap.values().iterator();

HashTable

与HashMap类似。可以将key和value结合起来，通过get/put方法可以从表中获取/输入键值信息。因为key和value必须是对象，所以原始类型（primitive types）必须通过运用诸如Integer(int)的方法转换成对象。例如，

Hashtable numbers = new Hashtable();   // 创建hashtable
numbers.put("one", new Integer(1));     // 向hashtable中输入数据
Integer n = (Integer)numbers.get("one");  // 查询hashtable中的数据
if (n != null) {
        System.out.println("one = " + n);
}

如果要将一个特定类的对象用做一个key，这个类必须提供java.lang.Object中的equals() 和 hashCode()两个方法,这两个方法在Object类中的实现一般没什么用，故通常需要重载这两个方法。

Equals()的基本设计约束：

public boolean equals(Object o)
{
        if ( (o == null) || !(o instanceof myClass)) {
                return false;
        }
}

HashCode方法设计原则：
HashCode()方法通过运用对象的内容执行一个哈希函数来生成一个int值。Hashtable和HashMap用这个值来算出一对key/value位于哪个bucket（哈希元）（或列表）中。
1.HashCode()方法必须为一个特定的对象返回相同的值，而不管这个方法被调用了多少次
2.如果equals()方法定义的两个对象是相等的，那么也必须生成相同的哈希码。
3.HashCode()方法应该尽量为不同的对象内容生成不同的结果。如果偶尔生成了相同哈希码，也不要紧。但是若该方法只能返回范围在1到10的值，则不管在hashtable中有多少个列表均只能使用10个列表。

与HashMap的区别：

1. Hashtable是基于Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现类；
2. Hashtable的方法是同步的，而HashMap的方法不是；
   在多线程的应用程序中可以直接使用Hashtable，但使用HashMap则需要提供外同步。（方法：利用Collections类的静态的synchronizedMap()方法创建一个线程安全的Map对象，并把它作为一个封装的对象来返回。这个对象的方法可以让你同步访问潜在的HashMap。）这样当不需要同步时（比如在一个单线程的应用程序中），不会切断Hashtable的同步。
   3.只有HashMap可以将空值作为一个表条目的key或value；
   HashMap中只有一条记录可以是一个空的key，但任意数量的条目可以是空的value。如果在HashTable中Key为空或者对应value为空，那么get()将返回null。可以通过containKey()方法来区别这两种情况。

需要同步时可以直接用Hashtable，但HashMap可以被同步，HashMap的功能比Hashtable的功能更多，且它不是基于过时的类，故多数情况下，HashMap优于Hashtable。。

属性Properties

Java中的配置文件常为.properties文件，而Properties类是读写此类文件的工具。属性文件有两种格式，一种是文本格式，其内容是“键=值”的形式，文本注释信息可以用"#"来注释。另一种是XML格式，键值对遵循XML规范，Android的SharedPreferences也是以xml存储的。
Properties的常用方法：
load : 从属性文件中加载属性对象
store : 把属性对象保存到属性文件
getProperty : 获取属性值
setProperty : 设置属性值
loadFromXML : 从XML格式的属性文件中加载属性对象
storeToXML : 把属性对象保存到XML格式的属性文件

实例

遍历向量

    public void vectorTest(){
        Vector<String> vector = new Vector<String>();
        vector.add("aa");
        vector.add("bb");
        vector.add("aa");
        vector.add("cc");
        // 使用迭代器遍历vector
        Iterator iterator = vector.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        // 使用枚举遍历vector
        Enumeration<String> enumeration = vector.elements();
        while (enumeration.hasMoreElements()){
            System.out.println(enumeration.nextElement());
        }
    }

遍历Map

    public void MapTest(){
        Map map = new HashMap();
        map.put(1, "str1");
        map.put(2, "str2");
        map.put(3, "str1");

        System.out.println(map.size());                 //map映射个数
        System.out.println(map.entrySet().getClass());  //HashMap的内部类EntrySet

        // map的三种视图
        Set<Map.Entry<Integer,String>> set = map.entrySet();
        Set<Integer> set_key = map.keySet();
        Collection<String> col_value = map.values();  // 不能返回Set，value值可能存在重复

        // 获取迭代器
        Iterator<Map.Entry<Integer,String>> iterator_Entry = set.iterator();
        Iterator iterator_key = set_key.iterator();
        Iterator<String> iterator_Value = col_value.iterator();
        // 迭代器遍历Map
        while (iterator_Entry.hasNext()){
            Map.Entry<Integer,String> mapEntry = iterator_Entry.next();
            System.out.println("键："+mapEntry.getKey()+" 值："+mapEntry.getValue());
        }

        // 增强for循环遍历Map
        for (Integer key:set_key){
            System.out.println("键："+key);
        }
        for (String value:col_value){
            System.out.println("值："+value);
        }
    }

属性文件读写

    Properties mProp = new Properties();
    // 向属性文件写入键值对
    public void setmProp(Properties mProp) {
        this.mProp = mProp;
        mProp.setProperty("name","cong");

        mProp.setProperty("age","" + (int)(Math.random()*100/100));
        // mProp.setProperty("age", String.valueOf((int)(Math.random()*100/100)));
        mProp.setProperty("married", " " + true);
        // mProp.setProperty("married", String.valueOf(true));

        mProp.setProperty("weight", "" + 100f);
        // mProp.setProperty("weight", String.valueOf(100f));
}

// 从属性文件读取键值对
    public Properties getmProp() {
        Properties mProp = new Properties();
        String name = mProp.getProperty("name","");
        int age = Integer.parseInt(mProp.getProperty("age", String.valueOf(0)));
        boolean married = Boolean.parseBoolean(mProp.getProperty("married", String.valueOf(true)));
        double weight = Double.parseDouble(mProp.getProperty("weight", String.valueOf(10)));
        return mProp;
    }