线性表--顺序储存结构 java实现

1、线性表：由n(n>=0)个数据元素组成的有限序列。

   对于一个非空、有限的线性表，总具有如下特征：

（1）总存在唯一的第一个数据元素

（2）总存在唯一的最后一个数据元素

（3）除第一个数据元素外，集合中的每一个数据元素都只有一个前驱的数据元素

（4）除最后一个数据元素外，集合中的每个数据元素都只有一个后继的数据元素

顺序存储结构：

是指用一组地址连续的存储单元一次存放线性表的元素。

为了使用顺序存储的线性表，程序通常采用数组来保存线性表中的元素。顺序存储的线性表是一种随机存储的储存结构。

import java.util.Arrays;

public class ArrayList<T>
{
    private int DEFAULT_SIZE = 10;//数组默认长度
    private int capacity;//保存数组的长度
    private Object[] elementData;//数组对象的引用
    private int size = 0;//保存顺序表中当前元素的个数
    
    public ArrayList()//构造器 以默认数组长度创建顺序线性表
    {
    	capacity = DEFAULT_SIZE;//线性表默认长度为10
    	elementData = new Object[capacity];
    }
    
    public ArrayList(T element)//以一个初始化元素创建一个顺序线性表
    {
    	this();
    	elementData[0]=element;
    	size++;
    }
    
    public ArrayList(int initSize)//指定长度的数组来创建顺序线性表
    {
    	capacity = 1;
    	while(capacity < initSize)
    	{
    		capacity <<= 1;
    	}
    	elementData = new Object[capacity];
    }
    
    //获取线性表的长度
    public int length()
    {
    	return size;
    }
    //获取指定位置的元素
    public T getElement(int index)
    {
    	if(index < 0 || index > size-1)
    	{
    		throw new IndexOutOfBoundsException("索引越界");
    	}
    	return (T)elementData[index];
    	
    }
    
    //查找
    //查找 指定元素的位置
    public int locateByElement(T element)
    {
    	for(int i = 0;i < size ;i++)
    	{
    		if(elementData[i] == element)
    		{
    			return i;
    		}
    	}
    	return -1;
    }
    
    //插入
    //向指定位置插入一个元素
    public void insert(T element,int index)
    {
    	if(index < 0 || index > size)
    	{
    		throw new IndexOutOfBoundsException("索引越界");
    	}
    	ensureCapacity(size + 1);//插入之前判断现在的数组容量是否已满
    	//数组的复制 将指定索引处的之后的元素向后移动一格
    	System.arraycopy(elementData,index,elementData,index+1,size-index);//从插入的位置开始复制直到最后一个元素
    	
    	//移动之后空出来的index的位置插入element
    	elementData[index] = element;
    	size++;
    	
    	
    	
    }
    
     //在表尾插入元素
    public void add(T element)
     { 
    	insert(element,size);
     }
    
    //检查是否需要对数组进行扩容，如果需要则对其扩容 原来数组中的元素及其职位保持不变
    public void ensureCapacity(int minCapacity)
    {
    	if(capacity < minCapacity)//如果当前的数组容量小于传进来的参数 则需要对数组进行扩容
    	{
    		while(capacity < minCapacity)
    		{
    			capacity <<= 1;//让capacity每次右移一位直到capacity大于传进来的参数
    		}
    		elementData = Arrays.copyOf(elementData,capacity);//对数组原来的内容进行拷贝并赋予其新的容量
    		//Arrays的copyOf()方法传回的数组是新的数组对象，第二个参数指定新的数组容量
         }
    }
    
    //删除指定位置的元素
    public T delete (int index)
    {
    	if(index < 0 || index > size-1)
    	{
    		throw new IndexOutOfBoundsException("索引越界");
    	}
    	T deleteElement = (T)elementData[index];//找到要删除的元素
		 
    	int move = size - index -1;//从index+1直到最后一个的总长度
    	System.arraycopy(elementData,index+1,elementData,index,move);
    	
    	elementData[--size] = null;//清空最后一个元素的引用
    	return deleteElement;
    }
    //判断线性表是否为空
    public boolean isEmpty()
    {
    	return size == 0;
    }
    
    //清空线性表
    public void clearAll()
    {
    	Arrays.fill(elementData,null);//第一个参数是一个数组变量，第二个参数是将数组中的所有值变为同一个value
    	size = 0;
    }
    
    //重写toString方法
    @Override
    public String toString()
    {
    	if(isEmpty())
    	{
    	     return "[]";
    	}
    	else
    	{
    		StringBuilder sb = new StringBuilder("[");
    		for (int i = 0; i < size; i++)
			{
				sb.append(elementData[i].toString() + ", ");	
			}
    		int len = sb.length();
    		return sb.delete(len-2,len).append("]").toString();
    	}
    
    }
    
}

测试

public class ArrayListTest<T>
{
	public static void main(String[] args)
  {
	 ArrayList<String> list = new ArrayList<String>();
	    list.add("hello");
	    list.add("world");
	    list.add("java");
	    System.out.println(list);
	    list.insert("111",1);
	    System.out.println(list);
	    list.delete(2);
	    System.out.println(list);
	    list.clearAll();
	    System.out.println(list);
  }
}

结果：

[hello, world, java]
[hello, 111, world, java]
[hello, 111, java]
[]