数组，链表，队列

<div class="iteye-blog-content-contain" style="font-size: 14px"></div>数组、链表、队列
数组
数组的引入：由于重绘的时候要在paint方法中传入画的时候的坐标，这样我们就要用一个东西把我们画的坐标给存下来，这样我们就想到了数组，每个位置存放一个对象，这个对象就是我们画的东西，包括坐标等数据。
　　数组的定义有两种方法，类型名[] 数组名=new 类型名[数组长度] ；
　　 类型名[] 数组名=new {数据或对象的集合}
　　数组分两种，1、原始数组，就是c语言中一样的，用来存放数据的；
　　String [] sa= new String{“wrww”,”3wwerss”,};
　　
　　对象数组，就是把原始数组中的每个数据换做对象，每个位置都是一个对象。
　　for( int i=0;i<10;i++){
　　 Student sa=new Student();
　　 Student[i]=sa;
　　}
　　队列
队列的引入：我们用数组来存放重绘时候的数据，但是数组有固定长度，而我们画的东西是不确定多少的，这样我们需要一个能改变长度的数组，这就是数组队列了，其实就是一个能自己增加长度的数组。
　　这样我们可以定义几个方法在方法，在队列中添加一个数据、删除一个数据、获得指定位置的值、、、、。
　　//定义一个在队列中添加一个对象的方法
public void add(Student ol){
//定义一个是原数组长度加一的数组
Student[] youn=new Student[old.length+1];
//把这个对象放在新数组的最后一个位置
youn[old.length]=ol;
//遍历原来的数组，并且把原数组中的数据依次放在新数组中
for(int t=0;t<old.length;t++){
youn[t]=old[t];
}
//将新数组指向旧数组
old=youn;
　　 }
　　Private Student[] old=new Student[0];
//定义获得队列的长度的函数
public int size(){
return old.length;
}
//定义一个取得特定位置的对象的方法
public Student getl(int ii){
return old[ii];
　　 }
　　链表
链表的引入：数组有一个很大的缺点，就是要删除或者插入一个数据时，要移动很多位置的数据，很不方便，这样我们就可以用链表中的指针。
链表就是由一个个节点组成，每个节点有两部分，数据存放的部分跟指针部分，指针指向下一个节点。就像一条链子，把所有数据都串在一起。
root=root.next;我们知道一个节点，就可以通过他的next找到他的下一个节点，这样就把所有的数据串起来了。

链表队列：跟数组雷同，也就是定义一个获得更加灵活的链表，也是实现若干方法。
//定义一个在链表队列中添加一个数据的方法
　　　Public void add(Student st){
　　　LinkNode ll=new LinkNode(st);
　　　//判断头节点是否为空
　　　if(root==Null){
　　　root=ll;
　　　Last=ll;
　　　}
　　　else{
　　　LinkNode tem=new LinkNode();
　　　tem.setData=st;
　　　last.setNext=tem;
　　　Last=tem;
　　　}
　　　}
　　　优化
数组队列的优化
/**
* 保存Point对象的队列
* @author
*
*/
public class PointList<E> {
//当前位置的下表
private int Index = 0;
//数组每次增加多大的长度
private int incre = 50;
//初始化时原始数组的大小
private int ss = 100;
private Object[] srcArr=new Object[ss] ;
//定义不同的构造方法，可以由使用者定义数值
public PointList(int ss, int incre){
This.ss=ss;;
this.incre = incre;
}
public PointList(int ss){
this(ss,50);
}
public PointList(int incre){
this(100,incre);
}
public PointList(){
this(100,50);
}

/**
* 往队列里面加入一个Point对象
* @param p Point对象
*/
public void add(E p){
if(Index < srcArr.length){
srcArr[Index++] = p;
} else {
Object[] destArr = new Object[srcArr.length+incre];
for(int i = 0; i < srcArr.length; i++) {
destArr[i] = srcArr[i];
}
srcArr = destArr;
srcArr[Index++] = p;
}
}
/**
* 取到队列第几个对象
* @param index - 对象是索引
* @return 返回Point对象
*/
public E getPoint(int index){
if(index >= srcArr.length)
return null;
return (E)srcArr[index];
}
/**
* 队列的长度
* @return
*/
public int size() {
return Index;
}
}
//定义p类
public class Point {
public double x;
public double y;
public Point(double x,double y){
this.x = x;
this.y = y;
}
public double getX() {
return x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return y;
}
public void setY(double y) {
this.y = y;
}
}
　　链表转为数组
//定义一个节点类
public class MyNode {
public int Data;
public MyNode next;
}
/*
* 定义一个将链表转化为数组的方法
*/
public class Test {
//定义一个得到一个链表的方法
public MyNode getl(){
MyNode tem=new MyNode();
MyNode tem3 ;
tem3=tem;
for(int k=1;k<5;k++){
MyNode tem4=new MyNode();
java.util.Random ran=new java.util.Random();

tem4.Data=ran.nextInt(1000);
tem3.next=tem4;
tem3=tem3.next;
}
return tem;
}
//传入一个链表，并且把链表转化为数组，并且返回一个数组
public int[] Gets(MyNode root){
int[] sa = new int[5];
// MyNode root1=new MyNode();
if(root!=null)
for(int i=0;i<sa.length;i++){
sa[i]=root.Data;
root=root.next;
}
return sa;
}
//定义一个打印数组的方法
public void printl(int[] sa){
for(int j=0;j<sa.length;j++){
System.out.println(sa[j]);
}
}
/**把一个字符串链表转化为字符串数组
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//实例化一个对象
Test ss=new Test();
MyNode tem1=ss.getl();
int[] ssa=ss.Gets(tem1);
ss.printl(ssa);
}
}