谢谢
，底层最好数组实现
/*
public class MyList{
private Object[] data=new Object[3];
private int index=0;
private void expand(){
Object[] data2=new Object[data.length*2];
System.arraycopy(data,0,data2,0,data.length);
data=data2;
}
public void add(Object o){
if (data.length==index) expand();
data[index]=o;
index++;
}
public void add(int pos,Object o){
if (data.length==index) expand();
for(int i=index;i>pos;i--){
data[i]=data[i-1];
}
data[pos]=o;
index++;
}
public Object remove(int pos){
Object o=data[pos];
index--;
for(int i=pos;i<index;i++){
data[i]=data[i+1];
}
return o;
}
public int size(){
return index;
}
public Object get(int pos){
return data[pos];
}
public void clear(){
index=0;
}
public boolean isEmpty(){
return index==0;
}
public Object[] toArray(){
return data;
}
}
搜索一下, 很多的
[url]http://sxhxrj.blog.163.com/blog/static/124049866200991111158789/[/url]
[code="java"]
public class SequenList {
public int length = 10;// 初始化顺序表大小为10
private int cur_index;// 当前插入位置
private Object[] seqList;// 顺序表数据存放处
public SequenList() {
initList();
}
/**
* 初始化顺序表
*/
private void initList() {
this.seqList = new Object[length];
}
/**
* 此方法用来在顺序表中最后位置添加新数据，当数据添加位置超过了数组允许大小时，
* 重新分配内存空间。并且，每加一条数据，List的当前插入位置自增“1”。
*/
public void add(Object obj) {
if (length > 0) {
if (cur_index < (length - 1)) {
seqList[cur_index] = obj;
cur_index++;
} else {
resizeList(seqList);
seqList[cur_index] = obj;
cur_index++;
}
} else {
System.err.print("The sequences are not initialed properly ! ");
}
}
/**
* 此方法用来在数组的任意位置添加一个新数据。
* 如果任意插入的数据位置刚好是最后一个元素 则直接调用 add(Objectobj)方法，
* 如果添加的数据超出了原始数据的边界值，则List会自动对空间进行扩充。
* 因此，允许添加数据的当前位置超出数据边界。
* 但是每次插入的数据索引大小不能超过length*3/2+1，否则，系统会抛出数组越界异常。
*/
public void add(int index, Object obj) {
if (index == cur_index + 1) {
add(obj);
} else {
int old_len = length;
if (index > length - 1) {
resizeList(seqList);
}
System.arraycopy(seqList, index, seqList, index + 1, old_len
- index);
seqList[index] = obj;
cur_index = index;
}
}
/**
* 此方法用于进行元素查找，如果要查找的元素在数据中存在，则返回数据所在位置，如果 元素在数据中没有找到，则直接返回 -1 。
*/
public int findElement(Object obj) {
int find_index = -1;
for (int i = 0; i < length; i++) {
if (obj.equals(seqList[i])) {
find_index = i;
}
}
return find_index;
}
/**
* 此方法用来得到某个确定位置的元素。
*/
public Object get(int index) {
return seqList[index];
}
/**
* 重新划分并扩充数据所占内存空间，具体扩充方式为： length*3/2+1 。
*/
public void resizeList(Object[] seqList_low) {
int resize = length * 3 / 2 + 1;
Object[] seqList_upp = new Object[resize];
System.arraycopy(seqList_low, 0, seqList_upp, 0, length);
seqList = seqList_upp;
length = resize;
}
}
[/code]
你用下java.util.LinkedList这个类。链表不能用数组实现。这两种数据结构是不同的，各有个的优缺点。链表的特性是插入删除快，但查找的时候效率低，数组是查找快，但插入删除慢。这中特性不要求链表在内存中是连续，但数组在内存中是连续的。现在我还不知道有那种数据结构能兼顾链表和数组的优点。
一楼二楼提供都是动态数组的实现.
三楼有提到链表的实现特性,它不要求元素与元素之间在内存之间是连续的.元素之间的链接靠的是当前元素所保存的前一元素和后一元素的引用:
[code="java"]private static class Entry {
E element;
Entry next;
Entry previous;
Entry(E element, Entry<E> next, Entry<E> previous) {
this.element = element;
this.next = next;
this.previous = previous;
}
}
[/code]
这种特性可以使链表很好的利用内存空间，因为并不需要对象是在连续的内存空间，只要建立它们之间的引用关系即可,加快元素的增加和删除操作,因为仅需要改动一下所引用的前一元素和后一元素的引用.
动态数组是预分配内存空间，就可能存在内存空间的浪费，数组要保证是连续的内存空间，就不能很好的利用内存空间隔，扩展元素数量导致整个数组的拷贝.
这两种实现形式是对时间和空间的不同追求,在查询效率上:链表牺牲时间,但是节省空间,动态数组牺牲空间换来时间.
楼主看下LinkedList和ArrayList及相关类的源代码,应该会有收获.