实现listLink链表操作

/**
 *
 */
package com.map.values;

import java.util.Arrays;

/**
 * @author Administrator
 *
 */
public class SequenceList<T> {
    private int DEFAULT_SIZE = 16;
    private int capacity;
    private Object[] elementData;
    private int size;
    public SequenceList(){
        capacity = DEFAULT_SIZE;
        elementData = new Object[capacity];
                
    }
    public SequenceList(T element){
        this();
        this.elementData[0] = element;
        size ++;
    }
    /**
     * 以指定的长度数组来创建顺序线性表
     * */
    public SequenceList(T element ,int initSize){
        capacity = 1;
        while(capacity < initSize){
            capacity<<=1;
            elementData = new Object[capacity];
            this.elementData[0] = element;
            size ++;
        }
    }
    //获取线性表的大小
    public int length(){
        return size;
    }
    //获取顺序线性表索引下的元索
    public T get(int i){
        if(i<0|| i>size-1){
            throw new IndexOutOfBoundsException("线性表索引越界");
        }
        return (T)elementData[i];
    }
    //查找顺序线性表指定的元索的索引
    public int locate(T element){
        for(int i =0; i<size;i++){
            if(elementData[i].equals(element)){
                return i;
            }
        }
        return -1;
    }
    //向顺序线性表的指定位置插入元索
    public void insert(T element , int index){
        if(index<0|| index>size){
            throw new IndexOutOfBoundsException("线性表索引越界");
        }
        this.ensureCapacity(size+1);
        System.arraycopy(elementData, index, elementData, index+1, size-index);
        elementData[index] = element;
        size++;
    }
    //在线性顺序表的开始处添加一个元索
    public void add(T element){
        insert(element, size);
    }
    //很麻烦,而且性能很差
    private void ensureCapacity(int minCapacity){
        //如果数组的原有长度小于目前所需的长度
        if(minCapacity >capacity){
            //不断地将capacity*2,直到capacity大于minCapacity
            while(capacity < minCapacity){
                capacity <<= 1;
            }
            elementData = Arrays.copyOf(elementData, capacity);
        }
    }
    //删除顺序线性表中指定索引处的元索
    public T delete (int index){
        if(index<0||index>size-1){
            throw new IndexOutOfBoundsException("线性表索引越界");
        }
        T oldvalu = (T) elementData[index];
        int numMove = size -index-1;
        if(numMove >0){
            System.arraycopy(elementData, index+1, elementData, index, numMove);
        }
        //清除最后一个元索
        elementData[--size] = null;
        return oldvalu;
    }
    //删除顺序线性表的最后一个元索
    public T remove(){
        return delete(size-1);
    }
    //判断顺序线性表是否为空表
    public boolean empty(){
        boolean  flag = true;
        if(size!=0){
            flag = false;
        }
        return flag;
    }
    //清空线性表
    public void clear(){
        //将底层所有的元索赋值为null
        Arrays.fill(elementData, null);
        size = 0;
    }
    public String toString(){
        if(size == 0){
            return "[]";
        }else{
            StringBuffer stbuff = new StringBuffer();
            for(int i=0;i<size;i++){
                stbuff.append(elementData[i].toString()+",");
            }
            int len = stbuff.length();
            return stbuff.delete(len-2,len).append("]").toString();
        }
    }
}

测试类

package com.map.values;

public class SequenceListTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SequenceList<String> list = new SequenceList<String>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        //在索引为1处插入一个新元索
        list.insert("ddd", 1);
        System.out.println(list);
        //删除索引为2的元索
        list.delete(2);
        System.out.println(list);
        //获取ccc字符串在顺序线性表中的位置
        System.out.println("ccc在顺序线性表的位置："+list.locate("ccc"));
    }

}

执行结果

aaa,ddd,bbb,cc]
aaa,ddd,cc]
ccc在顺序线性表的位置：2