这是一个测试

group01/245205213/.classpath

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

group01/245205213/.gitignore

@@ -0,0 +1 @@
+/bin/

group01/245205213/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>245205213Learning</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

group01/245205213/src/JavaTest.java

@@ -0,0 +1,75 @@
+import com.collection.list.ArrayList;
+import com.collection.list.LinkedList;
+import com.collection.list.Queue;
+import com.collection.list.Stack;
+
+public class JavaTest {
+
+	/**
+	 * @param args
+	 */
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+	    //测试ArrayList
+//         ArrayList arrList = new ArrayList();
+//         for (int i = 0; i < 5; i++) { 
+//             arrList.add(i); 
+//         } 
+//         arrList.add(5, 10);
+//         System.out.println("size:" + arrList.size()); 
+//         System.out.println("get:" + arrList.get(2)); 
+//         System.out.println(arrList); 
+//         System.out.println("remove:" + arrList.remove(2)); 
+//         System.out.println("remove:" + arrList.remove(5));
+//         System.out.println(arrList); 
+	    //测试LinkedList
+//	    LinkedList linkedList = new LinkedList();
+//	    for (int i = 0; i < 20; i++) {
+//	        linkedList.add(i);
+//        }
+//        System.out.println("size:"+ linkedList.size());
+//        System.out.println("get:" + linkedList.get(1));
+//        System.out.println(linkedList);
+//        System.out.println("remove:" + linkedList.remove(1));
+//        System.out.println("remove:" + linkedList.remove(15));
+//        System.out.println(linkedList);
+//        linkedList.addFirst(22);
+//        System.out.println("size:"+ linkedList.size());
+//        System.out.println(linkedList);
+//        System.out.println("removeFirst:"+ linkedList.removeFirst());
+//        System.out.println(linkedList);
+//        linkedList.add(5, 999);
+//        System.out.println(linkedList);
+	    //测试Stack
+//	    Stack stack = new Stack();
+//        System.out.println("isEmpty:" + stack.isEmpty());
+//	    for (int i = 0; i < 10; i++) {
+//	        stack.push(i);
+//        }
+//        System.out.println("size:" + stack.size());
+//        System.out.println("isEmpty:" + stack.isEmpty());
+//	    System.out.println(stack);
+//        System.out.println("pop:" + stack.pop());
+//        System.out.println("pop:" + stack.pop());
+//        System.out.println(stack);
+//        System.out.println("peek:" + stack.peek());
+//        System.out.println("peek:" + stack.peek());
+//        System.out.println(stack);
+//        System.out.println("size:" + stack.size());
+	    //测试Queue
+	    Queue queue = new Queue();
+        System.out.println("isEmpty:" + queue.isEmpty());
+	    for (int i = 0; i < 10; i++) {
+            queue.enQueue(i);
+        }
+        System.out.println("isEmpty:" + queue.isEmpty());
+        System.out.println("size:" + queue.size());
+        System.out.println(queue);
+        System.out.println("deQueue:" + queue.deQueue());
+        System.out.println(queue);
+
+	}
+
+}

group01/245205213/src/com/collection/list/ArrayList.java

@@ -0,0 +1,80 @@
+package com.collection.list;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+public class ArrayList<E> implements List<E> {
+
+    private int size = 0;
+    private Object[] elementData = new Object[10];
+
+    public ArrayList() {
+        System.out.println("test1");
+    }
+    public ArrayList(Collection<? extends E> c) {
+        size = c.size();
+        elementData = c.toArray();
+    }
+
+    private void ensureCapacity() {
+        if (elementData.length+1 > size) {
+            elementData = Arrays.copyOf(elementData, size*3/2+1);
+        } 
+    }
+
+    public String toString() {
+        return Arrays.toString(Arrays.copyOf(elementData, size)) ;
+    }
+
+    public boolean add(E e) {
+        ensureCapacity();
+        elementData[size++] = e;
+        return true;
+    }
+
+    public boolean add(int index, E e) {
+        if (index > size || index < 0) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+        ensureCapacity();
+        System.arraycopy(elementData, index, elementData, index+1, size-index);
+        elementData[index] = e;
+        size++;
+        return true;
+    }
+
+    public E get(int index) {
+        if (index >= size) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+        return elementData(index);
+    }
+
+    @SuppressWarnings("unchecked")
+    private E elementData(int index) {
+        return (E) elementData[index];
+    }
+
+    public E remove(int index) {
+        if (index >= size || index < 0) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+        E oldValue = elementData(index);
+        System.arraycopy(elementData, index+1, elementData, index, size-index-1);
+        elementData[--size] = null;
+        return oldValue;
+    }
+
+    public int size() {
+        return size;
+    }
+
+
+    public boolean clear() {
+        for (int i = 0; i < elementData.length; i++) {
+            elementData[i] = null;
+        }
+        size = 0;
+        return true;
+    }
+}

group01/245205213/src/com/collection/list/ArrayListTest.java

@@ -0,0 +1,51 @@
+package com.collection.list;
+
+import java.util.Arrays;
+
+import org.junit.Assert;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class ArrayListTest {
+    private ArrayList<Integer> al;
+    @BeforeEach
+    void setUp() throws Exception {
+        al = new ArrayList<Integer>(Arrays.asList(1,2,3,4,5,6,7,8,9,10,11));
+    }
+    @AfterEach
+    void tearDown() throws Exception {
+        System.out.println(al);
+    }
+
+    @Test
+    void add() {
+        System.out.println("add:***********");
+        Assert.assertEquals(true, al.add(2));
+    }
+
+    @Test
+    void addElement() {
+        System.out.println("addElement:***********");
+        Assert.assertEquals(true, al.add(1,3));
+    }
+
+    @Test
+    void get() {
+        System.out.println("get:***********");
+        Assert.assertEquals(new Integer(1), al.get(0));
+    }
+
+    @Test
+    void clear() {
+        System.out.println("clear:***********");
+        Assert.assertEquals(true, al.clear());
+    }
+
+    @Test
+    void remove() {
+        System.out.println("remove:***********");
+        Assert.assertEquals(new Integer(2), al.remove(1));
+    }
+
+}

group01/245205213/src/com/collection/list/LinkedList.java

@@ -0,0 +1,126 @@
+package com.collection.list;
+
+import java.util.Arrays;
+import java.util.NoSuchElementException;
+
+public class LinkedList<E> implements List<E> {
+    private Node<E> first;
+    private Node<E> last;
+    private int size = 0;
+
+    public boolean add(E e) {
+        if (first == null) {
+            first = new Node<E>();
+            first.data = e;
+            last = first;
+            size++;
+        } else {
+            Node<E> node = new Node<E>();
+            node.data = e; 
+            node.pre = last;
+            last.next = node;
+            last = node;
+            size++;
+        }
+        return true;
+    }
+
+    public E getFirst() {
+        return first.data;
+    }
+
+    public E getLast() {
+        return last.data;
+    }
+
+    public E get(int index) {
+        isNotElementIndex(index);
+        return getNode(first,index).data;
+    }
+
+    private void isNotElementIndex(int index) {
+        if (index > size-1 || index < 0) {
+            throw new NoSuchElementException();
+        }
+    }
+
+    private Node<E> getNode(Node<E> n, int index) {
+        if (index == 0) {
+            return n;
+        }
+        return getNode(n.next, index-1);
+    }
+
+    public E remove(int index) {
+        isNotElementIndex(index);
+        Node<E> node = getNode(first, index);
+        E e = node.data;
+        node.pre.next = node.next;
+        node.next.pre = node.pre;
+        node.data = null;
+        node.next = null;
+        node.pre = null;
+        size--;
+        return e;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public void addFirst(E e) {
+        Node<E> node = new Node<E>();
+        node.next = first;
+        node.data = e;
+        first.pre = node;
+        first = node;
+        size++;
+    }
+
+    public E removeFirst() {
+        E e = first.data;
+        Node<E> next = first.next;
+        first.next = null;
+        first.data = null;
+        first = next;
+        size--;
+        return e;
+    }
+
+    private static class Node<E> {
+        E data;
+        Node<E> next;
+        Node<E> pre;
+    }
+
+    public boolean add(int index, E e) {
+        Node<E> node = new Node<E>();
+        Node<E> pre = getNode(first, index).pre;
+        node.data = e;
+        node.next = getNode(first, index);
+        node.next.pre = node;
+        node.pre = pre;
+        node.pre.next = node;
+        size++;
+        return true;
+
+    }
+
+    public String toString() {
+        int index = 0;
+        Object[] objs = new Object[size];
+        Node<E> node = first;
+        while (node != null) {
+            objs[index++] = node.data;
+            node = node.next;
+        }
+        return Arrays.toString(objs);
+    }
+
+
+    @Override
+    public boolean clear() {
+        // TODO Auto-generated method stub
+        return true;
+    }
+}

group01/245205213/src/com/collection/list/LinkedListTest.java

@@ -0,0 +1,36 @@
+package com.collection.list;
+
+import org.junit.Assert;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class LinkedListTest {
+    LinkedList<Integer> ll = new LinkedList<Integer>();
+
+    @BeforeEach
+    void setUp() throws Exception {
+    }
+
+    @AfterEach
+    void tearDown() throws Exception {
+    }
+
+    @Test
+    void add() {
+        ll.add(2);
+        ll.add(2);
+        Assert.assertEquals(true, ll.add(1));
+        Assert.assertEquals(new Integer(2), ll.getFirst());
+        Assert.assertEquals(new Integer(1), ll.getLast());
+        Assert.assertEquals(new Integer(2), ll.get(1));
+        Assert.assertEquals(new Integer(3), new Integer(ll.size()));
+        Assert.assertEquals(new Integer(2), ll.remove(1));
+        ll.add(4);
+        ll.addFirst(4);
+        ll.add(2, 3);
+        Assert.assertEquals(new Integer(4), ll.removeFirst());
+        System.out.println(ll);
+    }
+
+}