java集合框架（二）其它集合

1、LinkedList链表

序列分先进先出FIFO,先进后出FILO
FIFO在Java中又叫Queue 队列
FILO在Java中又叫Stack 栈

• （1） LinkedList 与 List接口
  与ArrayList一样，LinkedList也实现了List接口，诸如add,remove,contains等等方法。 详细使用，请参考 ArrayList 常用方法。

接下来是LinkedList的一些特别的地方

• （2）双向链表 Deque
  除了实现了List接口外，LinkedList还实现了双向链表结构Deque，可以很方便的在头尾插入删除数据

    public static void Deque(){
        //LinkedList是一个双向链表结构的list
        LinkedList<Hero> linkedList = new LinkedList<>();
        linkedList.add(new Hero("hero1"));
        linkedList.addLast(new Hero("hero2"));
        linkedList.add(new Hero("hero3"));
        System.out.println(linkedList);
        linkedList.addFirst(new Hero("hero0"));
        System.out.println(linkedList);
        System.out.println(linkedList.getFirst());
        System.out.println(linkedList.getLast());
        System.out.println(linkedList.removeFirst());
        System.out.println(linkedList.removeLast());
        System.out.println(linkedList);
    }

• （3）队列 Queue

LinkedList 除了实现了List和Deque外，还实现了Queue接口(队列)。
Queue是先进先出队列 FIFO，常用方法：
offer 在最后添加元素
poll 取出第一个元素
peek 查看第一个元素

    public static void Quene(){
        LinkedList linkedList = new LinkedList<Hero>();
        Queue<Hero> q = new LinkedList<Hero>();
        q.offer(new Hero("Hero1"));
        q.offer(new Hero("Hero2"));
        q.offer(new Hero("Hero3"));
        q.offer(new Hero("Hero4"));
        System.out.println(q);
        //取出第一个Hero，FIFO 先进先出
        Hero h = q.poll();
        System.out.println(q);
        System.out.println(h);
        //把第一个拿出来看一看，但是不取出来
        h = q.peek();
        System.out.println(q);
        System.out.println(h);
    }

2、二叉树

• （1）二叉树概念

二叉树由各种节点组成
二叉树特点：
每个节点都可以有左子节点，右子节点
每一个节点都有一个值

public class Node {
    // 左子节点
    public Node leftNode;
    // 右子节点
    public Node rightNode;
    // 值
    public Object value;
}

• （2）二叉树排序 插入和遍历

public class Node {
    public Node leftNode;
    public Node rightNode;
    public Object value;

    public void add(Object v){
         if(null == value)
             value = v;
         else {
             if((Integer)v-(Integer)value <= 0){
                 if(null == leftNode)
                     leftNode = new Node();
                 leftNode.add(v);
             }
             else {
                 if (null == rightNode)
                     rightNode = new Node();
                 rightNode.add(v);
             }
         }
    }
    public List<Object> values(){
        List<Object>values = new ArrayList<>();
        if(null != leftNode)
            values.addAll(leftNode.values());
        values.add(value);
        if(null != rightNode)
            values.addAll(rightNode.values());
        return values;
    }

    public static void main(String[] args) {
        int randoms[] = new int[]{67, 7, 30, 73, 10, 0, 78, 81, 10, 74 };
        Node roots = new Node();
        for(int number: randoms){
            roots.add(number);
        }
        System.out.println(roots.values());
    }
}

3、HashMap

HashMap储存数据的方式是—— 键值对

对于HashMap而言，key是唯一的，不可以重复的。
所以，以相同的key 把不同的value插入到 Map中会导致旧元素被覆盖，只留下最后插入的元素。
不过，同一个对象可以作为值插入到map中，只要对应的key不一样

public class HashMapTest
{
    public static void main(String[] args) {
        HashMap<String,String> dict = new HashMap<>();
        dict.put("abc" ,"物理英雄");
        dict.put("apc","魔法英雄");
        dict.put("t", "坦克");
        System.out.println(dict.get("t"));
    }
}

4、HashSet

Set中的元素，不能重复
Set中的元素，没有顺序。
严格的说，是没有按照元素的插入顺序排列

public class TestCollection {
    public static void main(String[] args) {
        HashSet<String> names = new HashSet<String>();
        names.add("gareen");
        System.out.println(names);
        //第二次插入同样的数据，是插不进去的，容器中只会保留一个
        names.add("gareen");
        System.out.println(names);
    }
}

• Set不提供get()来获取指定位置的元素
  所以遍历需要用到迭代器，或者增强型for循环

 //遍历Set可以采用迭代器iterator
        for (Iterator<Integer> iterator = numbers.iterator(); iterator.hasNext();) {
            Integer i = (Integer) iterator.next();
            System.out.println(i);
        }
         
        //或者采用增强型for循环
        for (Integer i : numbers) {
            System.out.println(i);
        }