Java学习随便记3

Java数据结构-BitSet类

BitSet类的功能和 C++ STL  bitset<N>模板类大致接近，只是STL bitset类没有直接位逻辑运算的方法，不过它可以直接[]索引，自己循环解决；另外，STL bitset没有求交集之类集合运算，不过<algorithm>提供了set_xxx系列对有序序列的集合运算。（参考 bitset - C++ Reference    <algorithm> - C++ Reference）

import java.util.BitSet;

public class BitSetTest {
    public static void main(String[] args) {
        BitSet bits1 = new BitSet(32);
        BitSet bits2 = new BitSet(32);

        bits1.set(0, 7);
        bits2.set(0, 7, false);

        for (int i = 8; i < 32; i++) {
            if (i % 2 == 0)
                bits1.set(i);
            if (i % 3 == 1)
                bits2.set(i);
        }
        System.out.print("bits1: ");
        System.out.println(bits1);
        System.out.print("bits2: ");
        System.out.println(bits2);

        System.out.print("Does bits1 intersect with bits2: ");
        System.out.println(bits1.intersects(bits2) ? "YES" : "NO");

        System.out.print("First clear bit of bits1 from index 0, index = ");
        System.out.println(bits1.nextClearBit(0));

        System.out.print("First set bit of bits2 from index 0, index = ");
        System.out.println(bits2.nextSetBit(0));

        bits1.xor(bits2);
        System.out.print("bits1 = bits1 XOR bits2: ");
        System.out.println(bits1);

        System.out.print("Cardinality of bits1: ");
        System.out.println(bits1.cardinality());

    }
}

bits1: {0, 1, 2, 3, 4, 5, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30}
bits2: {10, 13, 16, 19, 22, 25, 28, 31}
Does bits1 intersect with bits2: YES
First clear bit of bits1 from index 0, index = 7
First set bit of bits2 from index 0, index = 10
bits1 = bits1 XOR bits2: {0, 1, 2, 3, 4, 5, 6, 8, 12, 13, 14, 18, 19, 20, 24, 25, 26, 30, 31}
Cardinality of bits1: 19

Java数据结构-Dictionary类、集合框架 Map、Map.Entry接口

因为 Java 的 Dictionary类是抽象类，所以，你并不能拿来就用。既然如此，Java的 Collection集合框架中有更好用的 Map接口，我们不如使用从 Map接口继承的 HashMap泛型类。Map.Entry接口需要配合Set工作，所以这里用法暂时略，简单来说，Map.Entry接口对应的具体类相当于 STL map 中的pair<K,V>键值对。

import java.util.HashMap;
import java.util.Map;

public class MapTest {
    public static void main(String[] args) {
        Map mp1 = new HashMap<String, Integer>();
        mp1.put("耐克", 200);
        mp1.put("Adidas", 199);
        mp1.put("李宁", 180);
        System.out.println();
        System.out.print("Map Elements: ");
        System.out.println(mp1);
        System.out.print("耐克 价格：");
        System.out.println(mp1.get("耐克"));
    }
}

Java数据结构-Vector类

Java的 Vector泛型类 和 STL vector接近，值得注意的是，Java的 Vector 可以同时装入整数和浮点数（可以认为此时它们都是Object类型），而 STL vector只能是整数序列或者浮点数序列。

import java.util.Vector;

public class VectorTest {
    public static void main(String[] args) {
        Vector v = new Vector(3, 2); // 2 是空间增长量
        System.out.println("v 初始大小： " + v.size());
        System.out.println("v 初始容量： " + v.capacity());
        v.add(new Integer(1));
        v.add(new Integer(2));
        v.add(new Integer(3));
        v.add(new Integer(4));
        System.out.println("v 加入4个元素后的容量： " + v.capacity());
        v.add(new Double(3.14));
        System.out.println("v 当前的容量： " + v.capacity());
        System.out.println("最后一个元素：" + v.lastElement());
        System.out.println("第二个元素：" + v.get(1));
        for (Object n : v) { // n 可能是装箱了的整数或者浮点数
            System.out.print(n + "\t");
        }
        System.out.println();
    }
}

v 初始大小： 0
v 初始容量： 3
v 加入4个元素后的容量： 5
v 当前的容量： 5
最后一个元素：3.14
第二个元素：2
1       2       3       4       3.14

Java数据结构-Stack类

Stack类是Vector类的子类，这一点和STL类似，即 Stack 本质上是 Vector实现的。借由Vector实现的 Stack类的优点是线程安全的，但作为栈使用，如果频繁进出栈，不如用 LinkedList 实现栈结构（但在编程竞赛中，如果一次性的分配不会超出空间，那自己维护栈顶指针的数组才能速度最快）。

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

public class StackTest {
    public static void main(String[] args) {
        Stack stk = new Stack();
        System.out.println("stack: " + stk);
        stk.push(new Integer(42));
        stk.push(new Integer(77));
        stk.push(new Integer(88));
        System.out.println("stack: " + stk);
        stk.pop();
        stk.pop();
        System.out.println("stack: " + stk);
        System.out.println("Is stack empty: " + stk.empty());
        try {
            stk.pop();
            System.out.println("Is stack empty: " + stk.empty());
            stk.pop();
        } catch (EmptyStackException e) {
            System.out.println("Stack empty!!!");
        }
    }
}

stack: []
stack: [42, 77, 88]
stack: [42]
Is stack empty: false
Is stack empty: true
Stack empty!!!

Java数据结构-集合框架List接口（ArrayList、LinkedList）

import java.util.List;
import java.util.LinkedList;
import java.util.ArrayList;

public class ListTest {
    public static void main(String[] args) {
        List lst1 = new ArrayList();
        lst1.add("纽约");
        lst1.add("东京");
        lst1.add("北京");
        System.out.println("ArrayList: " + lst1);
        List lst2 = new LinkedList();
        lst2.add("纽约");
        lst2.add("东京");
        lst2.add("北京");
        System.out.println("LinkedList: " + lst2);
    }
}

ArrayList: [纽约, 东京, 北京]
LinkedList: [纽约, 东京, 北京]

从表面效果来看，ArrayList和LinkedList是“差不多”的，但它内部实现有很大不同。ArrayList是内部Object[]类型数组作为buffer实现的，如果装入是一次性的或者只会少量在后面再次装入，主要是查询，那么它的效果会比较好；但要从头部或中间增删元素，对它是很糟糕的情况（这个意义上说，它和传统Java数据结构中的Vector一样，或者说，ArrayList就是集合框架中Vector的对应物）。LinkedList则是标准的双向链表，具有链表的特性，对于头部、中间增删频繁的情况特别适用，尾部增删频繁也可用。

Java数据结构-集合框架Set接口

Set就是数学概念上的集合，即元素的唯一性，这种唯一性是可以比较的。继承Set接口的有HashSet，TreeSet，LinkedHashSet等。HashSet是基于Hash的，所以，有“去重”效果，但元素无序；TreeSet是基于红黑树之类的树结构，所以，元素是有序的（实现了SortedSet接口）。LinkedHashSet 引入了链表特性，使得hash表大小可变。和STL对比，反而是TreeSet像STL set，HashSet则像unordered_set。

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetTest {
    public static void main(String[] args) {
        int[] a = { 34, 22, 10, 60, 30, 22 };
        Set<Integer> s = new HashSet<Integer>();
        try {
            for (int n : a) {
                s.add(n);
            }
            System.out.println(s);
            TreeSet sortedSet = new TreeSet<>(s);
            System.out.println("Sorted set is: " + sortedSet);
            System.out.println("1st element of sortedSet: " + sortedSet.first());
            System.out.println("last element of sortedSet: " + sortedSet.last());
        } catch (Exception e) {
        }
    }
}

[34, 22, 10, 60, 30]
Sorted set is: [10, 22, 30, 34, 60]
1st element of sortedSet: 10
last element of sortedSet: 60

Java数据结构-集合框架 Map、Map.Entry、SortedMap接口

SortedMap接口从Map接口继承，HashMap是继承Map接口，而TreeMap则继承SortedMap接口。HashMap类似STL 的 unordered_map，而TreeMap则像map，Map.Entry像pair<K,V>。

TreeMap遍历需要用键值对的集合或者键的集合来达到目的。

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class MapTest2 {
    public static void main(String[] args) {
        TreeMap mp = new TreeMap<>();
        mp.put("萝卜", 0.85);
        mp.put("黄瓜", 3.45);
        mp.put("芹菜", 4.85);
        mp.put("土豆", 1.00);
        Set s = mp.entrySet();
        Iterator itr = s.iterator();
        while (itr.hasNext()) {
            Map.Entry entry = (Map.Entry) itr.next();
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }
        Double price = ((Double) mp.get("萝卜")).doubleValue();
        mp.put("萝卜", new Double(price + 0.5));
        System.out.println("萝卜的新价格： " + mp.get("萝卜"));
    }
}

简单来说，Java传统数据结构中，除了Bitset类，其他我们可以考虑用Collection集合框架下的接口和类。要用Vector，可以考虑 ArrayList，要用Stack，可以考虑LinkedList。无论是 Map 还是 Set，都有 Hash方式的和Tree方式的。

Java数据结构-队列

没有涉及的似乎还有一个“队列”。

Queue和Deque都是接口而已，实际我们会考虑使用的，一个是 LinkedList，一个是 ArrayDeque。前者是链表实现的双端队列，后者是循环数组实现的双端队列。

另外一个“队列”是优先队列 PriorityQueue，也就是基于数组的堆结构。