学习完java集合容器.模仿一个简单的ArrayList.
模仿的简单的ArrayList支持增删查, 并且具有自动扩大容量的功能,增加遍历.  
接口文件如下:

1. /**
   
2. * <p>Title: ILinearList.java</p>
   
3. * <p>Description: 线性表抽象接口</p>
   
4. * <p>Copyright: Copyright (c) 2015</p>
   
5. * @author possible
   
6. * @version 1.0
   
7. */
   
8. package com.dt.linearlist;
   
9. 
   
10. public interface ILinearList<T> {
    
11. //        /**
    
12. //         * 初始化线性表
    
13. //         *
    
14. //         * @return 返回线性表引用
    
15. //         */
    
16. //        public T initList();
    
17. 
    
18.         /**
    
19.          * 删除线性表
    
20.          *
    
21.          * @return 返回true 销毁成功 false失败
    
22.          */
    
23.         public void destoryList();
    
24. 
    
25.         /**
    
26.          * 判断线性表是否为空
    
27.          *
    
28.          * @return true 链表为空. false 链表不为空
    
29.          */
    
30.         public boolean isEmpty();
    
31. 
    
32.         /**
    
33.          * 线性表长度
    
34.          *
    
35.          * @return 链表长度
    
36.          */
    
37.         public int length();
    
38. 
    
39.         /**
    
40.          * 获取指定索引线性表结点
    
41.          *
    
42.          * @param index
    
43.          *            获取index位置的元素
    
44.          * @return 返回元素 T
    
45.          */
    
46.         public T get(int index);
    
47. 
    
48.         /**
    
49.          * 在指定位置插入元素
    
50.          *
    
51.          * @param i
    
52.          *            插入位置的索引
    
53.          * @param t
    
54.          *            插入的元素
    
55.          * @return true 插入成功, false 插入失败
    
56.          */
    
57.         public boolean add(int index, T t);
    
58. 
    
59.         /**
    
60.          * 删除指定索引的元素
    
61.          *
    
62.          * @param i
    
63.          *            删除指定位置的元素
    
64.          * @return true 删除成功; false 删除失败
    
65.          */
    
66.         public T delete(int index);
    
67. 
    
68.         /**
    
69.          * 线性表遍历
    
70.          *
    
71.          * @return 返回遍历结果
    
72.          */
    
73.         public String traverse();
    
74. 
    
75.         /**
    
76.          * 插入元素结点.
    
77.          *
    
78.          * @param t
    
79.          *            插入结点
    
80.          * @return true 插入成功 ; false 插入失败
    
81.          */
    
82.         public boolean add(T t);
    
83. }

复制代码

对应模仿的简单ArrayList如下:

1. /**
   
2. * <p>Title: ArrayLinearList.java</p>
   
3. * <p>Description:模仿ArrayList</p>
   
4. * <p>Copyright: Copyright (c) 2015</p>
   
5. * @author possible
   
6. * @version 1.0
   
7. */
   
8. package com.dt.linearlist;
   
9. 
   
10. import java.util.Arrays;
    
11. 
    
12. /**
    
13. * @author possible
    
14. *
    
15. */
    
16. public class ArrayLinearList<T> implements ILinearList<T> {
    
17.         /**
    
18.          * 扩大容量的加载因子
    
19.          */
    
20.         private static final float LOADER_FACTOR = 0.8f;
    
21.         /**
    
22.          * 初始化容量
    
23.          */
    
24.         private static final int INITITAL_CAPACITY = 3;
    
25. 
    
26.         /**
    
27.          * 顺序表中真实存放的元素的个数
    
28.          */
    
29.         private int length;
    
30.         /**
    
31.          * 容量
    
32.          */
    
33.         private int capacity;
    
34.         private Object[] elements;
    
35. 
    
36.         public ArrayLinearList() {
    
37.                 this(INITITAL_CAPACITY);
    
38.         }
    
39. 
    
40.         public ArrayLinearList(int inititalCapacity) {
    
41.                 elements = new Object[inititalCapacity];
    
42.                 this.capacity = inititalCapacity;
    
43.         }
    
44. 
    
45.         @Override
    
46.         public void destoryList() {
    
47.                 for (int i = 0, len = elements.length; i < len; i++) {
    
48.                         elements[i] = null;
    
49.                 }
    
50.                 length = 0;
    
51.         }
    
52. 
    
53.         @Override
    
54.         public boolean isEmpty() {
    
55.                 return length == 0;
    
56.         }
    
57. 
    
58.         @Override
    
59.         public int length() {
    
60.                 System.out.println("length = "+length+"   capacity = "+capacity);
    
61.                 return length;
    
62.         }
    
63. 
    
64.         @SuppressWarnings("unchecked")
    
65.         @Override
    
66.         public T get(int index) {
    
67.                 if (!checkBounds(index)) {
    
68.                         throw new ArrayIndexOutOfBoundsException(checkBoundsMsg(index));
    
69.                 }
    
70.                 return (T) elements[index];
    
71.         }
    
72. 
    
73.         @Override
    
74.         public boolean add(int index, T t) {
    
75.                 if (!checkBounds(index)) {
    
76.                         throw new ArrayIndexOutOfBoundsException(checkBoundsMsg(index));
    
77.                 }
    
78.                
    
79.                 if (isExtendCapacity()) {
    
80.                         extendCapacity();
    
81.                 }
    
82.                 System.arraycopy(elements, index, elements, index+1, length-index+1);
    
83.                 elements[index] = t;
    
84.                 length ++;
    
85.                 return true;
    
86.         }
    
87.         @Override
    
88.         public T delete(int index) {
    
89.                 if (!checkBounds(index)) {
    
90.                         throw new ArrayIndexOutOfBoundsException(checkBoundsMsg(index));
    
91.                 }
    
92.                 @SuppressWarnings("unchecked")
    
93.                 T t = (T) elements[index];
    
94.                 System.arraycopy(elements, index+1, elements, index, length-index-1);
    
95.                 length--;
    
96.                 return t;
    
97.         }
    
98. 
    
99.         @Override
    
100.         public String traverse() {
     
101.                 StringBuffer sb = new StringBuffer();
     
102.                 sb.append("开始遍历顺序表");
     
103.                 sb.append("\n");
     
104.                 for (int i = 0, len = length; i < len; i++) {
     
105.                         if(elements[i] == null){
     
106.                                 break;
     
107.                         }
     
108.                         sb.append(elements[i].toString());
     
109.                         sb.append("\n");
     
110.                 }
     
111.                 sb.append("结束遍历顺序表");
     
112.                 System.out.println(sb.toString());
     
113.                 return sb.toString();
     
114.         }
     
115. 
     
116.         @Override
     
117.         public boolean add(T t) {
     
118.                 if (isExtendCapacity()) {
     
119.                         extendCapacity();
     
120.                 }
     
121. 
     
122.                 elements[length++] = t;
     
123.                 return true;
     
124.         }
     
125. 
     
126.         private String checkBoundsMsg(int index) {
     
127.                 if (index >= length) {
     
128.                         return "下标越界   " + " length: " + length + " index: " + index;
     
129.                 }
     
130.                 return null;
     
131.         }
     
132. 
     
133.         /**
     
134.          * 检查指定的索引是否越界
     
135.          *
     
136.          * @param index
     
137.          * @return
     
138.          */
     
139.         private boolean checkBounds(int index) {
     
140.                 return index >= 0 && index < length;
     
141.         }
     
142. 
     
143.         /**
     
144.          * 判断是否需要扩大容量
     
145.          */
     
146.         private boolean isExtendCapacity() {
     
147.                 if (length > capacity * LOADER_FACTOR) {
     
148.                         return true;
     
149.                 }
     
150.                 return false;
     
151.         }
     
152. 
     
153.         /**
     
154.          * 扩展容量
     
155.          */
     
156.         private void extendCapacity() {
     
157.                 System.out.println("扩大容量");
     
158.                 int newLength = capacity * 2;
     
159.                 elements = Arrays.copyOf(elements, newLength);
     
160.                 capacity = newLength;
     
161.         }
     
162. 
     
163. }
     

复制代码

大神，学习了

王国库 发表于 2015-5-1 12:16
大神，学习了

哈哈,谢谢. 很简单的模仿了一下.

学习了~~~