链表（四）

假设你要遍历一张链表，然后需要的每个链接点上执行一些操作。例如一张链表存储职工表，需要提高拿最低工资员工的薪水，这样无法做出来。

若是数组，这种操作很容易。可以用数组下标跟踪每个数据项，并进行操作，再指向下一个坐标。链表虽然可以用 find() 找出指定的链接点，但是这种需要频繁比较，而且多次遍历。

    for(int i = 0 ; i < emps.length; i++){
        Emp emp = emps[i];
        if(emp.getSalary() < 1800){
        　　emp.setSalary(1800);
        }
    }

迭代器：迭代器类可以包含对数据结构中的数据项引用，并用来遍历这些结构的对象。

public class Link {

    private int iData;
    private double dData;
    private Link next;

    public Link(int i, double d) {
    　　this.iData = i;
    　　this.dData = d;
    }

    public void displayLink() {
    　　System.out.println("{ " + iData + " , " + dData + " }");
    }

    public Link getNext() {
    　　return next;
    }

    public void setNext(Link next) {
    　　this.next = next;
    }

    public int getiData() {
    　　return iData;
    }

    public double getdData() {
    　　return dData;
    }

}

public class LinkList {

    private Link first;

    public boolean isEmpty() {
    　　return first == null;
    }

    public void insertFirst(int i, double d) {
    　　Link newLink = new Link(i, d);
    　　newLink.setNext(first);
    　　first = newLink;
    }

    public Link getFirst() {
    　　return first;
    }

    //这种方式比较危险
    public void setFirst(Link f) {
    　　first = f;
    }

    public ListIterator getIterator() {
    　　return new ListIterator(this);
    }

    public void displayList() {
    　　Link current = first;
    　　System.out.println("List (First --> Last)");
    　　while (current != null) {
        　　current.displayLink();
        　　current = current.getNext();
    　　}
    }

}

public class ListIterator {

    private Link current;
    private Link pervious;
    private LinkList ourList;

    public ListIterator(LinkList ourList) {
        this.ourList = ourList;
        reset();
    }

    public void reset() {
        current = ourList.getFirst();
        pervious = null;
    }

    public boolean hasNext() {
        return (current.getNext() == null);
    }

    public void next() {
        pervious = current;
        current = current.getNext();
    }

    public Link getCurrent() {
        return current;
    }

    public void insertAfter(int i, double d) {
        Link newLink = new Link(i, d);
        if (ourList.isEmpty()) {
            ourList.setFirst(newLink);
            current = newLink;
        } else {
            newLink.setNext(current.getNext());
            current.setNext(newLink);
            next();
        }
    }

    public void insertBefore(int i, double d) {
        Link newLink = new Link(i, d);
        if (ourList.isEmpty()) {
            ourList.setFirst(newLink);
            current = newLink;
        } else {
            pervious.setNext(newLink);
            newLink.setNext(current);
            current = newLink;
        }
    }

    public Link deleteCurrent() {
        if (pervious != null) {
            pervious.setNext(current.getNext());
            if (hasNext()) {
                reset();
            } else {
                current = current.getNext();
            }
        } else {
            ourList.setFirst(current.getNext());
            reset();
        }
        return current;
    }
}

    public static void main(String[] args) {
    　　LinkList ll = new LinkList();
    　　ll.insertFirst(10, 10.5);
    　　ll.insertFirst(9, 9.5);
    　　ll.insertFirst(8, 8.5);
    　　ll.insertFirst(7, 7.5);
    　　ll.insertFirst(6, 6.5);
    　　ll.insertFirst(5, 5.5);
    　　ll.displayList();
    　　System.out.println("-------------------------");
    　　ListIterator iterator = ll.getIterator();
    　　while(iterator.hasNext()){
        　　iterator.next().displayLink();
    　　}
    　　System.out.println("-------------------------");
    　　iterator.reset();
    　　iterator.insertAfter(77, 77.5);
    　　iterator.insertBefore(88, 88.5);
    　　ll.displayList();
    }

打印结果：
List (First --> Last)
{ 5 , 5.5 }
{ 6 , 6.5 }
{ 7 , 7.5 }
{ 8 , 8.5 }
{ 9 , 9.5 }
{ 10 , 10.5 }
-------------------------
{ 5 , 5.5 }
{ 6 , 6.5 }
{ 7 , 7.5 }
{ 8 , 8.5 }
{ 9 , 9.5 }
{ 10 , 10.5 }
-------------------------
List (First --> Last)
{ 5 , 5.5 }
{ 88 , 88.5 }
{ 77 , 77.5 }
{ 6 , 6.5 }
{ 7 , 7.5 }
{ 8 , 8.5 }
{ 9 , 9.5 }
{ 10 , 10.5 }