Java学习之数组
数组1
//filename su.java 数组讲解
/*使用java数组一般需要经过三个步骤：
①声明数组
②分配空间
③创建数组元素并赋值
前两个步骤语法如下:
数据类型[] 数组名； //声明一维数组
数组名 = new 数据类型[个数] //分配内存给数组
/
//下面举例说明数组的定义：
/
法一：
int[] x;//声明名称为x的int型数组
x = new int[10]; //x数组中包含有10个元素，并为这10个元素分配内存空间
法二：
在声明数组时，也可将两个语句合并为一句，格式如下：
数据类型[] 数组名 = new 数据类型[个数];
法三：
利用这种格式在声明数组的同时，也分配一块内存供数组使用，还可写成如下形式：
int[] x =new int[10];
//在等号左边的int[] x相当于定义了一个特殊的变量x，x的数据类型是一个对int型数组对象的引用，x就是一个数组的引用变量，其引用的数组元素个数不定
//等号右边的new int[10] 就是在堆内存中创建一个具有10个int类型变量的数组对象
*/
//程序简介：
//声明一个一维数组，其长度为5，利用循环对数组元素进行赋值，然后再利用另一个循环逆序输出数组元素的内容
public class sz
{
public static void main(String[] args)
{
int i;
int[] a;//声明一个数组a
a =new int[5];//分配内存空间供整型数组a使用，其元素个数为5
for (i=0;i<5 ;i++ )//对数组元素进行赋值
a[i]=i;
for(i=a.length-1;i>=1;i--)//逆序输出数组的内容
System.out.print("a[" +i+ "]=" +a[i] ",\t");
System.out.println("\n数组a的长度是："+a.length);//输出数组的长度
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
数组2
/*对数组元素的赋值，既可以使用单独方式进行，也可以在定义数组的同时就为数组元素分配空间并赋值，这种赋值方法称为数组的初始化
数据类型[ ] 数组名={初值0,初值1,…,初值n}
在花括号内的初值会依次赋值给数组的第1,2,…,n+1个元素，此外在声明数组的时候，无需将数组元素的个数给出，编译器会根据所给的初值的个数来设置数组的长度:
int[] a={1,2,3,4,5};
在上面的语句中，声明一个整形数组a，虽然没有特别知名数组的长度，但是由于花括号里的初值有五个，编译器会分别依次指定个元素存放，a[0]为1，a[1]为2,…,a[4]为5
*/
//程序要求：
//设数组中有n个互不相同的书，不用排序求出其中的最大值和次最大值。
//filename sz2
public class sz2 //比较数组元素值的大小
{
public static void main(String[] args)
{
int i,max,sec;
int[] a = {8,50,20,7,81,55,76,93};//声明数组a，并赋初值
if(a[0] > a[1])
{
max=a[0];//max存放最大值
sec=a[1];//min存放次最大值
}
else
{
max=a[1];
sec=a[0];
}
System.out.print("数组的个元素为："+a[0]+" "+a[1]);
for(i=2;i<a.length;i++)
{
System.out.print(" "+ a[i]);//输出数组a中的各元素
if(a[i]>max)//判断最大值
{
sec=max;//原最大值降为次最大值
max=a[i];//a[i]为新的最大值
}
else if(a[i]>sec)//即a[i]不是新的最大值，但若a[i]大于次最大值
sec = a[i];//a[i]为新的最大值
}
System.out.print("\n其中最大的值为:"+ max);//输出最大值
System.out.println(" 次最大的值为："+sec);//输出次最大值
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
数组3
//程序要求：
/*设有N给人为最一圈并按顺时针方向从1到N编号，从第S个人开始进行1到M报数，报数到第M的人，此人除权，在从他的下下一个人重新开始从1到M报数，如此进行，每次报数到M的人就出圈直到所有人都出圈为止，给出这个N个人的顺序
//filename sz3
*/
public class sz3 //约瑟夫环问题
{
public static void main(String[] args)
{
final int N=13,S=3,M=5;//设一共13个人，从第三个人开始1至5报数
int i=S-1,j,k=N,g=1;
int[] a=new int[N];
for(int h=1;h<=N;h++)
a[h-1]=h;//将第h个人的编号存入下标为h-1的数组元素中
System.out.println("\n出圈的顺序为: ");
do
{
i=i+{M-1};//计算除权人的下标i
while(i>=k)//当数组下标i大于等于圈中的人数k时
i=i-k;//将数组的下标i减去全中的人数k
System.out.print(" "+a[i]);//输出出圈人的编号
for(j=i;j<k-1;j++)
a[j]=a[j+1];//a[i]出圈后，将后续人的编号前移
k--;//圈中的人数k-1
g++;//g为循环控制变量
}
while (g<=N);//共有N人，所以循环N次
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
数组4
//多维数组
/*二维数组的声明方式与一维数组类似，内存的分配也是一样是用new运算符，其生命与非配内存的格式如下：
数据类型[] []数组名；
数组名=new 数据类型[行数] [列数]；
二维数组在分配内存时，要告诉编译器二维数组行与列的个数，因此上面的格式中，“行数”是告诉编译器所声明的数组有多少行，“列数”则是声明每行中有多少列。如下：
int[][] a; //声明二维整型数组a
a = new int[3][4];//分配一块内存空间，供3行4列的整型数组a使用；
简洁的表达方式如下:
数据类型[][] 数组名 = new 数据类型[行数][列数]；
以该种方式声明的数组，在声明的同时，就分配一块内存空间，供该数组使用，如下：
int[][] a =new int[3][4];
注意:Java中的二维数组不一定是规则的矩形；
如果数组对象正好是一个mn形式的规则矩阵，可不必向上面的代码一样，先创建高维的数组对象后，在逐一创建低维的数组对象，例如：
int[][] x =new int[2][3];
该语句表示创建一个23形式的二维数组。
在二维数组中，若要取得二维数组的行数，只要在数组名后加上.length属性即可；若要取得数组中某行元素的个数，则需在数组名后面加上该行的下标，再加上.length，例如：
x.length;//计算数组x的行数
x[0].length；//计算数组x的第1行元素的个数
x[2].length；//计算数组x的第3行元素的个数
注意：与一维数组相同，用new运算符来为数组申请内存空间时，很容易在数组各维数的指定中出现错误，二维数组要求必须指定高层维数。例如：
int[][] myArray = new int[10][];//只指定数组的高层维数
int[][] myArray = new int[10][3];//指定数组的高层维数和低层维数
如果想直接在声明二维数组时就给数组赋初值，可以利用花括号实现，只要在数组的声明格式后面再加上初值的赋值即可，如下:
数据类型[][] 数组名 = {{第1行初值},
{第2行初值},
{…},
{第n+1行初值}};
例如：
int[][] a ={{11,22,33,44}, //二维数组的初始赋值
{66,77,88,99}};
该语句中声明了一个整形数组a，该数组有2行4列共8个元素，花括号里的2组初值会分别一次指定给各行里的元素存放，a[0][0]为11，a[0][1]为22…
注意：与一维数组一样，在声明多维数组并初始化时，不能指定其长度，否则出错，如:int[2][3] b={{1,2,3},{4,5,6}}; 语句在编译时，将出错
*/
//filename sz4
//程序要求:计算并输出 杨辉三角形
public class sz4
{
public static void main(String[] args)
{
int i,j;
int level=7;
int[][] iaYong =new int[level][];//声明7行二维数组，存放杨辉三角形的各数；
System.out.println("杨辉三角形");
for(i=0;i<iaYong.length;i++)
iaYong[i]=new int[i+1]; //定义数组第i行有i+1列
iaYong[0][0]=1;
for(i=1;i<iaYong.length;i++) //计算杨辉三角形
{
iaYong[i][0] =1;
for(j=1;j<iaYong[i].length-1;j++)
iaYong[i][j]=iaYong[i-1][j-1]+iaYong[i-1][j];
iaYong[i][iaYong[i].length-1]=1;
}
for(int[] row : iaYong) //利用foreach语句显示出杨辉三角形
{
for(int col :row)
System.out.print(col+" ");
System.out.println();
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
数组5
/*
三维数组声明为 int[][][] a; 而四维数组为 int[][][][] a 依此类推
注意：
使用多维数组时，输入输出的方式和一，二维数组相同，但是每多一维数，嵌套循环的层数就必须多一层所以位数越高的数组其复杂程度也就越高
*/
//filename sz5
//程序要求：声明三维数组并赋初值，然后输出该数组的各元素，并计算各元素之和
public class sz5
{
public static void main(String[] args)
{
int i,j,k,sum=0;
int[][][] a = {{{1,2},{3,4}},{{5,6},{7,8}}};//声明三维数组并赋初值
for(i=0;i<a.length;i++)
for(j=0;j<a[i].length;j++)
for(k=0;k<a.[i][j].length;k++)
{
System.out.println("a["+i+"]["+j+"]["+k+"]="+a[i][j][k]);
sum+=a[i][j][k];//计算各元素之和
}
System.out.println("sum="+sum);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
文章来源: blog.csdn.net，作者：指剑，版权归原作者所有，如需转载，请联系作者。
原文链接：blog.csdn.net/fly1574/article/details/90778000
- 点赞
- 收藏
- 关注作者
评论（0）