数组

最新推荐文章于 2022-10-20 09:49:39 发布

安德烈雪99

最新推荐文章于 2022-10-20 09:49:39 发布

阅读量5.8k

点赞数 34

本文链接：https://blog.csdn.net/qq_38787854/article/details/81262260

版权

1、概念：一组相同类型的数据的组合
数组也是一种引用类型，
2、名称：数组名称不是固定的，与存放的数据的类型有关。

数组中只能存一种类型的数据
如: 存放一组int类型的数据，
   数组名称 int[]

   存放一组字符串数据
   数组名称 String[]

存放一组Scanner类型的数据
数组名称 Scanner[]

   存放一组字符类型的数据
   数组名称 char[]
3、元素的概念：
数组中的每个数据，都是这个数值的元素。
4、数组的声明与初始化
声明：元素类型[] 变量名;
元素类型变量名[];--不建议此写法
变量的初始化的时机：2种
   (1)声明时直接初始化
   (2)先声明，再初始化(使用前初始化)
数组的变量初始化：3种情况
(1)静态初始化
   String[] names = {"A","B"};
   int[] nums = {};

   (2)动态初始化
   --规定数组长度的写法
   int[] ages = new int[length];

       其实有默认元素：
       整数类型：默认是0
       浮点数类型：默认0.0
       字符类型：默认'\u0000'
       布尔类型：默认false
       引用数据类型：默认值null

   --不规定长度的写法
       int[] ages = new int[]{};
       double[] counts = new double[]{1.2,3.14};

5、数组的长度：
即数组元素的个数
表示方式：变量名.length;
6、数组的下标(index):
下标从0开始，最后一个元素的下标为：length-1;
下标范围：0~length-1
7、数组元素的访问(查看):
通过下标进行查看
语法:变量名[index];

元素的遍历(从头到尾依次查看)
for(int i=0;i<变量名.length;i++){
   System.out.println(变量命[i]);
}
8、数组元素的覆盖(赋值，替换)

语法：变量名[index] = value;

9、数组间的赋值

数组间的变量赋值：
           通过一个变量对数组的元素进行修改，
           那么与之相关的变量对应的数组的元素
           也会发生变化。
           如：
           int[] a = {1,2,3};
           int[] b = a;
           通过b修改元素，a对应的数组也跟着改变

数组是引用数据类型，在变量中村的是地址。

10、数组下标越界异常：
java.lang.ArrayIndexOutOfBoundsException

出现的原因：
访问数组元素时的下标超出了范围[0~length-1]，属于运行时异常，

数组下标越界异常，编译器检查不出来此异常
       运行时才会出现，出现的结果造成了程序的中断结束。
   正确范围：0~length-1
   错误下标：
   变量名[-1]
   变量名[length]
11、引用类型之Arrays
是数组的工具类。此类提供了很多对数组操作的功能方法
如：

在使用工具类时，一定要先到包。不然会出现错误
String info = Arrays.toString(数组名);
Arrays.toString():此方法是将数组的元素
一一拼接成字符串.(一定要是数组)

格式如下：
"[元素1,元素2,.....元素length-1]"

12、数组的复制
数组的特点：一经创建，长度不可变。

系统复制法：
System.arraycopy(src,start1,des,start2,length);
src:源数组，即被复制的数组名
start1:源数组复制的开始下标
des:目标数组，即复制到的数组名
start2:目标数组复制的开始下标
length:复制的长度

int[] nums = {99,100,98,99,100};
       int[] num1 = new int[nums.length];//{0,0,0,0,0}
       System.arraycopy(nums,0,num1,0,nums.length);
       System.out.println("num1:"+Arrays.toString(num1));

工具类提供的复制方法:
元素类型[] 变量名=Arrays.copyOf(src,newLength);
src:源数组
newLength:新数组的长度

功能解释：从src的下标为0的元素开始复制
复制到长度为newLength的新数组中
新数组存放元素的开始位置为0

（可以对复制的数组进行扩容何人缩容）

数组的练习：

/* 定义一个字符串数组names,
       存储10个学生的姓名*/
       String[] names = new String[10];
       for(int i=0;i<names.length;i++){
           names[i] = "小"+(char)(i+65);
       }
       for(int i=0;i<names.length;i++){
           System.out.print(names[i]+" ");
       }
       /* 定义一个int数组scores,用于存储这10个学生的
       成绩，成绩使用随机数 [90,100]
           计算成绩的平均值
           找到成绩的最大值，并输出其姓名
           找到成绩的最小值，并输出其姓名
       */
       System.out.println();
int[] scores = new int[names.length];
       for(int i=0;i<scores.length;i++){
           scores[i] = (int)(Math.random()*11+90);
       }
       for(int i=0;i<scores.length;i++){
           System.out.print(scores[i]+" ");
       }
       /* 计算平均值：*/
       int sum = 0;
       for(int i=0;i<scores.length;i++){
           sum+=scores[i];
       }
       double avg_score = sum*1.0/scores.length;
       System.out.println("平均成绩为："+avg_score);
       /* 找最大值 */
       int max = -1;//用于存入最大值
       int min = 101;//用于存储最小值
       for(int i=0;i<scores.length;i++){
           if(max<scores[i]){
               max = scores[i];//将较大值的成绩存入max
           }
           if(min>scores[i]){
               min = scores[i];//将较小值的成绩存入min
           }
       }
       System.out.println("最高成绩："+max);
       System.out.println("最低成绩："+min);

/*
       需要知道最高成绩的下标，才能知道人名
   而最高成绩的下标可能有多个。需要保存
       到一个新数组里

       最低成绩同上。
       */
       int h_count = 0;
       int l_count = 0;
       for(int i=0;i<scores.length;i++){
           if(max==scores[i]){
               h_count++;//统计最高成绩的个数
           }
           if(min==scores[i]){
               l_count++;//统计最低成绩的个数
           }
       }
       /*
       将最高/最低成绩的下标：
       存入新数组中
       */

       int[] max_indexs = new int[h_count];//用来存储最高成绩的多个下标
       int max_count=0;//用来下标的自增

       int[] min_indexs = new int[l_count];//用来存储最低成绩的多个下标
       int min_count=0;//用来下标的自增

       for(int i=0;i<scores.length;i++){
           if(scores[i]==max){
               max_indexs[max_count] = i;//找到最大值的下标，并存入新数组
               max_count++;//为下一次存储做准备
           }
           if(scores[i]==min){
               min_indexs[min_count++] = i;
           }
       }
       /*输出最高成绩的姓名和分数
       从存储下标的数组中，取出值，此值是
       names数组的下标

       */
       for(int i=0;i<max_indexs.length;i++){
           int v = max_indexs[i];
           System.out.println(names[v]+":"+scores[v]);
       }

       /*输出最低成绩的姓名和分数*/
       for(int i=0;i<min_indexs.length;i++){
           int v = min_indexs[i];//
           System.out.println(names[v]+":"+min);
       }

}

二维数组：

概念：数组的元素依然是数组
int[] a = {1,2,3,4}
int[][] b={{1,2},{2,3,4,5,6},{1,2,3}}
访问： b[0]-->{1,2}
b[1]-->{2,3,4,5,6}
b[2]-->{1,2,3}

b[0][0] -->1
b[0][1] -->2
.....
b[1][3] -->5
b[1][4] -->6
...
b[2][1] -->2
x={
{1,2,3},
{1,2,3},
{4,5,6}
}

x数组的元素：都是等长的数组，类似于矩阵。

y ={
   {1,2},
   {1,2,3},
   {1}
}
y数组的元素：不是等长的数组。

二维数组的初始化：
静态初始化
如：int[][] a = {{1},{1,2},{2,3,4}};

动态初始化：
(1)等长式初始化
int[][] a = new int[3][2];

   表示a有三个元素，每个元素都是2个长度的数组。
(2)只规定高维数组的长度
int[][] a = new int[3][];
   表示a有三个元素，但是都是null.
   null在使用时，需要新建数组对象(长度任意)

int[][] c = new int[3][];
       //输出c的第一个元素
       System.out.println(c[0]);//null 数组只有长度没有元素{}
c[0] = new int[2];//将null替换成数组对象，如果是以上初始化方法，一定要有这一步
       System.out.println(Arrays.toString(c[0]));
       c[0][0] = 1;
       c[0][1] = 2;
       System.out.println(c[0]);
       System.out.println(Arrays.toString(c[0]));

二维数组的练习

/*录入5个学生的数学，语文，英语三科成绩
       计算每科的平均成绩与每人的平均成绩
       并找出每科成绩的最高分与最低分。
       */

//以学生为主体，录入每个学生的3科，此处也可以以科目为主题，录入每个学生，

//数组定义变为 int[3][5]
       int[][] scores = new int[5][3];
       Scanner sc = new Scanner(System.in);
       for(int i=0;i<scores.length;i++){

//分别录入每个学生三科成绩
           System.out.println("录入第"+(i+1)+"个学生的成绩");
           for(int j=0;j<scores[i].length;j++){
               scores[i][j]=sc.nextInt();
           }
       }
       /*查看每个学生的成绩*/
       for(int i=0;i<scores.length;i++){
           System.out.println("学生"+(i+1)+":"+Arrays.toString(scores[i]));
       }
       /*计算每个学生的总成绩和平均成绩
       int sum = 0;
           sum+=scores[0][0];
           sum+=scores[0][1];
           sum+=scores[0][2];
           sum/3.0;

           int sum = 0;
           sum+=scores[1][0];
           sum+=scores[1][1];
           sum+=scores[1][2];
           sum/3.0;

           .....
       */
       for(int i=0;i<scores.length;i++){
           int sum = 0;
           for(int j=0;j<scores[i].length;j++){
               sum+=scores[i][j];
           }
           System.out.println("学生"+(i+1)+"的总成绩："+sum+",平均成绩："+(int)((sum/3.0)*100)/100.0);
       }
       /*
           计算每科的总成绩和平均成绩
           int total_sum = 0;
           total_sum+=scores[0][0];
           total_sum+=scores[1][0];
           total_sum+=scores[2][0];
           total_sum+=scores[3][0];
           total_sum+=scores[4][0];
           total_sum+=scores[5][0];
           .....
           total_sum/10.0

           int total_sum = 0;
           total_sum+=scores[0][1];
           total_sum+=scores[1][1];
           total_sum+=scores[2][1];
           total_sum+=scores[3][1];
           total_sum+=scores[4][1];
           total_sum+=scores[5][1];
           .....
           total_sum/10.0

           int total_sum = 0;
           total_sum+=scores[0][2];
           total_sum+=scores[1][2];
           total_sum+=scores[2][2];
           total_sum+=scores[3][2];
           total_sum+=scores[4][2];
           total_sum+=scores[5][2];
           .....
           total_sum/10.0

       */
       /*
       顺便统计每科的最高分与最低分
       */
       for(int i=0;i<scores[0].length;i++){
           int total_sum = 0;
           int max = -1;
           int min = 101;
           for(int j=0;j<scores.length;j++){
               total_sum+=scores[j][i];

               if(max<scores[j][i]){
                   max = scores[j][i];
               }
               if(min>scores[j][i]){
                   min = scores[j][i];
               }
           }
           System.out.println("学科"+(i+1)+"的总成绩："+total_sum+",平均成绩："+total_sum/10.0+",最高分："+max+",最低分："+min);
       }
   }

引用类型数组：
   基本数据类型数组，元素是基本类型的数据
   引用数据类型数组，元素是对象
   初始化的方式
       静态初始化：
           元素类型[] 变量名 = {}
       动态初始化
           规定长度
               元素类型[] 变量名 = new 元素类型[]
           不规定长度：
               元素类型[] 变量名 = new 元素类型[]{}
引用数据类型的数组使用规定长度的方式进行初始化
默认值是null；存入元素时，需要新建对象存入；
如：
   Cell[] cs = new Cell[10];
   cs里有地址，数组对象的地址，此对象里有10个null
   第一个元素存储（0，3）的方格
   cs[0]= new Cell(0,3)
   第一个元素存储（0，4）的方格
   cs[1]= new Cell(0,4)
引用类型的数组内，存储的是元素对象的地址信息

安德烈雪99

关注

34
点赞
踩
104

收藏

觉得还不错? 一键收藏
0
评论
数组

1、概念：一组相同类型的数据的组合数组也是一种引用类型，2、名称：数组名称不是固定的，与存放的数据的类型有关。数组中只能存一种类型的数据如: 存放一组int类型的数据，数组名称 int[] 存放一组字符串数据数组名称 String[] 存放一...
复制链接

扫一扫