/***
* list集合的底層使用陣列實現的
* 陣列的特點是 讀取快，因為記憶體是連續的 插入刪除慢
*
* 連結串列的特點相反 ： 讀取慢，因為需要記憶體不是連續的，需要找到頭節點，順序遍歷。但是插入刪除會很快
*/

package com.bjsxt.collection;

import java.util.ArrayList;
import java.util.List;

import sun.misc.SharedSecrets;

public class MyList {
	
	private Object[] installArr={};
	
	private Object[] elementData=null;
	
	private int size=0;//記錄裡面到底儲存了幾個元素
	
	private int installSize=10;
	public MyList(){
		//比較方便，這裡我這麼寫
		this.elementData=new Object[installSize];
	}
	
	public MyList(int sizeParam) throws Exception{
		if(this.size<=0){
			throw new Exception("越界");
		}
		this.elementData=new Object[sizeParam];
	}
	
	public void add(Object obj){
		grow();//若有必要擴容，沒必要的話自己玩
		elementData[size]=obj;
		size++;
	}
	
	//移除某個元素 此處不考慮obj為null的情況
	public void remove(Object obj){
		//需要遍歷陣列，找打他 幹掉他
		for(int i=0;i<elementData.length; i++){
			Object ob=elementData[i];
			if(ob.equals(obj)){
				int numMoved = size - i - 1;
		        if (numMoved > 0){
		        	//這個函式的意思
		        	//第一個elementData是原來的陣列
		        	//第二個elementData是新的陣列，這裡只不過是特殊，為了不再新建一個數組就用了他自己
		        	//第二個引數 的意思是 要複製元素的的起始下標
		        	//第四個傳引數的意思是 覆蓋到新陣列的 起始下標
		        	//第五個引數是從原陣列複製的長度是多少
		            System.arraycopy(elementData, i+1, elementData, i,
		                             numMoved);
		            //此時size應該減少1個了
		            size--;
		            //到這完事了，沒有，我們要把原來最後一個元素置為空才行啊 你說呢
		            //因為中間少了一個元素，最後一個元素的值沒有被覆蓋還在那兒呢
		            System.out.println("size的值為"+size);
		            elementData[size]=null;
		            
		        }    
		        break;
			}
		}
	}
	
	//獲得集合裡面的物件
	Object getValue(int index ) throws Exception{
		indexIsvalid(index);
		return elementData[index];
	}	
	
	
	//檢查陣列越界	
	void indexIsvalid(int index ) throws Exception{
		if(index<0||index>size){
			throw new Exception("越界啦");
		}
	}
	
	//擴容
	public void grow(){
		if(size==elementData.length){
			Object[] elementDataNew=new Object[size*2+10];//規則自己定義
			System.arraycopy(elementData, 0, elementDataNew, 0, size);
			elementData=elementDataNew;
			System.out.println("擴容成功，現在的陣列大小為"+elementData.length);
		}
	}
	
	//遍歷List
	public void whileMyList(){
		//相當於遍歷陣列
		for(Object obj:elementData){
			if(obj!=null){
				System.out.println(obj);
			}else{
				System.out.println("null");
			}
			
		}
	}

	public static void main(String[] args) throws Exception {
		
		MyList list=new MyList();
		
		for(int i=0;i<15;i++){
			list.add(i);
		}
		
		list.whileMyList();
		System.out.println("剔除一個元素");
		list.remove(10);
		System.out.println("剔除一個元素後，陣列長度"+list.elementData.length);
		list.whileMyList();
		
		Object obj=list.getValue(3);
		System.out.println("getValue方法得到的物件是"+obj);
				
	}

}

 

擴容成功，現在的陣列大小為30
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
null
null
null
null
null
null
null
null
null
null
null
null
null
null
null
剔除一個元素
size的值為14
剔除一個元素後，陣列長度30
0
1
2
3
4
5
6
7
8
9
11
12
13
14
null
null
null
null
null
null
null
null
null
null
null
null
null
null
null
null
getValue方法得到的物件是3

上面的程式使用陣列實現了ArrayList，裡面用到了一個很重要的方法， System.arraycopy這個的作用就是將一個數組從某個下標開始的後續n個元素，插入到另一個數組從某個下標開始後的n個元素

比如：第一個陣列arrOld是 {1，2，3，4，5} //長度為5

第二個陣列arrValue是int[] arrNew=new int[8];//長度為8

下面我要實現將old陣列的 3,4,5複製到新陣列第四到第六個位置，那麼我該怎麼做呢。

int[] arrOld=new int[] {1,2,3,4,5};
		
		int[] arrNew=new int[8];
		System.arraycopy(arrOld, 2, arrNew, 3, 3);
		for(int i:arrNew){
			System.out.print(i+"==》");
		}

輸出的結果如下；

0==》0==》0==》3==》4==》5==》0==》0==》
 

//這個函式的意思
//第一個elementData是原來的陣列
//第二個elementData是新的陣列，這裡只不過是特殊，為了不再新建一個數組就用了他自己
//第二個引數 的意思是 要複製元素的的起始下標
//第四個傳引數的意思是 覆蓋到新陣列的 起始下標
//第五個引數是從原陣列複製的長度是多少
System.arraycopy(elementData, i+1, elementData, i,
numMoved);