队列和数组 数据结构J#

.数组
1.数组是什么类型的存储结构
数组也是属于应用类型的一种。
数组是一种线性的存储结构。
//链式结构

2.实例化一维数组的格式
一种：数据类型 []  数组名 = new 数据类型[数组的长度];
二种： 数据类型 []  数组名 = {值列表};
三种：数据类型 []  数组名;
数组名 = new 数据类型[数组的长度];
四种：数据类型 []  数组名 = new 数据类型[]{值列表};
数据类型 []  数组名;
数组名 = new 数据类型[]{值列表};

3.对一维数组的操作，通过什么？
得到数组的长度：数组.length属性名;
数组的下标是用来获取相应位置的值。
数组名[下标];
数组的下标从0开始的。

4.实例化二维数组的格式
一种：数据类型 [][]  数组名 = new 数据类型[行数][列数];
二种： 数据类型 [][]  数组名 = {{值列表},......};
三种：数据类型 [][]  数组名;
数组名 = new 数据类型[行数][列数];
四种：数据类型 [][]  数组名 = new 数据类型[][]{{值列表},......};
数据类型 [][]  数组名;
数组名 = new 数据类型[][]{{值列表},......};

对二维数组的操作，通过什么？
得到二维数组的行数：数组.length属性名;
得到二维数组的列数：数组[下标].length属性名;
是否可以创建不规则的二维数组？
可以创建不规则的二维数组，用第二种格式。
数组的下标是用来获取相应位置的值。
数组名[行下标][列下标];
数组的下标从0开始的。

5.随机数类的使用
java.util.Random的一个类

数组的缺点？
1.数组的长度是固定。
2.数组只能存储同样的数据类型。

数组的优点？
运行速度快-->有序的，查找的速度快，直接通过下标来找相应的数据。
队列
1.为什么要使用队列
数组不能随意的添加或者删除空间。

2.如何实现队列
借助于数组和引用传递。

自定义队列就是用类来操作数组，将所有的操作用类封装起来，在类外是无法看到具体的操作

实现通用的队列
//自定义泛型队列的接口
public interface NetJavaList<E> {
//向队列中加一个对象
public void add(E e);
//向队列中指定位置插入一个对象
public void insert(E e, int index);
//取得的队列中指定位置的对象
public E get(int index);
//删除某位置对象
public E delete(int index);
//得到队列中的长度，及队列中元素的个数
public int size();
}
//实现的泛型队列
public class STList<E> implements NetJavaList<E>{
private Object[] srcA = new Object[0];
//向队列中加一个对象
public void add(E e){
Object[] destA = new Object[srcA.length+1];
destA[srcA.length]=e;
System.arraycopy(srcA, 0, destA, 0, srcA.length);
srcA=destA;
}
//向队列中指定位置插入一个对象
public void insert(E e, int index){
Object[] destA = new Object[srcA.length+1];
System.arraycopy(srcA, 0, destA, 0, srcA.length);
for(int i=index+1;i<destA.length;i++){
destA[i+1]=destA[i];
}
destA[index]=e;
srcA=destA;
}
//取得的队列中指定位置的对
public E get(int index){
E st = (E)srcA[index];
return st;
}
//删除某位置对象
public E delete(int index){

for(int i=index;i<srcA.length;i++){
srcA[i]=srcA[i+1];
}
}
//得到队列中的长度，及队列中元素的个数
public int size(){
return srcA.length;
}
}
找出二维数组中最大的一个数值
public class Twoarray {
public static void main(String[] args){
//定义一个二维数组
int[][] srcA = creat();
int t = cacular(srcA);
System.out.println("二维数组的最大值是："+t);
//给数组中的每个元素赋值
public static int[][] creat(){
int ta[][] = new int[5][8];
for(int i=0;i<ta.length;i++){
for(int j=0;j<ta[i].length;j++){
java.util.Random ran = new java.util.Random();
int value =ran.nextInt(300)+200;
ta[i][j]=value;
}
}
return ta;
}

public static int cacular(int[][] x){
int max=x[0][0];
for(int i=0;i<ta.length;i++){
for(int j=0;j<x[i].length;j++){
if(max<x[i][j]){
max=x[i][j];
}
}

}
return max;
}


}
}