Java集合的List

List底层是数组，是有序可重复的，下标从0开始，它有自己独有的迭代方式（也可以使用迭代器迭代）
初始化容量为10，扩容后为原来的1.5倍。
有三个实现类：ArrayList、Vector、LinkedList。
ArrayList a = new ArrayList();
a.get(i); //for循环，i为数组中下标

list：

set(index,value)、get(index)、indexof(value)、lastindexof(value)、remove(index)
set：修改index下标的元素的值
get：得到index下标的元素的值
indexOf：得到值为value的元素在表中存储的第一个下标
lastIndexOf：得到值为value的元素在表中存储的最后一个下标
remove：将index下标的元素从表中删除

package Collection;
import java.util.ArrayList;
import java.util.List;
public class ListTest {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(1);
        list.add(1);
        list.add(1);
        list.add(1);
        list.add(1);
        display(list);	 //5个1
        System.out.println();
        list.set(2,5);  //将下标为2的元素的值修改为5
        display(list); //1 1 5 1 1
        System.out.println();
        list.set(3,"string");   
        display(list);  // 1 1 5 string 1
        System.out.println();
        list.set(4,'c'); 
        display(list); //1 1 5 string c
    }
    public static void display(List list){
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

将hashset集合转换成list集合
Collection c = new HashSet();
List ls = new ArrayList©;

单双向链表的构建。

package Collection;

public class NodeTest {
    public static void main(String[] args) {
        Node n = new Node();
        System.out.println(n.getData());
//        n.addNode(2);
//        System.out.println(n.size());
        LinkList ll = new LinkList(n);
        System.out.println(ll.getHeadNode().getData());
        System.out.println(ll.getHeadNode().getNext());
//        ll.addNode(2);
        System.out.println(ll.getHeadNode().getNext());
        System.out.println(ll.size());
    }
}
class Node{
    private int data;
    private Node next;
    public Node() {
    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

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

    public Node(int data, Node next) {
        this.data = data;
        this.next = next;

    }
}
class LinkList{
    private Node headNode;
    private int index = 0;

    public LinkList() {
    }

    /**
     * 链表在创建的过程中，如果创建的时候没有实际节点，那么应该创造空表。
     * 此时不应该将空节点赋予一个地址空间，然后将data、next分别设置为空浪费内存。
     * @param headNode
     */
    public LinkList(Node headNode) {
        if (headNode == null) System.out.println("头结点为空，创造的链表为空。");
        this.headNode = headNode;
        this.index++;
    }

    public Node getHeadNode() {
        return headNode;
    }

    public void setHeadNode(Node headNode) {
        this.headNode = headNode;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    /**
     *
     * @param data
     */
    public void addNode(int data){
        Node n = headNode;
        while (n.getNext() != null){
            n = n.getNext();
        }
        Node an = new Node(data,null);    //set data
        n.setNext(an);
        index++;
    }

    /**
     *
     */
    public void delNode(int data){
        Node n = headNode;
        if (n == null) {
            System.out.println("删除失败，链表中已没有元素！");
            return;
        }
        if (headNode.getData() == data) headNode = null;
        while (n.getNext().getData() != data && n != null){
            n = n.getNext();
        }
        if (n == null){
            System.out.println("删除失败，链表中没有该元素！");
            return;
        }
        Node dn = n.getNext();
        n.setNext(dn.getNext());
        index--;
    }
    /**
     *
     * @return
     */
    public int size(){
        return index;
    }
}

将非线程安全的集合变成线程安全的。

List ls = new ArrayList();
Collections.synchronize(ls);