鏈表是數據結構中最基礎的內容，鏈表在存儲結構上分成兩種：數組形式儲存，鏈式存儲。

相比c語言需要的結構體，在java中由於有了面向對象編程，將指針‘藏’了起來，不需要分配內存。

所以只需要創建一個對象數組，為了能讓鏈表更加實用，方便存儲非基本類型的對象，所以使用了泛型。

菱形運算符<>中放你自己寫的或者基本類型，比如你創建了一個Stdent類，想用鏈表將很多學生的信息存起來。

就可以myArrayList<Student> a=new myArrayList();這個鏈表就都存Student類的對象了。

數組鏈表的源碼：

  1 import java.util.Arrays;
 
  2 
  3 /**
  4  * @author 李正陽
  5  * @param <E> 泛型：所存儲的對象
  6  */
  7 public class myArrayList<E> implements List<E> {
  8     /**
  9      * DEFAULT_SIZE 數組鏈表儲存的最大值
 10      * elementData 存儲元素的數組
 11      * capacity當前數組鏈表可以存儲的個數（為了擴容存在）
 12      * size當前鏈表存儲的個數
 13      */
 14     private
 
 final int DEFAULT_SIZE = 16;
 15     private Object[] elementData;
 16     private int capacity;
 17     public int size;
 18 
 19     /**
 20      * 初始化數組棧
 21      */
 22     public myArrayList() {
 23         elementData = new Object[DEFAULT_SIZE];
 24         size = 0;
 25         capacity=DEFAULT_SIZE;
 
 26     }
 27 
 28     /**
 29      * 在數組鏈表的最後添加元素
 30      * @param data 添加的元素
 31      * @return true 添加成功 false 添加失敗
 32      */
 33     @Override
 34     public boolean add(E data) {
 35         if(isFull()) {
 36             relloc();
 37             elementData[size] = data;
 38             size++;
 39         }else {
 40             elementData[size] = data;
 41             size++;
 42         }
 43         return true;
 44     }
 45 
 46     /**
 47      * 判滿函數
 48      * @return true 滿 false 未滿
 49      */
 50     @Override
 51     public boolean isFull() {
 52         if (size == DEFAULT_SIZE-1) {
 53             return true;
 54         } else {
 55             return false;
 56         }
 57     }
 58     /**
 59      * 判空函數
 60      * @return true 空 false 未空
 61      */
 62     @Override
 63     public boolean isEmpty() {
 64         if (size ==0) {
 65             return true;
 66         } else {
 67             return false;
 68         }
 69     }
 70 
 71     /**
 72      * 刪除元素
 73      * @param number 刪除元素在數組中的位置
 74      * @return
 75      */
 76     @Override
 77     public E remove(int number){
 78 
 79             E temp;
 80             if (number == size) {
 81                 temp = (E) elementData[size - 1];
 82                 size--;
 83             } else if(number<size) {
 84                 temp = (E) elementData[number - 1];
 85                 for (int i = number; i < size; i++) {
 86                     elementData[i] = elementData[i + 1];
 87                 }
 88                 size--;
 89             }else {
 90                 throw new ArrayIndexOutOfBoundsException();
 91             }
 92             return temp;
 93 
 94     }
 95 
 96     /**
 97      * 刪除數組最後的元素
 98      * @return 刪除那個元素
 99      */
100     @Override
101     public E remove(){
102         E temp;
103         temp = (E) elementData[size-1];
104         size--;
105         return temp;
106     }
107 
108     /**
109      * 設置某一個位置元素
110      * @param i 在數組的位置
111      * @param data 替換的元素
112      */
113     @Override
114     public void set(int i,E data){
115         if(i<=size) {
116             elementData[i - 1] = data;
117         }else {
118             throw new ArrayIndexOutOfBoundsException();
119         }
120     }
121 
122     /**
123      * 取得數組中某個位置的元素
124      * @param i 數組的位置
125      * @return 這個位置的對象
126      */
127     @Override
128     public E get(int i){
129         E temp;
130         if(i<=size) {
131              temp = (E) elementData[i - 1];
132             return temp;
133         }else {
134             throw new ArrayIndexOutOfBoundsException();
135         }
136     }
137 
138     /**
139      * 判斷一條鏈表是否為回文
140      * @return false 否 true 是
141      */
142     @Override
143     public boolean isPalindrome() {
144         if(!isEmpty()) {
145             for (int i = 0, j = size - 1; i < size - 1; i++, j--) {
146                 if (String.valueOf(elementData[i]).equals(String.valueOf(elementData[j]))) {
147                 } else {
148                     return false;
149                 }
150             }
151             return true;
152         }else {
153            throw new NullPointerException();
154         }
155     }
156 
157     /**
158      * 輸出鏈表中所有元素
159      */
160     @Override
161     public void traver() {
162         for (int i=0;i<size;i++){
163             System.out.print(elementData[i]+" ");
164         }
165     }
166 
167     /**
168      * 擴容將數組擴容為兩倍
169      */
170     private void relloc(){
171         capacity=DEFAULT_SIZE*2;
172         elementData=Arrays.copyOf(elementData,DEFAULT_SIZE*2);
173     }
174 }

List接口：

 1 /**
 2  * @author 李正陽 
 3  * @param <E> 泛型
 4  */
 5 public interface List<E> {
 6     public boolean add(E data) ;
 7 
 8     /**
 9      * 鏈式不需要這個方法
10      */
11     default boolean isFull() {
12         return false;
13     }
14     public boolean isEmpty() ;
15     public E remove(int number);
16     public E remove();
17     public void set(int i,E data);
18     public E get(int i);
19     public boolean isPalindrome();
20     public void traver();
21 }

數據結構java（一）數組鏈表