呆板动态数组和自定义动态数组

/**

 * 定义一个呆板的动态数组

 * 

 * @author kowloon

 * 

 */

public class Array {

 

// 定义一个长度是0的数组，来表示动态数组存放数据的位置

// 初始状态该下，没有任何数据，长度是0

private int[] src = new int[0];

 

/**

* 将指定的数据添加到数组中

* 

* @param t

*            要添加的数据

*/

public void add(int t) {

// 定义一个新的数组，长度是src的长度+1

int[] dest = new int[src.length + 1];

// 将要添加的数据放到新数组的最后一个位置

dest[dest.length - 1] = t;

// 如果原数组中有数据，这按照下标对应位置放到新数组

for (int i = 0; i < src.length; i++) {

dest[i] = src[i];

}

// 将src指向新数组

src = dest;

}

 

/**

* 获取指定编号的数据

* 

* @param index

*            要获取的数据的编号

* @return 取得的数据

*/

public int get(int index) {

// 要获取的数据就在src数组中

return src[index];

}

 

/**

* 获得动态数组中数据的个数

* 

* @return 返回数据的个数

*/

public int size() {

return src.length;

}

 

/**

* 将指定的数据插入到指定的位置

* 

* @param t

*            要插入的数据

* @param index

*            要插入的下标位置

*/

public void insert(int t, int index) {

// 定义一个新数组，长度是src长度+1

 int dest[] = new int[src.length+1];

    for(int i=0;i<dest.length;i++){

// 如果i<index，则下标对应，如果i>index，

// 则将旧数组中的下标-1赋给新数组

         if(i<index){

    dest[i] = src[i];

    }else if(i>index){

    dest[i] = src[i-1];

    }

      }

    dest[index]=t;

        src = dest;

    }

 

 

 

/**

* 修改执行位置的数据

* 

* @param t

*            修改后的数据

* @param index

*            要修改的数据的位置

*/

public void replace(int t, int index) {

src[index] = t;

}

 

/**

* 删除指定位置的数据

* 

* @param index

*            要删除的数据下标位置

*/

public void delete(int index) {

// 定义一个新数组，长度是src长度-1

int[] dest = new int[src.length - 1];

for (int i = 0; i < src.length; i++) {

// 如果i<index，则下标对应，如果i>index，

// 则新数组中的下标-1

if (i < index) {

dest[i] = src[i];

} else if (i > index) {

dest[i - 1] = src[i];

}

}

src = dest;

 

}

}

 

 

**********************************************************************

/**

 * 自定义动态数组

 * 具有容量和增长率的动态数组[优化之后的]

 * @author kowloon

 * 

 */

public class Array2 {

private int rongliang = 10;// 初始容量

private int zengzhang = 10;// 每次增长的数量

private int count = 0;// 动态数组中的数据个数

 

// 定义一个长度是0的数组，来表示动态数组存放数据的位置

// 初始状态该下，没有任何数据，长度是0

Integer[] src = new Integer[rongliang];

 

public Array2() {

 

}

 

public Array2(int rongliang, int zengzhang) {

this.rongliang = rongliang;

this.zengzhang = zengzhang;

src = new Integer[rongliang];

}

 

/**

* 将指定的数据添加到数组中

* 

* @param t要添加的数据

*/

public void add(int t) {

// 如果动态数组的长度<容量，

// 则可以直接添加到src从左往右第一个没有数据的位置

if (count < src.length) {

src[count] = t;

} else {

// 如果长度>=容量,就定义新的数组，按照增长数量增加

Integer[] dest = new Integer[src.length + zengzhang];

// 按照下标对应位置放到新数组

for (int i = 0; i < src.length; i++) {

dest[i] = src[i];

}

src = dest;

src[count] = t;

}

count++;

}

 

/**

* 获取指定编号的数据

* 

* @param index

*            要获取的数据的编号

* @return 取得的数据

*/

public int get(int index) {

// 要获取的数据就在src数组中

return src[index];

}

 

/**

* 删除指定位置的数据

* 

* @param index

*            要删除的数据下标位置

*/

public void delete(int index) {

// 如果删除1个数据后的长度减去初始容量除以增长值的余数是0

// 表示删除后的最后一个数据是在最后数组的最后一个位置

if ((src.length - 1 - rongliang) % zengzhang == 0) {

// 节省空间删除增长值，再次增加时会直接增加增长值，经行n+1次数组替换

// 只会多出一次数组替换时间可以忽略不计

Integer[] dest = new Integer[src.length - zengzhang];

for (int i = 0; i < dest.length; i++) {

if (i < index) {

dest[i] = src[i];

} else if (i > index) {

dest[i] = src[i + 1];

}

}

 

src = dest;

// 如果删除1个数据后的长度减去初始容量除以增长值的余数不是0

// 则不需要减少增加值，直接删除数据位置之前的数据不动，后面的

// 数据赋给前一位的数据，最后有数据的位置则会被替换为null

} else {

for (int i = 0; i < src.length; i++)

if (i < index) {

 

} else if (i > index) {

src[i - 1] = src[i];

}

 

}

// 执行一次长度-1

count--;

}

 

/**

* 将指定的数据插入到指定的位置

* 

* @param t

*            要插入的数据

* @param index

*            要插入的下标位置

*/

public void insert(int t, int index) {

// 如果增加1个数据后的长度减去初始容量除以增长值的余数是0

// 则需要增加增加值，增加数据位置之前的数据不动，最后的

// 数据赋给后一位，因为从前面开是的话，列如5位给6位，6位给7位，

// 从插入的数据开始，后面每一位数据会一样，所以要从最后一位开始往后

// 赋值，最后有数据的位置会被替换null

if ((src.length + 1 - rongliang) % zengzhang == 0) {

Integer dest[] = new Integer[src.length + zengzhang];

for (int i = 0; i < dest.length; i++) {

// 如果i<index，则下标对应，如果i>index，

// 则将旧数组中的下标-1赋给新数组

if (i < index) {

dest[i] = src[i];

} else if (i > index) {

dest[i] = src[i - 1];

}

dest[index] = t;

src = dest;

}

} else {

// 如果i<index，则下标对应，如果i>index,

// i是从index+1开始执行最后一位数据往后一位赋值

for (int i = 0; i < index+2; i++) {

if (i < index) {

src[i] = src[i];

} else if (i > index) {

for (int x = 0; x <src.length-index-1;x++) {

src[src.length-x-1] = src[src.length-x-2];

}

}

}

src[index] = t;

}

count++;

}

 

/**

* 获得动态数组中数据的个数 src.length是初始数组的长度，不代表动态数组的长度 动态数组的长度表示src中已经存放的数据个数

* 

* @return 返回数据的个数

*/

public int size() {

return count;

}

 

/**

* 修改执行位置的数据

* 

* @param t

*            修改后的数据

* @param index

*            要修改的数据的位置

*/

public void replace(int t, int index) {

src[index] = t;

}

 

}