线性表（数组 链表 栈 队列 哈希表）：具有n个相同类型元素的有序序列；

    1. package com.ay;
    3. import javafx.beans.binding.ObjectExpression;
    5. public class ArrayList<E> {
    6.     public int size;
    7.     private E[] elements; //所有的元素
    8.     private static final int DEFAULT_CAPACITY = 10;
    9.     private static final int ELEMENT_NOT_FOUND = -1;
    11.     //构造方法
    12.     public ArrayList(int capaticy){
    13.         if (capaticy<DEFAULT_CAPACITY){
    14.             capaticy = DEFAULT_CAPACITY;
    15.         }else{
    16.             capaticy = capaticy;
    17.         }
    18.         elements = (E[]) new Object[capaticy];
    19.     }
    21.     public void rangeCheck(int index){
    22.         if (index<0 || index>= size){
    23.             throw new IndexOutOfBoundsException("Index： "+index + "But Size :"+size);
    24.         };
    25.     }
    27.     public void rangeCheckForAdd(int index){
    28.         if (index<0 || index> size){
    29.             throw new IndexOutOfBoundsException("Index： "+index + "But Size :"+size);
    30.         };
    31.     }
    34.     public void add(E element){
    36.         add(size,element);
    37.     }
    39.     public void add(int index,E element){
    41.         rangeCheckForAdd(index);
    42.         ensureCapacity(size+1);
    43.         for (int i = size-1; i >= index ; i--) {
    44.             elements[i+1] = elements[i];
    45.         }
    46.         elements[index] = element;
    47.         size ++;
    48.     }
    50.     public ArrayList(){
    51.         //elements = new int[DEFAULT_CAPACITY];
    52.         this(DEFAULT_CAPACITY); //调用有参数的构造方法
    53.     }
    55.     public boolean isEmpty(){
    56.         return size==0;
    57.     }
    59.     public E get(int index){
    60.         rangeCheck(index);
    61.         return elements[index];
    62.     }
    64.     public E set(int index,E element){
    65.         rangeCheck(index);
    66.         E old = elements[index];
    67.         elements[index] = element;
    68.         return old;
    69.     }
    71.     /**
    72.     * 查看元素索引
    73.     * @param element
    74.     * @return index
    75.      */
    76.     public int indexOf(E element){
    77.         for (int i = 0; i < size; i++) {
    78.             if (elements[i]==element) return i;
    79.         }
    80.         return ELEMENT_NOT_FOUND;
    81.     }
    83.     /**
    84.      * 是否包含某个元素
    85.      * @param element
    86.      * @return boolean
    87.      */
    88.     public boolean contains(E element){
    89.         return indexOf(element) != ELEMENT_NOT_FOUND;
    90.     }
    92.     // 清楚所有元素
    94.     /**
    95.      * 控制size为0即可，无需清空
    96.      */
    97.     public void clear(){
    98.         for (int i = 0; i < size; i++) {
    99.             elements[i] = null;
    100.         }
    101.         size = 0;
    102.     }
    104.     // java中 打印对象会默认调用 对象.toString() 重写该方法
    105.     public String toString(){
    106.         // 拼接字符串
    107.         StringBuilder string = new StringBuilder();
    108.         string.append("size=").append(size).append(" [");
    109.         for (int i = 0; i < size; i++) {
    110.             string.append(elements[i]);
    111.             if(i!=size-1){
    112.                 string.append(",");
    113.             }
    114.         }
    115.         string.append("]");
    116.         return string.toString();
    117.     }
    119.     public E remove(int index){
    120.         rangeCheck(index);
    121. //        for (int i = 0; i < size; i++) {
    122. //            if (i>index){
    123. //                elements[i-1] = elements[i];
    124. //            }
    125. //        }
    126.         E old = elements[index];
    127.         for (int i = index+1; i <size ; i++) {
    128.             elements[i-1] = elements[i];
    129.         }
    130.         size --;
    131.         elements[size]=null;
    132.         return old;
    133.     }
    134.     Integer
    135.     /**
    136.      * 保证要有capacity的容量
    137.      * @param capacity
    138.      */
    139.     private void ensureCapacity(int capacity){
    140.         int oldCapacity = elements.length;
    141.         if (oldCapacity>=capacity){
    142.             return;
    143.         }
    144.         // 新容量为旧容量的1.5倍
    145.         int newCapacity = oldCapacity + (oldCapacity>>1);
    146.         E[] newElements = (E[]) new Object[newCapacity];
    147.         for (int i =0;i<size;i++){
    148.             newElements[i] = elements[i];
    149.         }
    150.         elements = newElements;
    151.         System.out.println("扩容");
    152.     }
    156. }
    1. package com.ay;
    3. public class Main {
    4.     public static void main(String[] args) {
    5.         Main.test2();
    6.     }
    8.     // 测试person对象 添加到数组
    9.     public static void test2(){
    10.         Person xiaoming = new Person("xiaoming",14);
    11.         Person xiaohong = new Person("xiaohong",30);
    12. //        Person xiaohong = new Person("xiaohong",30);
    14.         ArrayList<Person> arrayList = new ArrayList<>();
    15.         arrayList.add(xiaoming);
    16.         arrayList.add(xiaohong);
    17.         arrayList.add(xiaohong);
    18.         arrayList.add(xiaohong);
    19.         System.out.println(arrayList);
    20.         arrayList.clear();
    21.         System.out.println(arrayList);
    22.         //提醒jvm去做垃圾回收
    23.         System.gc();
    24.     }
    26.     public static void test1(){
    27.         ArrayList<Integer> arrayList = new ArrayList<>();
    29.         arrayList.add(100);
    30.         arrayList.add(10);
    31.         arrayList.add(200);
    32.         arrayList.add(300);
    34.         for (int i=0;i<30;i++){
    35.             arrayList.add(i);
    36.         }
    38.         System.out.println(arrayList);
    41.     }
    42. }