Update SinglyLinkedListTest.java

pom.xml

@@ -27,8 +27,8 @@
                     <artifactId>maven-compiler-plugin</artifactId>
                     <version>3.8.1</version>
                     <configuration>
-                        <source>1.8</source>
-                        <target>1.8</target>
+                        <source>17</source>
+                        <target>17</target>
                     </configuration>
                 </plugin>
             </plugins>

src/main/java/com/nbee/solution/practice/DynamicArray.java

@@ -1,16 +1,22 @@
 package com.nbee.solution.practice;
 
-public class DynamicArray {
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.function.Consumer;
+import java.util.stream.IntStream;
+
+public class DynamicArray implements Iterable<Integer> {
     private int size = 0;
     private int capacity = 8;
-    private int[] array = new int[capacity];
+    private int[] array = {};
 
     public void addList(int element) {
         add(size, element);
     }
 
     public void add(int index, int element) {
-        if (index < 0 || index > size){
+        checkAndGrow();
+        if (index < 0 || index > size) {
             throw new IndexOutOfBoundsException();
         }
         if (index >= 0 && index < size) {
@@ -20,14 +26,66 @@ public class DynamicArray {
         size++;
     }
 
+    private void checkAndGrow() {
+        if (size == 0) {
+            array = new int[capacity];
+        } else if (size == capacity) {
+            capacity = capacity + (capacity >>> 1);
+            int[] newArray = new int[capacity];
+            System.arraycopy(array, 0, newArray, 0, size);
+            array = newArray;
+        }
+    }
+
     public int getSize() {
         return size;
     }
+
     public int get(int index) {
-        if (index < 0 || index >= size){
+        if (index < 0 || index >= size) {
             throw new IndexOutOfBoundsException();
         }
         return array[index];
     }
+
+    public void forEach0(Consumer<Integer> consumer) {
+        for (int i = 0; i < size; i++) {
+            consumer.accept(array[i]);
+        }
+    }
+
+
+    @Override
+    public Iterator<Integer> iterator() {
+        return new Iterator<Integer>() {
+            int i = 0;
+
+            @Override
+            public boolean hasNext() {
+                return i < size;
+            }
+
+            @Override
+            public Integer next() {
+                return array[i++];
+            }
+        };
+    }
+
+    public IntStream stream() {
+        return IntStream.of(Arrays.copyOfRange(array, 0, size));
+    }
+
+    public int remove(int index) {
+        int removed = array[index];
+        if (index < size - 1) {
+            System.arraycopy(array, index + 1, array, index, size - index - 1);
+            size--;
+        }
+        return removed;
+    }
+    public String toString() {
+        return Arrays.toString(Arrays.copyOfRange(array, 0, size));
+    }
 }
 

src/main/java/com/nbee/solution/practice/SinglyLinkedList.java

@@ -0,0 +1,81 @@
+package com.nbee.solution.practice;
+
+import java.util.Iterator;
+import java.util.function.Consumer;
+
+/**
+ * 链表类
+ */
+public class SinglyLinkedList implements Iterable<Integer> {
+    private Node head;
+
+    @Override
+    public Iterator<Integer> iterator() {
+        return new Iterator<Integer>() {
+            Node p = head;
+
+            @Override
+            public boolean hasNext() {
+                return p != null;
+            }
+
+            @Override
+            public Integer next() {
+                int value = p.value;
+                p = p.next;
+                return value;
+            }
+        };
+    }
+
+    private Node findLast() {
+        if (head == null) {
+            return null;
+        }
+        Node p;
+        for (p = head; p != null; p = p.next) {
+        }
+        return p;
+    }
+
+    public void addLast(int value) {
+        Node last = findLast();
+        if (last == null){
+            addFirst(value);
+            return;
+        }
+        last.next = new Node(value, null);
+    }
+
+    private static class Node {
+        int value;
+        Node next;
+
+        Node(int value, Node next) {
+            this.value = value;
+            this.next = next;
+        }
+    }
+
+    public void addFirst(int value) {
+        //链表为空
+//        head = new Node(value,null);
+        //链表非空，包含了链表为空的情况
+        head = new Node(value, head);
+    }
+
+    public void loop(Consumer<Integer> consumer) {
+        Node p = head;
+        while (p != null) {
+            consumer.accept(p.value);
+            p = p.next;
+        }
+    }
+
+    public void loop0(Consumer<Integer> consumer) {
+        for (Node p = head; p != null; p = p.next) {
+            consumer.accept(p.value);
+        }
+    }
+}
+

src/test/java/com/nbee/solution/practice/DynamicArrayTest.java

@@ -1,44 +1,79 @@
 package com.nbee.solution.practice;
 
-import org.junit.Assert;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import java.util.List;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertIterableEquals;
 
 class DynamicArrayTest {
 
     private DynamicArray dynamicArray;
 
     @BeforeEach
-    void setUp() {
+    public void setUp() {
         dynamicArray = new DynamicArray();
     }
 
     @Test
-    void testAddListInitial() {
+    public void testAddListInitial() {
         dynamicArray.addList(1);
         dynamicArray.addList(3);
         dynamicArray.addList(5);
-        for (int i = 0; i < 3; i++){
+        dynamicArray.add(1, 7);
+        for (int i = 0; i < 4; i++) {
             System.out.println(dynamicArray.get(i));
         }
     }
 
-
     @Test
-    void testAddListMultiple() {
-        dynamicArray.addList(2);
+    public void test01() {
+        dynamicArray.addList(1);
         dynamicArray.addList(3);
-        dynamicArray.addList(4);
-        assertEquals(3, dynamicArray.getSize(), "Size should be 3 after adding three elements.");
+        dynamicArray.addList(5);
+        dynamicArray.add(1, 7);
+        dynamicArray.forEach(element -> {
+            System.out.println(element);
+        });
     }
-
     @Test
-    void testAddListCapacityExceeded() {
-        for (int i = 0; i < 8; i++) {
+    public void test02() {
+        dynamicArray.addList(1);
+        dynamicArray.addList(3);
+        dynamicArray.addList(5);
+        dynamicArray.add(1, 7);
+        for (Integer element : dynamicArray) {
+            System.out.println(element);
+        }
+    }
+    @Test
+    public void test03() {
+        dynamicArray.addList(1);
+        dynamicArray.addList(3);
+        dynamicArray.addList(5);
+        dynamicArray.add(1, 7);
+        dynamicArray.stream().forEach(element -> {
+            System.out.println(element);
+        });
+    }
+    @Test
+    public void test04() {
+        dynamicArray.addList(1);
+        dynamicArray.addList(3);
+        dynamicArray.addList(5);
+        dynamicArray.add(1, 7);
+        int removed =dynamicArray.remove(1);
+        System.out.println("removed: " + removed);
+        for (Integer element : dynamicArray) {
+            System.out.println(element);
+        }
+    }
+    @Test
+    public void test05() {
+        for (int i = 0; i < 9; i++) {
             dynamicArray.addList(i);
         }
-        assertEquals(8, dynamicArray.getSize(), "Size should be 8 after adding elements up to capacity.");
+        System.out.println(dynamicArray.toString());
+        assertIterableEquals(List.of(0, 1, 2, 3, 4, 5, 6, 7, 8), dynamicArray, "List should be equal");
     }
-
 }

src/test/java/com/nbee/solution/practice/SinglyLinkedListTest.java

@@ -0,0 +1,25 @@
+package com.nbee.solution.practice;
+
+import org.junit.Test;
+
+public class SinglyLinkedListTest {
+    private SinglyLinkedList list = new SinglyLinkedList();
+    @Test
+    public void singlyLinkedListAddFirstTest(){
+        list.addFirst(1);
+        list.addFirst(3);
+        list.addFirst(5);
+        list.addFirst(6);
+        list.loop0(i -> System.out.println(i + " "));
+    }
+    @Test
+    public void singlyLinkedListIteratorTest(){
+        list.addFirst(1);
+        list.addFirst(3);
+        list.addFirst(5);
+        list.addFirst(6);
+        for (Integer value: list) {
+            System.out.println(value);
+        }
+    }
+}