Java 数据结构

开篇

最近一直处于焦虑的写论文阶段，马上就要出去实习了，今天总算可以抽出一点时间，更新一下自己的博客，接着就该去深圳实习了。

枚举

import java.util.Vector;
import java.util.Enumeration;
public class EnumerationTester {
    public static void main(String args[]) {
        Enumeration<String> days;
        Vector<String> dayNames = new Vector<String>();
        dayNames.add("Sunday");
        dayNames.add("Monday");
        dayNames.add("Tuesday");
        dayNames.add("Wednesday");
        dayNames.add("Thursday");
        dayNames.add("Friday");
        dayNames.add("Saturday");
        days = dayNames.elements();
        while (days.hasMoreElements()){
            System.out.println(days.nextElement());
        }
    }
}

out:
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday

bitset

import java.util.BitSet;

public class BitSetDemo {

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

     // set some bits
     for(int i=0; i<16; i++) {
        if((i%2) == 0) bits1.set(i);
        if((i%5) != 0) bits2.set(i);
     }
     System.out.println("Initial pattern in bits1: ");
     System.out.println(bits1);
     System.out.println("\nInitial pattern in bits2: ");
     System.out.println(bits2);

     // AND bits
     bits2.and(bits1);
     System.out.println("\nbits2 AND bits1: ");
     System.out.println(bits2);

     // OR bits
     bits2.or(bits1);
     System.out.println("\nbits2 OR bits1: ");
     System.out.println(bits2);

     // XOR bits
     bits2.xor(bits1);
     System.out.println("\nbits2 XOR bits1: ");
     System.out.println(bits2);
  }
}

out:
Initial pattern in bits1:
{0, 2, 4, 6, 8, 10, 12, 14}

Initial pattern in bits2:
{1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14}

bits2 AND bits1:
{2, 4, 6, 8, 12, 14}

bits2 OR bits1:
{0, 2, 4, 6, 8, 10, 12, 14}

bits2 XOR bits1:
{}

vector

/**
 * Created by Dave on 2018/6/26.
 */

import java.util.*;
import java.lang.*;
import java.util.Enumeration;
public class Vector_basic {
    public static void main(String args[])
    {
        Vector v1 = new Vector();
        Integer integer1= new Integer(1);
        //加入为字符串对象
        v1.addElement("one");
        //加入的为integer的对象
        v1.addElement(integer1);
        v1.addElement(integer1);
        v1.addElement("two");
        v1.addElement(new Integer(2));
        //不能直接插入2的
        v1.addElement(integer1);
        v1.addElement(integer1);
        System.out.println(v1);
        //转为字符串并打印
        //System.out.println("The Vector v1 is:\n\t"+v1);

        //向指定位置插入新对象
        v1.insertElementAt("three",2);
        v1.insertElementAt(new Float(3.9),3);

        System.out.println(v1);

        //会改变原先位置的元素
        v1.setElementAt("four",2);
        System.out.println(v1);

        v1.removeElement(integer1);
        System.out.println(v1);

        //依次输出元素
        Enumeration em = v1.elements();
        while(em.hasMoreElements())
        {
            System.out.println(em.nextElement());

        }

        System.out.println(v1.indexOf(integer1));
        System.out.println(v1.lastIndexOf(integer1));
        System.out.println("index 2 = "+v1.get(2));
        //设置相应的大小

        v1.setSize(2);
        System.out.println(v1);

        Vector v2 = new Vector(3,2);
        System.out.println("Initial size: " + v2.size());
        System.out.println("Initial capacity: " + v2.capacity());
        v2.addElement(new Integer(1));
        v2.addElement(new Integer(2));
        v2.addElement(new Integer(3));
        v2.addElement(new Integer(4));
        System.out.println("Capacity after four additions: " + v2.capacity());
        v2.addElement(new Double(5.45));
        System.out.println("Current capacity: " + v2.capacity());
        v2.addElement(new Double(6.08));
        v2.addElement(new Integer(7));
        System.out.println("Current capacity: " + v2.capacity());
        v2.addElement(new Float(9.4));
        v2.addElement(new Integer(10));
        System.out.println("Current capacity: " + v2.capacity());
        v2.addElement(new Integer(11));
        v2.addElement(new Integer(12));

        System.out.println("First element: " + (Integer)v2.firstElement());
        System.out.println("Last element: " + (Integer)v2.lastElement());
        if(v2.contains(new Integer(3)))
            System.out.println("Vector contains 3.");

        System.out.println(v2);


    }



}

更多函数

out:
[one, 1, 1, two, 2, 1, 1]
[one, 1, three, 3.9, 1, two, 2, 1, 1]
[one, 1, four, 3.9, 1, two, 2, 1, 1]
[one, four, 3.9, 1, two, 2, 1, 1]
one
four
3.9
1
two
2
1
1
3
7
index 2 = 3.9
[one, four]
Initial size: 0
Initial capacity: 3
Capacity after four additions: 5
Current capacity: 5
Current capacity: 7
Current capacity: 9
First element: 1
Last element: 12
Vector contains 3.
[1, 2, 3, 4, 5.45, 6.08, 7, 9.4, 10, 11, 12]

Process finished with exit code 0

堆栈

import java.util.*;

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.print("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 {
            showpop(st);
        } catch (EmptyStackException e) {
            System.out.println("empty stack");
        }
    }
}

stack: [ ]
push(42)
stack: [42]
push(66)
stack: [42, 66]
push(99)
stack: [42, 66, 99]
pop -> 99
stack: [42, 66]
pop -> 66
stack: [42]
pop -> 42
stack: [ ]
pop -> empty stack

import java.util.*;
public class Stack_basic {


    public static void main(String args[])
    {
        Stack st = new Stack();

        st.push(new Integer(1));
        st.push(new Integer(2));
        st.push(new Integer(3));
        st.push(9.4);

        System.out.println(st);
        //不会从栈中移除栈顶元素
        System.out.println(st.peek());

        System.out.println(st.pop());
        System.out.println(st);
    }


}

Map

import java.util.*;
import java.lang.*;
public class Map_basic {
    public static void main(String[] args)
    {
        Map<String,String> m1 = new HashMap<String,String>();
        m1.put("Zara", "8");
        m1.put("Mahnaz", "31");
        m1.put("Ayan", "12");
        m1.put("Daisy", "14");
        System.out.println();
        System.out.println(" Map Elements");
        System.out.print("\t" + m1);
        System.out.println();

        //获取元素
        System.out.println(m1.get("Zara"));
        //移除元素
        m1.remove("Zara");
        System.out.println(m1);
        //清除map
        //m1.clear();
        //System.out.println(m1);

        //map遍历
        for(String key : m1.keySet())
            System.out.println(key + ":" + m1.get(key));

        for(Map.Entry<String,String> entry : m1.entrySet())
            System.out.println(entry.getKey()+":"+entry.getValue());

        //迭代器遍历
        Iterator<String> iterator = m1.keySet().iterator();
        while(iterator.hasNext())
        {
            String key = iterator.next();
            System.out.println(key+":"+m1.get(key));
        }

        Iterator<Map.Entry<String, String>> iterator1 = m1.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, String> entry = iterator1.next();
            System.out.println(entry.getKey() + "　：" + entry.getValue());
        }


    }
}

map的排序

Map<String, String> map = new HashMap<String, String>();
map.put("a", "c");
map.put("b", "b");
map.put("c", "a");

// 通过ArrayList构造函数把map.entrySet()转换成list
List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>(map.entrySet());
// 通过比较器实现比较排序
Collections.sort(list, new Comparator<Map.Entry<String, String>>() {
    public int compare(Map.Entry<String, String> mapping1, Map.Entry<String, String> mapping2) {
        return mapping1.getKey().compareTo(mapping2.getKey());
    }
});

for (Map.Entry<String, String> mapping : list) {
    System.out.println(mapping.getKey() + " ：" + mapping.getValue());
}