OnJava8_集合

集合类：List, Set, Map, Queue

• 泛型
  ArrayList<Apple> apples = new ArrayList<>();

类名，后边跟着对象的散列码的无符号十六进制表示（这个散列码是通过 hashCode() 方法产生的）

Objec.toString 方法打印对象.png

常用集合类型

        System.out.println(fill(new ArrayList<>()));
        System.out.println(fill(new LinkedList<>()));
        //通过hash算法存储和查找元素
        System.out.println(fill(new HashSet<>()));
        //比较结果的升序保存对象
        System.out.println(fill(new TreeSet<>()));
        //被添加的先后顺序保存对象
        System.out.println(fill(new LinkedHashSet<>()));
        System.out.println(fill(new HashMap<>()));
        System.out.println(fill(new TreeMap<>()));
        System.out.println(fill(new LinkedHashMap<>()));

列表

• ArrayList: 底层是数组，所以擅长随机访问元素，在中间插入和删除元素较慢；

• LinkedList：底层是链表，所以擅长list中插入和删除元素，随机访问元素较慢。

• 所有的类都是 Iterable, 不需要.iterator()方法：

import typeinfo.pets.*;
import java.util.*;

public class CrossCollectionIteration2 {
  public static void display(Iterable<Pet> ip) {
    Iterator<Pet> it = ip.iterator();
    while(it.hasNext()) {
      Pet p = it.next();
      System.out.print(p.id() + ":" + p + " ");
    }
    System.out.println();
  }
  public static void main(String[] args) {
    List<Pet> pets = Pets.list(8);
    LinkedList<Pet> petsLL = new LinkedList<>(pets);
    HashSet<Pet> petsHS = new HashSet<>(pets);
    TreeSet<Pet> petsTS = new TreeSet<>(pets);
    display(pets);
    display(petsLL);
    display(petsHS);
    display(petsTS);
  }
}

• ListIterator可以双向移动

package collections;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.ListIterator;

public class ListIteration {
    public static void main(String[] args) {
        List<Integer> lists = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9));
        ListIterator<Integer> it = lists.listIterator();
        while (it.hasNext()) {
            System.out.println(it.next() + " " + it.nextIndex() + " " + it.previousIndex());
        }
        System.out.println();
        while (it.hasPrevious()) {
            System.out.println(it.previous());
        }
        it = lists.listIterator(3);
        while (it.hasNext()) {
            ;
            System.out.println(it.next() + " " + it.nextIndex() + " " + it.previousIndex());
        }
    }
}

Set:（需要详细了解）

TreeSet用红黑树数据结构存储元素；会对元素进行排序；
HashSet使用散列函数存储元素；
LinkedHashSet 还不清楚。

idea的相对路径相对于项目根目录"./src/某某文件.txt"

stack （先进后出）

用ArrayDeque实现, ArrayDeque比Stack性能好。

package collections;

import java.util.ArrayDeque;
import java.util.Deque;

public class Stack<T> {
    private Deque<T> storage = new ArrayDeque<>();

    public void push(T v) {
        storage.push(v);
    }

    public T peek() {
        return storage.peek();
    }

    public T pop() {
        return storage.pop();
    }

    public boolean isEmpty() {
        return storage.isEmpty();
    }

    public String toString() {
        return storage.toString();
    }
}

queue （先进先出）

LinkedList 实现了 Queue 接口，并且提供了一些方法以支持队列行为，因此 LinkedList 可以用作 Queue 的一种实现。 通过将 LinkedList 向上转换为 Queue。

//offer() 在队列的尾部插入一个元素，或者返回 false;
// peek() 和 element() 都返回队头元素而不删除它;
//如果队列为空，则 element() 抛出 NoSuchElementException;
// peek() 返回 null; 
// poll() 和 remove()* 都删除并返回队头元素;
// 但如果队列为空，poll() 返回 null ，而 remove() 抛出。 NoSuchElementException 。
package collections;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;

public class QueueDemo {
    public static void printQ(Queue queue) {

        while (queue.peek() != null) {
            System.out.println(queue.remove() + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        Random rand = new Random(47);
        for (int i = 0; i < 10; i++) {
            queue.offer(rand.nextInt(i + 10));
        }
        printQ(queue);
        Queue<Character> qc = new LinkedList<>();
        for (char c : "Brontosaurus".toCharArray()) {
            qc.offer(c);
        }
        printQ(qc);
    }
}

优先级队列PriorityQueue

package collections;

import java.util.*;

public class PriorityQueueDemo {
    public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
        Random random = new Random(47);
        for (int i = 0; i < 10; i++) {
            priorityQueue.offer(random.nextInt(i + 10));
        }
        QueueDemo.printQ(priorityQueue);

        List<Integer> ints = Arrays.asList(25, 22, 20, 18, 14, 9, 3, 1, 1, 2, 3, 9, 14, 18, 21, 23, 25);
        priorityQueue = new PriorityQueue<>(ints);
        QueueDemo.printQ(priorityQueue);
        priorityQueue = new PriorityQueue<>(ints.size(), Collections.reverseOrder());
        priorityQueue.addAll(ints);
        QueueDemo.printQ(priorityQueue);

        String fact = "EDUCATION SHOULD ESCHEW OBFUSCATION";
        List<String> strings = Arrays.asList(fact.split("\\s+"));
        PriorityQueue<String> stringPQ = new PriorityQueue<>(strings);
        QueueDemo.printQ(stringPQ);
        stringPQ = new PriorityQueue<>(strings.size(), Collections.reverseOrder());
        stringPQ.addAll(strings);
        QueueDemo.printQ(stringPQ);

        Set<Character> charSet = new HashSet<>();
        for (char c : fact.toCharArray())
            charSet.add(c);
        PriorityQueue<Character> characterPQ = new PriorityQueue<>(charSet);
        QueueDemo.printQ(characterPQ);
    }
}

HashMap 专为快速访问而设计，而 TreeMap 保持键始终处于排序状态，所以没有 HashMap 快。 LinkedHashMap 按插入顺序保存其元素，但使用散列提供快速访问的能力。
Set 不接受重复元素。 HashSet 提供最快的查询速度，而 TreeSet 保持元素处于排序状态。 LinkedHashSet 按插入顺序保存其元素，但使用散列提供快速访问的能力。