Java链表

Java的链表已经被库程序员做好了封装，不会再像面向过程语言那样再重建。
Java中提供了linkedList类，从此一切链表的操作都会很简单。

package linkedList;

import java.util.Iterator;//迭代器
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;

public class LinkedListTest {

    public static void main(String[] args){
        List<String> a = new LinkedList<>();
        a.add("Amy");
        a.add("Carl");
        a.add("Erica");

        List<String> b = new LinkedList<>();
        b.add("Bob");
        b.add("Doug");
        b.add("Frances");
        b.add("Gloria");

        ListIterator<String> aIter = a.listIterator();
        Iterator<String> bIter = b.iterator();

        //merge the words from b into a
        while(bIter.hasNext()){
            if(aIter.hasNext())
                aIter.next();
            aIter.add(bIter.next());
        }

        System.out.println(a);
        //remove every second word from b
        bIter=b.iterator();
        while(bIter.hasNext()){
            bIter.next();
            if(bIter.hasNext()){
                bIter.next();
                bIter.remove();
            }
        }

        System.out.println(b);
        ((LinkedList<String>) a).removeAll(b);
        System.out.println(a);
    }
}
解释：
1.ListIterator<E> listIterator() 返回一个列表迭代器，以便用来访问列表的元素
2.void add(int i, E element) 在给定位置添加一个元素
3.E remove(int i)删除给定位置元素比你高返回这个元素
4.hasNext()指的是检测下一个元素是否为空，Next()是指将迭代器往下迭代一次

但是Java的链表类有一个缺点，当你需要搜索的时候，只能从头开始遍历，无法直接寻找到你所要找的位置。但散列表很好的解决了这一问题，散列表为每个对象计算一个整数，称为散列码。其缺点就是无法控制元素出现的次序。

以下是散列表的实现方法：

package set;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;

public class SetTree {
    public static void main(String[] args){
        Set<String> words = new HashSet<>();//hashset implements set
        long totalTime = 0;

        try (Scanner in = new Scanner(System.in))
        {
            while(in.hasNext()){
                String word = in.next();
                long callTime = System.currentTimeMillis();
                words.add(word);
                callTime = System.currentTimeMillis() - callTime;
                totalTime += callTime;
            }
        }

        Iterator<String> iter = words.iterator();
        for (int i = 1; i <= 20 && iter.hasNext(); i++)
            System.out.println(iter.next());
        System.out.println("...");
        System.out.println(words.size() + "distinct words," +totalTime+ "millsseconds.");
    }
}

解释：
1.Hashset() 构造一个空散列表

TreeSet 树集与散列集非常相似，不过相对于散列集更加有所改进：树集是一个有序集合。

迭代器总是以排好的顺序访问每个元素，但将每一个元素添加到树集中要比散列表慢。

以下是示例：

SortedSet<String> sorter = new TreeSet<>();

sorter.add("Bob");

sorter.add("Amy");

sorter.add("Carl");

for(String s: sorter) System.println(s);

此处的排序是用树来完成的。

 

此外，还有一个优先级队列，这其中的元素可以以任意的顺序插入，但却总是按排序的顺序进行检索。无论何时调用方法都是从队列中的最小元素入手。

 

 

后续持续改进......