方式一、数组；数组默认长度；存放数据的数组；有效元素个数；add、remove、get、size；
add；需要考虑数据长度>=size+1? 不大的话，需要扩容；扩容后，需要将原数组数据移到新数组；size++
remove；索引是否合理？不合理的话，抛出异常，中断程序；合理的话，从索引+1处左移元素；原数组最后一位有效元素置为空；(int类型默认为0）；size--
get;索引是否合理？不合理的话，抛出异常中断程序；合理的话，直接返回索引对应的值；
size；
package box;
public class ArrayBox{
//设计一个静态常量
private static final int DEFAULT_CAPACITY=10;
private int[] elementData;//存放真实数据的[]
private int size;//有效元素个数
public ArrayBox(){
elementData=new int[DEFAULT_CAPACITY];
}
public ArrayBox(int num){
elementData=new int[num];
}//构造方法重载；
//确保数组内部的容量
private void ensureCapacity(int minCapacity){
//判断小，则扩容；
if(minCapacity>elementData.length){
this.grow(minCapacity);
}
}
//扩容大小
private void grow(int minCapacity){
if(minCapacity<(elementData.length>>1)*3){
minCapacity=(elementData.length>>1)*3;
}
elementData=this.copyArray(elementData,minCapacity);
}
//原数组中元素移入新数组
private int[] copyArray(int[] oldArray,int minCapacity){
int[] newArray=new int[minCapacity];
for(int i=0;i<oldArray.length;i++){
newArray[i]=oldArray[i];
}
return newArray;
}
//检测index是否合法
private void rangeCheck(int indexx){
if(indexx<0 || indexx>=size){
//自定义异常
throw new BoxIndexOutOfBoundsException("index:"+indexx+",size:"+size);
}
}
//-----------------------------------------
public boolean add(int element){
this.ensureCapacity(size+1);
elementData[size++]=element;
return true;
}
public int remove(int indexx){
this.rangeCheck(indexx);
int oldValue=elementData[indexx];
for(int i=indexx;i<size-1;i++){//indexx开始左移；
elementData[i]=elementData[i+1];
}
elementData[size-1]=0;//手动将最后的元素删除；
size--;
return oldValue;
}
public int get(int indexx){
this.rangeCheck(indexx);//检测index是否合法
return elementData[indexx];
}
public int size(){
return size;
}
}
package box;
public class BoxIndexOutOfBoundsException extends RuntimeException{
public BoxIndexOutOfBoundsException(){
}
public BoxIndexOutOfBoundsException(String msg){
super(msg);
}
}
package box;
public class Test{
public static void main(String[] args){
LinkBox x=new LinkBox();
boolean add=x.add(10);
x.add(20);
x.add(3);
x.add(2);
x.add(1);
x.add(4);
x.add(5);
x.add(6);
x.add(7);
x.add(8);
x.add(9);
x.add(22);
x.add(30);
int get=x.get(8);
int remove=x.remove(9);
int size=x.size();
System.out.println("添加结果:"+add+";获取结果"+get+"删除结果："+remove+";长度"+size);
ArrayBox j=new ArrayBox();
j.add(10);
boolean addd=j.add(20);
j.add(3);
j.add(2);
j.add(1);
j.add(4);
j.add(5);
j.add(6);
j.add(7);
j.add(8);
j.add(9);
j.add(22);
j.add(30);
int gett=j.get(8);
int removee=j.remove(9);
int sizee=j.size();
System.out.println("添加结果:"+addd+";获取结果"+gett+"删除结果："+removee+";长度"+sizee);
}
}
方式二、链表；首节点（是某一个节点）first、尾节点last、有效元素个数size；
一个节点（Node）包含：前一个Node对象，元素值（element），后一个Node对象；
add;将add的element组合成一个新的节点；并将这个新节点作为尾节点；若是之前尾节点为空，则当前新节点（是第一个节点）即是首节点也是尾节点；若之前尾结点不为空，则之前尾节点中的后一个Node对象=新节点；size++;
remove;判断索引是否合理？不合理，抛出异常，中断程序；合理，找到该节点？如何找节点；根据索引，first是索引0对应的Node对象；索引1对应的Node对象是Node nodee=first.after;索引2对应的Node对象是nodee.after;
若是size过大，索引值也挺大，从头开始找，找的次数过多；所以，判断索引<size/2? 小于，则从first开始找；否则从last开始找；last是索引size-1对应的Node对象；索引size-2对应的Node对象是Node nodee=last.prev;索引size-3对应的Node对象是nodee.prev;
get;判断所以是否合理？不合理，抛出异常，中断程序；合理，找到该节点，并取出该节点的值；
size;
package box;
public class Node{
public Node prev;//前；
public Node after;//后；
public int element;
public Node(Node prev,int element,Node after){
this.prev=prev;
this.element=element;
this.after=after;
}//构造方法；
}
package box;
public class LinkBox{
public Node first;//记录首节点；
public Node last;//尾节点；
public int size;//记录有效元素个数
//添加element;
public void addLink(int element){
Node l=last;//获取尾节点；
Node newNode=new Node(l,element,null);
last=newNode;
if(l==null){//之前无人使用过
first=newNode;
}else{//之前有人使用过，之前last的after
l.after=newNode;
}
size++;
}
//查看indexx是否合理；
public void rangeCheck(int indexx){
if(indexx<0 || indexx>size-1){
throw new BoxIndexOutOfBoundsException("index:"+indexx+",size:"+size);
}
}
//查看indexx对应的node
public Node nodeValue(int indexx){
Node nodee;
if(indexx < (size>>1)){
nodee=first;
for(int i=0;i<indexx;i++){
nodee=nodee.after;
}
}else{
nodee=last;
for(int i=size-1;i>indexx;i--){
nodee=nodee.prev;
}
}
return nodee;
}
//删除indexx对应的node
public int unLink(int indexx){
Node nodee=this.nodeValue(indexx);
Node bf=nodee.prev;//当前nodee的前一个；
Node af=nodee.after;
if(bf==null){//第一个；
first=af;
}else{
bf.after=af;
nodee.prev=null;
}
if(af==null){//当前Node为最后一个；
last=bf;
}else{
af.prev=bf;
nodee.after=null;
}
size--;
return nodee.element;
}
//-----------------------------------------------------------------------------
public boolean add(int element){
this.addLink(element);
return true;
}
public int remove(int indexx){
this.rangeCheck(indexx);
int a=this.unLink(indexx);
return a;
}
public int get(int indexx){
this.rangeCheck(indexx);//检测index是否合法
Node a=nodeValue(indexx);
int b=a.element;
return b;
}
public int size(){
return size;
}
}
联络网：单向链表（ A-->B-->C-->D）；双向链表；环链表；
