ArrayList的add（）方法很奇怪吗？

Question

I'm working on a (double) linked list implementation using "buckets". In short, A doubly linked list of nodes, each node holding an ArrayList of a set size specified by arguments.

I've Initialized my Nodes and list like this:

public class MyLinkedList<T> implements ADTListInterface<T> {

ArrayList<T> list;

private class Node {

    T value;
    Node next;
    Node previous;
    ArrayList<T> list;

    public Node(Node n, Node p) {

        list = new ArrayList<T>(bucketSize);
        next = n;
        previous = p;
    }
}

private Node head;
private Node tail;
private int bucketSize;

public MyLinkedList(int bucketSize) {

    this.bucketSize = bucketSize;
    head = tail = new Node(null, null);

}

and I have set up my add method like this:

    public void add(T o) {

    Node current = head;

    while (current.list.add(o) != true) {

        if (current.next != null) {

            current = current.next;
        }

        if (current.next == null) {

            current.next = new Node(null,current);
        }
    }
}

When testing the add method with bucketSize = 3 and the following commands:

list.add("a");
list.add("b");
list.add("c");

I expect the head node to contain a list with elements and order as follows:

c,b,a

However, the line: current.list.add(o) appears to add the specified object multiple times until it fills the list. so my node turns out to contain the elements:

a,a,a

Thank you in advance for looking at my code.

Answer 1

Part of your problem lies in your logic that prints the content of the list and part of it is in your add method. First of all your current node is a local variable of add method. That means second 'if' statement:

if (current.next != null) {

            current = current.next;
}

is not doing anything useful. You set current to point at the same object as current.next does but then you leave the method and your reference is destroyed. It does not make sense.

Assuming you invoked constructor of your list and then added three elements: "a", "b", "c" here is how your Node objects will behave on heap.

After constructor finished there is one Node object on the heap which looks like: { list -> {empty}, prev -> null, next -> null } this object is referenced by the head and tail reference variables. Note that if you invoke new ArrayList(bucketSize) it will create empty list with 'bucketSize' initial capacity.

After 1st call to add("a"):

nodeObject#1 : { list -> {"a"}, prev -> null, next -> nodeObject#2 }

nodeObject#2 : { list -> {empty}, prev -> nodeObject#1, next -> null}

nodeObject#1 is accesible via head or tail. nodeObject#2 is accesible via head.next or tail.next.

After 2nd call to add("b"):

nodeObject#1 : { list -> {"a","b"}, prev -> null, next -> nodeObject#2 }

nodeObject#2 : { list -> {empty}, prev -> nodeObject#1, next -> null}

After 3rd call to add("c"):

nodeObject#1 : { list -> {"a","b","c"}, prev -> null, next -> nodeObject#2 }

nodeObject#2 : { list -> {empty}, prev -> nodeObject#1, next -> null}

Also having prev and next in your Node suggest that your list should be bi directional that means you need to implement methods like add_at_the_end and add_at_the_beginning but that's a different story ( I can show some examples too if needed ). The next question is why you use ArrayList as a Node class field. T value should be enough.

Here is my example of simple list implementation without ArrayList. There is iterator method that returns instance of Iterator which can be used to display list's elements.

package com.playground;

import java.util.ArrayList;
import java.util.Iterator;

class CustomList<T>{
    private class Node{
        Node prev;
        Node next;

        T value;
        Node(T rVal, Node p, Node n){
            this.value = rVal;
            this.prev = p;
            this.next = n;
        }
        void setNext(Node n){ this.next = n; }
        void setPrev(Node p){ this.prev = p; }
    }

    private Node head;
    private Node tail;



    public void add(T element) {
        if(tail == null && head == null){
            head = new Node(element, null,null);
            tail = head;
        }
        else{
            Node tmp = new Node(element, tail, null);
            tail.setNext( tmp );
            tail = tmp;
        }

    }

    public Iterator<T> iterator() {

        return new Iterator<T>(){
            Node current = head;
            @Override
            public boolean hasNext() {
                // TODO Auto-generated method stub
                return current != null;
            }

            @Override
            public T next() {
                Node tmp = current;
                current = tmp.next;
                return tmp.value;
            }

            @Override
            public void remove() {
                // TODO Auto-generated method stub

            } };
    }

}

public class CustomListTest {
    public static void main(String [] args){
        CustomList<String> list = new CustomList<String>();
        list.add("my");
        list.add("custom");
        list.add("list");       

        Iterator<String> forwardIterator = list.iterator();
        while( forwardIterator.hasNext()){
            System.out.println( forwardIterator.next());
        }

    }
}