java怎么把数组存到单链表_java存储元素，两种设计方式，一种是数组；一种是链表（联络网）...

方式一、数组；数组默认长度；存放数据的数组；有效元素个数；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>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

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

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过大，索引值也挺大，从头开始找，找的次数过多；所以，判断索引

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

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)；双向链表；环链表；