java学习笔记4>顺序线性表的实现及其内存分配

相信大家用过很多java提供的集合类，如list，map，set等，而对于线性表这种数据结构，我们用得最多的就是实现了java.util.List这个接口的ArrayList类和LinkedList类

ArrayList类就是线性表的顺序表示的实现，如果大家度过该类的源代码就能很清楚的看到顺序线性表是如何在java中实现的了

相信大家都很清楚线性表这种数据结构

线性表的基本操作：

>初始化一个空的线性表

>获取线性表的长度

>获取线性表中指定索引处的元素

>返回线性表中指定元素的索引，否则返回-1

>向指定位置插入元素

>直接插入元素在表中的末尾

>直接删除表中的末尾元素

>删除指定位置的元素

>判断表是否为空

以下程序引用自《java程序员的基本修养》，修改了部分函数名和纠正了一些注释，该类实现了一个简单的顺序线性表

import java.util.Arrays;

public class SequenceList<T> {

private int DEFAULT_SIZE = 16;
//保存数组的长度
private int capacity;
//定义一个数组用于保存顺序线性表的元素
private Object[] elementData;
//保存当前数组的元素个数
private int size=0;
//以默认数组长度创建空顺序线性表
public SequenceList(){
capacity = DEFAULT_SIZE;
elementData = new Object[capacity];
}
//以一个初始话元素来创建顺序线性表
public SequenceList(T element){
this();
elementData[0]=element;
size++;
}
/**
* 以指定长度的数组来创建顺序线性表
* @param element 指定顺序线性表中的第一个元素
* @param initSize 指定顺序线性表底层数组的长度
*/
public SequenceList(T element,int initSize){
capacity = 1;
//把capacity设为大于initSize的最小的2的n次方
while(capacity<initSize){
capacity <<=1;
}
elementData = new Object[capacity];
elementData[0] = element;
size++;
}
//获取顺序线性表的大小
public int length(){
return size;
}
//获取顺序线性表中索引为i处的元素
@SuppressWarnings("unchecked")
public T get(int i){
if( i<0 || i>size-1 ){
throw new IndexOutOfBoundsException("线性表索引越界");
}
return (T) elementData[i];
}
//查找顺序线性表中指定元素的索引,有则返回,无则返回-1
public int getIndexByElement(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("线性表索引越界");
}
ensureCapacity(size+1);
//将index以后的所有元素向后移动一格
System.arraycopy(elementData, index, elementData, index+1, size-index );
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;
}
elementData = Arrays.copyOf(elementData, capacity);
}
}
//删除顺序线性表中指定索引处的元素
@SuppressWarnings("unchecked")
public T delete(int index){
if(index<0||index>size-1){
throw new IndexOutOfBoundsException("线性表索引越界");
}
T oldValue = (T)elementData[index];
int numMoved = size-index-1;
if(numMoved>0){
System.arraycopy(elementData, index+1, elementData, index, numMoved);
}
//清空最后一个元素
elementData[--size]=null;
return oldValue;
}
//删除顺序线性表中最后一个元素
public T remove(){
return delete(size-1);
}
//判断顺序线性表是否为空表
public boolean empty(){
return size==0;
}
//清空顺序线性表
public void clear(){
Arrays.fill(elementData, null);
size=0;
}

public String toString(){
if(size==0){
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 - 1, len).append("]").toString();
}

}

}

测试线性表

public class TestSequenceList {

public static void main(String[] args){
SequenceList<String> list = new SequenceList<String>("first",6);
list.add("second");
list.add("third");
list.insert("forth",3);
list.insert("fifth",2);
list.delete(1);
System.out.println(list);
System.out.println("fifth在顺序线性表中的位置："+list.getIndexByElement("fifth"));
}
}

输出结果：



该线性表在内存中的分配情况如下：



由于初始化时是

SequenceList<String> list = new SequenceList<String>("first",6);

因此经过计算，初始化数组的长度是8，size为1

故内存分配如上图所示

以上就是本次介绍的内容，下次继续跟大家分享LinkedList的实现，如果有不正确的地方希望大家指点指点