【06】JAVASE-数组讲解【从零开始学JAVA】

Java零基础系列课程-JavaSE基础篇

Lecture：波哥

在这里插入图片描述

  Java 是第一大编程语言和开发平台。它有助于企业降低成本、缩短开发周期、推动创新以及改善应用服务。如今全球有数百万开发人员运行着超过 51 亿个 Java 虚拟机，Java 仍是企业和开发人员的首选开发平台。

六、数组讲解

1.为什么要使用数组

byte short int long

double float

boolean

char

String

问题：Java考试结束后，需要统计全班学员的平均分(30个人)。

解决方案：定义30个变量，然后相加求和，并计算平均分。

更好的解决方案：数组 数据容器

2.内存分配

2.1 硬盘

​ 持久化我们的数据

2.2 内存

​ 运行时存储，在软件(程序)运行的时候开辟空间，软件运行结束后，内存中的数据就会消失

Java程序运行的时候，系统分配的内存,Java程序是怎么利用的？

FunDemo01.java这个Java文件肯定是存储在硬盘上的。但是当我们通过javac FunDemo01.java --> FunDemo01.class -->

java FunDemo01 执行 这个过程中内存是怎么分配的?

2.3 Java程序的内存分区

内存划分的结构图

在这里插入图片描述

名称描述
方法区又称为代码区/永久区，存放 代码、静态东西、常量池
堆存放的是new出来的东西
本地方法栈和系统有关系，我们暂时不介绍
Java虚拟机栈存放局部变量的
程序计数器和CPU计算有关，暂时也不介绍

局部变量：方法体内定义的变量 或者 方法定义时声明的变量【形参】

public class ArrayDemo01 {// 定义一个全局变量int sum = 30;public static void main(String[] args) {// 定义一个局部变量int i = 10;}}

2.4 Java虚拟机栈的特点

  1. 先进后出(Firt in last out FILO),类似于子弹夹
  2. 栈区中的数据仅在作用域内有效，使用完毕之后立马自动释放
  3. 栈内的变量没有默认值，如果没有给出默认值就直接报错

2.5 堆区的特点

1.堆区中的每个变量都有默认值

byte short int long 默认的都是 0

float double 默认的 0.0

char 默认的是 ‘\u0000’ 就是一个空字符

boolean 默认值 false

引用类型 默认值是 null

2.凡是new出来的东西都在堆区开辟空间，堆区开辟的空间都会有地址值

3.在堆区中的对象，一旦使用完毕之后，不会立刻消失，会等待垃圾回收期空闲的时候自动回收

3.数组的初始化

3.1 数组的语法格式

数据类型[] 数组名 = new 数据类型[数组的长度];
数据类型 数组名[] = new 数据类型[数组的长度];

public static void main(String[] args) {// 定义一个数组int[] array1 = new int[5];int array2[] = new int[10];
}

数组其实也一个变量，存储相同类型的一组数据

作用：告诉计算机数据类型是什么

特点：

  1. 数据类型相同
  2. 数组名实际上就是一个变量，既然是变量，那就必须先赋值在使用
  3. 数组的每一个元素既可以是基本数据类型，也可以是引用数据类型

A “张三” ,“李四” ,“王五”

B 9 , 99, “c”, 12

C 98.1 ,33.3 ,45

3.2 数组的内存分配

上面的数组的语法格式其实有两步组成

1.数组的声明

int[] array1;

声明的变量会在内存中划分一块合适的空间，栈区

在这里插入图片描述

2.数组的赋值

arra1 = new int[5];

将内存划分出来的一串连续的内存空间的地址赋值给了变量

在这里插入图片描述

3.3 数组的赋值

​ 在前面介绍的 arra1 = new int[5]; 数组中的每个元素会根据数组的类型赋予默认值，那么我们可以通过数组的下标来获取数组中的各个位置上的元素，在Java中数组的下标是从0开始的,最大的下标 length-1

如果我们从数组中获取元素的下表超过的数组的长度会出错，下表越界

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3

下标不能是负数

java.lang.ArrayIndexOutOfBoundsException: -1

我想要修改数组中对应位置中的元素

public static void main(String[] args) {int i = 10;// 定义一个数组int[] array1 = new int[3];array1[0] = 5;array1[1] = 6;array1[2] = 7;System.out.println(array1[0]);System.out.println(array1[1]);System.out.println(array1[2]);
}

简化的初始化方式

在初始化的时候就为每个元素赋值，不需要指明长度

public static void main(String[] args) {//int[] a1 = new int[7];// 声明变量后直接将一个数组赋值给了这个变量int a1[] = {1,2,3,4,5,6,7,8,9};System.out.println(a1[0]);System.out.println(a1[3]);System.out.println(a1[4]);System.out.println(a1[5]);System.out.println(a1[6]);
}

注意事项：

  1. 标识符：数组的名称，用于区分不同的数组
  2. 数组元素：向数组中存放的数据
  3. 元素下标，从0开始，数据中的每个元素都可以通过下标来访问
  4. 元素类型：数组元素的数据类型

4. 数组的遍历

​ 前面我们是通过下标一个个从数组中取出元素的，这种在数组中元素比较多的情况下，会比较麻烦这时我们可以考虑使用前面介绍的循环来实现。

public static void main(String[] args) {//int[] a1 = new int[]{1,2,3,4,5,6,7,8,9};int a1[] = {1,2,3,4,5,6,7,8,9};// 通过遍历的形式获取数组中的每个元素System.out.println(a1[0]);System.out.println(a1[1]);System.out.println(a1[2]);System.out.println(a1[3]);System.out.println(a1[4]);System.out.println(a1[5]);System.out.println(a1[6]);System.out.println(a1[7]);System.out.println(a1[8]);for(int i = 0 ; i < a1.length ; i ++){System.out.println(a1[i]);}
}

案例：将数组转换为如下格式的字符串

[33,55,77,999]

/*** 将数组转换为如下格式的字符串* [33,55,77,999]* 解决的思路：*    1.声明一个字符串 String arrayStrinig = "[";*    2.变量获取数组中的每个元素 拼接在 arrayString中 *    3.在循环结束后 将 "]" 拼接到arrayString的结尾* @param a* @return*/
public static String arrayToString(int[] a){String arrayString = "[";for(int i = 0 ; i < a.length; i ++){if(i == a.length-1){// 获取数组中的最后一个元素arrayString += a[i];}else{arrayString += a[i]+",";}}arrayString += "]";return arrayString;
}

5. 课堂案例

5.1 计算5个学员的平均分

public class ArrayDemo05 {/*** 计算5个学员的平均分* * @param args*/public static void main(String[] args) {double[] score = {67,89,87,68,54};// 记录学员总分double sum = 0;for(int i = 0 ; i < score.length; i ++){sum += score[i];}System.out.println("5个学员的平均分是：" + sum/5);}}

5.2 有一个数列： 8,4,1,0,25,199,33

​ A 循环输出数列值

​ B 求数列中所有数值的和

​ C 求出最大值

​ D 将数组倒置并输出

​ E 数组查找 猜数字游戏：从键盘中任意输入一个数字判断是否在数列中

​ F 数组排序

package com.bobo.array;import java.util.Scanner;public class ArrayDemo06 {/*** 5.2 有一个数列： 8,4,1,0,25,199,33
​       A 循环输出数列值
​	   B 求数列中所有数值的和
​       C 求出最大值
​       D 将数组倒置并输出
​       E  数组查找 猜数字游戏：从键盘中任意输入一个数字判断是否在数列中
​	   F  数组排序* @param args*/public static void main(String[] args) {int[] a = { 8,4,1,0,25,199,33};printArray(a);System.out.println("数列中所有值的和:" + getSum(a));System.out.println("数列中的最大值是：" + getMax(a));// 将数组倒置reverseArray2(a);printArray(a);Scanner input = new Scanner(System.in);System.out.println("请输入一个数字：");int num = input.nextInt();System.out.println(num + "是否在数列中：" + isContainsNumInArray(a, num));}/*** 循环输出数列值* @param a*/public static void printArray(int[] a){for(int i = 0 ; i< a.length ; i++){System.out.println(a[i]);}}/*** 求数列中所有数值的和* @param a* @return*/public static int getSum(int[] a){int sum = 0 ;for(int i = 0 ; i < a.length ;i ++){sum += a[i];}return sum;}/*** 求出最大值*  8,4,1,0,25,199,33* @param a*/public static int getMax(int[] a){int max = 0 ;for(int i = 0 ; i < a.length ; i ++){if(max < a[i]){max = a[i];}}return max;}/*** 将数组倒置并输出* 8,4,1,0,25,199,33 * 33 199 25 0 1 4 8* */public static int[] reverseArray1(int[] a){int[] b = new int[a.length];for(int i = a.length-1 ,j=0; i >= 0; i--,j++){b[j] = a[i];}return b;}/*** 将数组倒置并输出* 8,4,1,0,25,199,33 * 33 199 25 0 1 4 8* 第一个数和最后一个数交换位置* a[0] 和  a[a.length-1 -0]* int temp = 0;* temp = a[0]* a[0] = a[a.length-1 -0]* a[a.length-1 -0]=temp* * 第二个和倒数第二个交换位置* a[1] 和  a[a.length-1 -1]* * 假设 a.length = 7   3次  a.length/2* 假设 a.length = 6   3次* 假设 a.length = 5   2次*                4   2次*                3   1次*                2   1次*                1   0次*/public static void reverseArray2(int[] a){for(int i=0 ; i < a.length/2 ;i++){int temp = 0 ;temp = a[i];a[i] = a[a.length-1-i];a[a.length-1-i] = temp;}}/*** 数组查找 猜数字游戏：从键盘中任意输入一个数字判断是否在数列中* @param a* @return*/public static boolean isContainsNumInArray(int[] a,int num){for(int i = 0 ; i < a.length ; i ++){if(num == a[i]){return true;}}return false;}}

排序下个内容单独介绍

6.排序

​ 将一个无序的数组转换为一个有序的数组

6.1 冒泡排序

​ 冒泡排序：从第一个数据开始，一次比较相邻元素的大小。如果前者大于后者，则进行交换操作。把大的元素往后交换。通过多轮迭代，直到没有交换操作为止。冒泡排序就像是在一个水池中处理数据一样，每次会把最大的那个数据传递到最后。

package com.bobo.array;import java.util.Arrays;public class ArrayDemo08 {/*** 冒泡排序*      1 4 3 5 2*         1 3 4 2 5* @param args*/public static void main(String[] args) {int[] a = {1,4,3,5,2};System.out.println("排序前：" );System.out.println(Arrays.toString(a));// 第一趟排序/*for (int i = 0 ; i < a.length-1-0 ; i++) {if(a[i] > a[i+1]){int temp = 0 ; temp = a[i];a[i] = a[i+1];a[i+1] = temp;}}System.out.println("第一趟排序后：");System.out.println(Arrays.toString(a));// 最后一位数值肯定是最大的// 第二趟排序for (int i = 0 ; i < a.length-1-1 ; i++) {if(a[i] > a[i+1]){int temp = 0 ; temp = a[i];a[i] = a[i+1];a[i+1] = temp;}}System.out.println("第二趟排序后：");System.out.println(Arrays.toString(a));// 第三趟排序for (int i = 0 ; i < a.length-1-2 ; i++) {if(a[i] > a[i+1]){int temp = 0 ; temp = a[i];a[i] = a[i+1];a[i+1] = temp;}}System.out.println("第三趟排序后：");System.out.println(Arrays.toString(a));// 第四趟排序for (int i = 0 ; i < a.length-1-3 ; i++) {if(a[i] > a[i+1]){int temp = 0 ; temp = a[i];a[i] = a[i+1];a[i+1] = temp;}}System.out.println("第四趟排序后：");System.out.println(Arrays.toString(a));*//*for(int i = 0 ; i < a.length-1; i ++){for(int j = 0 ; j < a.length-1 - i; j ++ ){if(a[j] > a[j+1]){int temp = 0 ; temp = a[j];a[j] = a[j+1];a[j+1] = temp;	}}}*/bubbleSort(a);System.out.println("冒泡排序后：");System.out.println(Arrays.toString(a));}public static void bubbleSort(int[] a){for(int i = 0 ; i < a.length-1; i ++){for(int j = 0 ; j < a.length-1 - i; j ++ ){if(a[j] > a[j+1]){int temp = 0 ; temp = a[j];a[j] = a[j+1];a[j+1] = temp;	}}}}}

在这里插入图片描述

6.2 选择排序

  选择排序原理为：随机确定一个标志位（一般为第一个数字）作为最小数，然后向后遍历，找到比标志位更小的数便与标志位互换位置并更新最小数，实现步骤为：

  1. 将数组的第一个数字设置为标志位最小数并记录最小数下标。
  2. 向后遍历，发现更小数后将该数与标志位互换位置并更新最小数与最小数下标。
  3. 循环完成排序

在这里插入图片描述

package com.boge.array;import java.util.Arrays;public class ArrayDemo05 {/*** 选择排序* @param args*/public static void main(String[] args) {int a[] = {6,1,8,9,2,3,5,4,7};System.out.println("排序前:" + Arrays.toString(a));int minIndex = 0;int minValue = a[0];for(int i = minIndex + 1; i < a.length ; i ++){if(a[i] < minValue){minIndex = i;minValue = a[i];}}// 把原来要替换的数据更新到对应的最小的索引位a[minIndex] = a[0];// 把最小数放到最前面a[0] = minValue;System.out.println("第一次排序:" + Arrays.toString(a));// 第二次排序minIndex = 1;minValue = a[1];for(int i = minIndex + 1; i < a.length ; i ++){if(a[i] < minValue){minIndex = i;minValue = a[i];}}// 把原来要替换的数据更新到对应的最小的索引位a[minIndex] = a[1];// 把最小数放到最前面a[1] = minValue;System.out.println("第二次排序:" + Arrays.toString(a));// 第三次排序minIndex = 2;minValue = a[2];for(int i = minIndex + 1; i < a.length ; i ++){if(a[i] < minValue){minIndex = i;minValue = a[i];}}// 把原来要替换的数据更新到对应的最小的索引位a[minIndex] = a[2];// 把最小数放到最前面a[2] = minValue;System.out.println("第三次排序:" + Arrays.toString(a));}
}// 整理的
package com.boge.array;import java.util.Arrays;public class ArrayDemo06 {/*** 选择排序* @param args*/public static void main(String[] args) {int a[] = {6,1,8,9,2,3,5,4,7};System.out.println("排序前:" + Arrays.toString(a));selectSort(a);System.out.println("排序后:" + Arrays.toString(a));}public static void selectSort(int[] a){for(int j = 0 ; j < a.length - 1; j++){int minIndex = j;int minValue = a[j];for(int i = minIndex + 1; i < a.length ; i ++){if(a[i] < minValue){minIndex = i;minValue = a[i];}}// 把原来要替换的数据更新到对应的最小的索引位a[minIndex] = a[j];// 把最小数放到最前面a[j] = minValue;}}
}

6.3 排序效率的测评

​ 选择排序和冒泡排序哪个效率高？我们通过测试数据来看看

package com.boge.array;import java.util.Arrays;public class ArrayDemo07 {/*** System.currentTimeMillis()* 	返回从1970年1月1日0时0分0秒 距今已经过去了多少毫秒* @param args*/public static void main(String[] args) {int a[] = new int[100000];for(int i = 0 ; i < a.length ; i++){a[i] = (int)(Math.random()*10000);}long start = System.currentTimeMillis();selectSort(a);long end = System.currentTimeMillis();System.out.println("选择排序花的时间:" + (end - start));start = System.currentTimeMillis();bubbleSort(a);end = System.currentTimeMillis();System.out.println("冒泡排序花的时间:" + (end - start));}public static void selectSort(int[] a){for(int j = 0 ; j < a.length - 1; j++){int minIndex = j;int minValue = a[j];for(int i = minIndex + 1; i < a.length ; i ++){if(a[i] < minValue){minIndex = i;minValue = a[i];}}// 把原来要替换的数据更新到对应的最小的索引位a[minIndex] = a[j];// 把最小数放到最前面a[j] = minValue;}}public static void bubbleSort(int[] a){for(int i = 0 ; i < a.length-1; i ++){for(int j = 0 ; j < a.length-1 - i; j ++ ){if(a[j] > a[j+1]){int temp = 0 ;temp = a[j];a[j] = a[j+1];a[j+1] = temp;}}}}
}

在这里插入图片描述

7.查找

​ 想要从数组中快速找到我们需要的元素，如果我要查找某个位置上的元素，那么我可以通过下标快速的找到，但是如果我们不知道数组中有哪些元素，而我们又需要找这个元素，那么此时我们应该怎么办呢？

7.1 顺序查找

​ 从数组的第一个元素开始遍历，找了就结束遍历，否则直到遍历完成

package com.bobo.array;public class ArrayDemo02 {public static void main(String[] args) {int[] d = {1,2,3,4,5,6,7,8,9,10};System.out.println(basicSelect(d, 11));}public static boolean basicSelect(int[] a,int num){for(int i = 0 ; i < a.length ; i ++){if(a[i] == num){return true;}}return false;}}

7.2 折半查找(二分查找)

前提条件：只能够针对排好序的数据进行查找

查找思路：每次都实现查找数据的中间元素，将需要找的数据和中间那个元素进行比较，这样查找可以减少至少一半的效率

在这里插入图片描述

8.增强版for循环

增强版for循环也称为foreach循环。相对于之前的普通for循环要简洁一些

语法格式：

for(元素类型 元素变量 : 遍历对象 ){// 循环体 使用元素变量
}

package com.bobo.array;public class ArrayDemo04 {/*** for(元素类型 元素变量 : 遍历对象 ){// 循环体 使用元素变量}* @param args*/public static void main(String[] args) {int[] a = {11,22,33,44,55,66};for(int i : a){System.out.println(i);}for(int i =  0 ; i < a.length ; i ++){System.out.println(a[i]);}}}

foreach循环和for循环对比：

  1. foreach循环更适合遍历数据
  2. foreach循环没有下标，普通for循环适合做添加，删除操作
  3. 本质上面foreach循环就是普通for循环

在这里插入图片描述

9. 可变的参数列表

可变参数列表的语法规则

参数类型 ... 变量名称

package com.bobo.array;public class ArrayDemo05 {/*** 方法的形参中出现了 类型相同，个数不同的情况，这时我们可以使用 可变参数列表来实现* @param args*/public static void main(String[] args) {// TODO Auto-generated method stubSystem.out.println(add(1,2));System.out.println(add(1,2,3));System.out.println(add(1,2,3,4));add();}/*	public static int add(int a,int b){return a + b ;}public static int add(int a,int b,int c){return a + b + c;}*/public static int add(int ... a){System.out.println(a);int sum = 0 ;for(int i : a){sum += i;}return sum;}}

可变参数的特点：

  1. …的位置 放在参数类型和变量名之间即可
  2. 可变参数列表必须出现在参数列表的最后面，而且一个方法的形参中最多只能有一个可变参数列表
  3. 可变参数列表本质上就是数组，既然是数组那么就可以按照数组的思路来处理

10. Arrays工具

在Java中提供了一个针对于数组操作的工具类，Arrays

package com.bobo.array;import java.util.Arrays;public class ArrayDemo06 {/*** Arrays工具类介绍* * @param args*/public static void main(String[] args) {int[] a = {11,7,22,33,99,225,44,66,55,66,87,7};int[] b = {11,7,22,33,99,225,44,66,55,66,87,7};// 将数组转换为一个字符串System.out.println(Arrays.toString(a));// 排序// Arrays.sort(a);// 指定某个范围内的数据排序//Arrays.sort(a, 3, 8);System.out.println(Arrays.toString(a));// 二分查找int index = Arrays.binarySearch(a, 661);System.out.println(index);// 判断两个数组是否相等System.out.println(Arrays.equals(a, b));// 给数组中的元素填充内容// Arrays.fill(a, 1);// 局部填充Arrays.fill(a, 2, 5, 1);System.out.println(Arrays.toString(a));// 复制数组int[] c = Arrays.copyOf(a, a.length-2);System.out.println(Arrays.toString(c));// 指定范围复制int d[] = Arrays.copyOfRange(a, 3, 7);System.out.println(Arrays.toString(d));}}

统计三个班上每个学员的成绩，计算班级的平均分和总分。

A 67 78 88 90 78

B 99 90 87

C 56 99

11. 二维数组

11.1 语法格式介绍

概念：本质上就是一个存放了一维数据的数组

语法规则：

//格式1：
数据类型[][] 变量名 = new 数据类型[m][n];
//m:表示一个二维数组中有m个一维数组
//n:每个一维数组中有n个元素//格式2：
数据类型 变量名[][] =   new 数据类型[m][n]; 
//格式3
数据类型[] 变量名[] = new 数据类型[m][n]; m必不可少，n可写可不写

/*** 二维数组* @param args*/
public static void main(String[] args) {int[] a = new int[4];int[][] arr = new int[3][2];int arr1[][] = new int[3][2];int[] arr2[] = new int[3][2];
}

注意：Java中并没有真正意义上的二维数组，本质上就是一个存放了一维数组的数组

​ 数组中的每个元素还是一个数组，那么二维数组中每一个元素的值应该是地址值

11.2 二维数组的内存图

n初始指定的情况下：

package com.bobo.array;public class ArrayDemo07 {/*** 二维数组* @param args*/public static void main(String[] args) {/*int[][] arr = new int[3][2];int arr1[][] = new int[3][2];int[] arr2[] = new int[3][2];int[][] arr3 = new int[3][];*/int arr[][] = new int[3][2];System.out.println(arr);System.out.println(arr[0]); //[I@15db9742System.out.println(arr[1]); //[I@6d06d69cSystem.out.println(arr[2]); //[I@7852e922//System.out.println(arr[3]); // 数组 越界System.out.println(arr[0][0]); // 0System.out.println(arr[0][1]); // 0 System.out.println(arr[1][0]); // 0//System.out.println(arr[0][2]);// 数组 越界arr[0][0] = 100;arr[0][1] = 200;arr[1][0] = 300;System.out.println(arr[0][0]); // 100System.out.println(arr[0][1]); // 200 System.out.println(arr[1][0]); // 300}}

在这里插入图片描述

n初始不指定的情况下：

package com.bobo.array;public class ArrayDemo08 {public static void main(String[] args) {int[][] arr = new int[3][];System.out.println(arr);System.out.println(arr[0]); //nullSystem.out.println(arr[1]); //nullSystem.out.println(arr[2]); //null// System.out.println(arr[0][0]);arr[0] = new int[3];arr[1] = new int[2];arr[2] = new int[1];System.out.println(arr[0][0]); // 0System.out.println(arr[0][1]); // 0 System.out.println(arr[1][0]); // 0//System.out.println(arr[1][2]);// 数组 越界arr[0][0] = 100;arr[0][1] = 200;arr[1][0] = 300;//arr[2][2] = 400;System.out.println(arr[0][0]); // 100System.out.println(arr[0][1]); // 200 System.out.println(arr[1][0]); // 300}
}

在这里插入图片描述

11.3 二维数组的静态初始化

// 一维数组中的静态初始化
int arr[] = new int[]{1,2,3,4,5,6};
int arr[] = {1,2,3,4,5,6};

int[][] arr = new int[][]{{},{},{}};
int[][] arr = {{},{},{}};

public static void main(String[] args) {int[][] arr = new int[][]{{11,22,33},{44,55},{66,77,88,99}};int[][] arr1 = {{11,22,33},{44,55},{66,77,88,99}};
}

针对二维数组的遍历

package com.bobo.array;import java.util.Arrays;public class ArrayDemo09 {public static void main(String[] args) {int[][] arr = new int[][]{{11,22,33},{44,55},{66,77,88,99}};int[][] arr1 = {{11,22,33},{44,55},{66,77,88,99}};int a0[] = arr[0];System.out.println(Arrays.toString(a0));int a1[] = arr[1];System.out.println(Arrays.toString(a1));int a2[] = arr[2];System.out.println(Arrays.toString(a2));System.out.println("----------");arrayPrintToString(arr);}public static void arrayPrintToString(int[] ... arr){for(int i = 0 ; i < arr.length ; i++){//System.out.println(Arrays.toString(arr[i]));// arr[i] 又是一个新的一维数组  那么我就可以按照一维数组的处理方式来处理了for(int j = 0 ; j < arr[i].length; j++){System.out.print(arr[i][j] + "\t");}System.out.println();}}
}

foreach循环效果

package com.bobo.array;import java.util.Arrays;public class ArrayDemo09 {public static void main(String[] args) {int[][] arr = new int[][]{{11,22,33},{44,55},{66,77,88,99}};int[][] arr1 = {{11,22,33},{44,55},{66,77,88,99}};int a0[] = arr[0];System.out.println(Arrays.toString(a0));int a1[] = arr[1];System.out.println(Arrays.toString(a1));int a2[] = arr[2];System.out.println(Arrays.toString(a2));System.out.println("----------");arrayPrintToString(arr);}public static void arrayPrintToString(int[] ... arr){/*for(int i = 0 ; i < arr.length ; i++){//System.out.println(Arrays.toString(arr[i]));// arr[i] 又是一个新的一维数组  那么我就可以按照一维数组的处理方式来处理了for(int j = 0 ; j < arr[i].length; j++){System.out.print(arr[i][j] + "\t");}System.out.println();}*/for(int[] x : arr){for(int y : x){System.out.print(y + "\t");}System.out.println();}}
}

二维数组遍历的规律：

  1. 外层循环控制一维数组的个数
  2. 内存循环控制每一个一维数组的元素个数

11.4 课堂案例

1.统计三个班级中的学员的成绩的平均分

package com.bobo.array;public class ArrayDemo10 {/*** 1.统计三个班级中的学员的成绩的平均分* @param args*/public static void main(String[] args) {int score[][] = {{78,87,90,93,78},{67,76,84},{45,80}};// 总分int sum = 0 ;int num = 0; // 记录总的学员数量for(int[] ss:score){for(int s:ss){sum+=s;num++;}}System.out.println("统计获取总的平均分:"+sum/num);}}

2.键盘输入一个值，打印对应的杨辉三角图案。

1
1   1
1   2   1
1   3   3   1
1   4   6   4    1
1   5   10  10   5    1

规则：

  1. n行有n列，类似于九九乘法表
  2. 每一行的第一列和最后一列的值为1
  3. 从第三行开始，除了第一列和最后一列，每个元素的值等于上一行的前一列加上上一行的本列的值之和
package com.bobo.array;import java.util.Scanner;public class ArrayDemo11 {/*** 规则：1. n行有n列，类似于九九乘法表2. 每一行的第一列和最后一列的值为13. 从第三行开始，除了第一列和最后一列，每个元素的值等于上一行的前一列加上上一行的本列的值之和* @param args*/public static void main(String[] args) {Scanner in = new Scanner(System.in);System.out.println("请输入杨辉三角的行数：");int n = in.nextInt();// 创建二维数组int[][] arr = new int[n][n];// 给二维数组赋值// a.给每一行的第一列和最后一列的值为1for(int i = 0 ; i < arr.length; i ++){// 没循环一次取出一行arr[i][0] = 1;arr[i][i] = 1;}// b.从第三行开始，除了第一列和最后一列，// 每个元素的值等于上一行的前一列加上上一行的本列的值之和for(int i = 2 ; i < arr.length ; i ++){for(int j = 1 ; j < arr.length-1 ; j++){arr[i][j] = arr[i-1][j-1] + arr[i-1][j];}}printArray(arr);}public static void printArray(int[][] arrays){/*for(int[] array : arrays){for(int a:array){System.out.print(a + "\t");}System.out.println();}*/for(int i = 0 ; i < arrays.length ; i ++){for(int j = 0 ; j <= i ; j++){System.out.print(arrays[i][j] + "\t");}System.out.println();}}}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/829606.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

最全GPTs使用教程+Prompt预设词教程

最全GPTs使用教程+Prompt预设词教程

使用指南 直接复制使用 可以前往已经添加好Prompt预设的AI系统测试使用&#xff08;可自定义添加使用&#xff09; https://ai.sparkaigf.com 现已支持GPTs 雅思写作考官 我希望你假定自己是雅思写作考官&#xff0c;根据雅思评判标准&#xff0c;按我给你的雅思考题和对应…
阅读更多...
从零入门区块链和比特币（第三期）

从零入门区块链和比特币（第三期）

欢迎来到我的区块链与比特币入门指南&#xff01;如果你对区块链和比特币感兴趣&#xff0c;但不知道从何开始&#xff0c;那么你来对地方了。本博客将为你提供一个简明扼要的介绍&#xff0c;帮助你了解这个领域的基础知识&#xff0c;并引导你进一步探索这个激动人心的领域。…
阅读更多...
一些基础知识FK

一些基础知识FK

1. 群体稳定性指数PSI 通过 PSI(Population Stability Index) 指标&#xff0c;可以得到不同样本下&#xff0c;模型在各分数段分布的稳定性。用于衡量两个群体(比如两个时间点、两个子群体等)之间稳定性的指标。通常PSI被用于评估信用风险模型、预测模型等在不同时间点或不同群…
阅读更多...
安装配置Maven（idea里面配置）

安装配置Maven（idea里面配置）

放在这个路径下&#xff08;如果需要可以免费发给你&#xff0c;dd我就好了&#xff09; D:\IearnSoftware\maven\apache-maven-3.6.1-bin.zip&#xff08;我自己的路径下面&#xff0c;防止忘记&#xff09; 1.首先测试maven在不在&#xff0c;配置对不对 mvn -v 这样就是成…
阅读更多...
STM32HAL库++ESP8266+cJSON连接阿里云物联网平台

STM32HAL库++ESP8266+cJSON连接阿里云物联网平台

实验使用资源&#xff1a;正点原子F1 USART1&#xff1a;PA9P、A10&#xff08;串口打印调试&#xff09; USART3&#xff1a;PB10、PB11&#xff08;WiFi模块&#xff09; DHT11&#xff1a;PG11&#xff08;采集数据、上报&#xff09; LED0、1&#xff1a;PB5、PE5&#xff…
阅读更多...
【微信小程序调用百度API实现图像识别实战】-前后端加强版

【微信小程序调用百度API实现图像识别实战】-前后端加强版

前言&#xff1a;基于前面两篇图像识别项目实战文章进行了改造升级。 第一篇 入门【微信小程序调用百度API实现图像识别功能】----项目实战 第二篇 前后端结合 【微信小程序调用百度API实现图像识别实战】----前后端分离 这一篇主要讲述的是在第二篇的基础上新增意见反馈功能&a…
阅读更多...
第72天：漏洞发现-Web框架中间件联动GobyAfrogXrayAwvsVulmap

第72天：漏洞发现-Web框架中间件联动GobyAfrogXrayAwvsVulmap

案例一&#xff1a;某 APP-Web 扫描-常规&联动-Burp&Awvs&Xray Acunetix 一款商业的 Web 漏洞扫描程序&#xff0c;它可以检查 Web 应用程序中的漏洞&#xff0c;如 SQL 注入、跨站脚本攻击、身份验证页上的弱口令长度等。它拥有一个操作方便的图形用户界 面&#…
阅读更多...
实验8 NAT配置

实验8 NAT配置

实验8 NAT配置 一、 原理描述二、 实验目的三、 实验内容1.实验场景2.实验要求 四、 实验配置五、 实验步骤2.静态NAT配置3.NAT Outbound配置4.NAT Easy-IP配置 一、 原理描述 2019年11月26日&#xff0c;全球43亿个IPv4地址正式耗尽&#xff0c;这意味着没有更多的IPv4地址可…
阅读更多...
Taro引入echarts【兼容多端小程序（飞书/微信/支付宝小程序）】

Taro引入echarts【兼容多端小程序（飞书/微信/支付宝小程序）】

近期接到公司新需求&#xff0c;开发飞书小程序&#xff0c;并且原型中含有大量的图表&#xff0c;本想使用飞书内置图表组件 —— chart-space&#xff0c;但官方表示已经停止维护了&#xff0c;无奈之下&#xff0c;只能另寻他路&#xff0c;于是乎&#xff0c;图表之王&…
阅读更多...
【Godot4.2】自定义Todo清单类 - myTodoList

【Godot4.2】自定义Todo清单类 - myTodoList

概述 在写myList类的时候&#xff0c;就想到可以写一个类似的Todo清单类。 基础思路 本质还是在内部维护一个数组&#xff0c;在其基础上进行增删改查操作的封装为了方便存储数据&#xff0c;编写一个自定义内置类TodoItem&#xff0c;内部数组就变成了Array[TodoItem]类型的…
阅读更多...
【Flutter】GetX

【Flutter】GetX

前言 状态管理 / 路由管理 / 依赖管理 这三部分之间存在联系 参考文章 建议看官网文章&#xff0c;很详细 &#xff0c;pub.dev搜索get pub.dev的文档 状态管理文章相关链接 状态管理 案例 实现一个计算器&#xff0c;运用GetX去管理它 构建界面 构建一个计算器界面 …
阅读更多...
GateWay具体的使用之全链路跟踪TraceId日志

GateWay具体的使用之全链路跟踪TraceId日志

1.创建全局过滤器&#xff0c;在请求头上带入traceId参数&#xff0c;穿透到下游服务. package com.by.filter;import cn.hutool.core.collection.CollUtil; import cn.hutool.core.util.IdUtil; import cn.hutool.core.util.ObjectUtil; import cn.hutool.jwt.JWTValidator;…
阅读更多...
数据结构1（初）：时间复杂度和空间复杂度

数据结构1（初）：时间复杂度和空间复杂度

目录 1、引言 1.1、什么是数据结构&#xff1f; 1.2、什么是算法&#xff1f; 1.3、如何学好数据结构和算法 &#xff1f; 2、算法效率 2.1、如何衡量一个算法的好坏 2.2、算法的复杂度 3、时间复杂度 3.1、时间复杂度的概念 3.2、大O的渐进表示法 3.3、常见时间复杂…
阅读更多...
C语言自定义类型【联合体与枚举】

C语言自定义类型【联合体与枚举】

文章目录 1.联合体1.1联合体的声明1.2联合体的特点1.3联合体的大小计算联合体的使用案例 2.枚举2.1枚举类型的声明2.2枚举类型的优点(为什么使用枚举)2.3枚举类型的使用 结语 1.联合体 1.1联合体的声明 和结构体一样&#xff0c;联合体也是由一个或多个成员构成&#xff0c;同…
阅读更多...
Atcoder Beginner Contest351 A-E Solution题解

Atcoder Beginner Contest351 A-E Solution题解

文章目录 [A - The bottom of the ninth](https://atcoder.jp/contests/abc351/tasks/abc351_a)[B - Spot the Difference ](https://atcoder.jp/contests/abc351/tasks/abc351_b)[D - Grid and Magnet](https://atcoder.jp/contests/abc351/tasks/abc351_d)E Note&#xff1a;…
阅读更多...
Rust 实战练习 - 12. Axum Web 简单demo

Rust 实战练习 - 12. Axum Web 简单demo

Rust Web 历程 Rust 的异步框架tokio非他莫属&#xff0c;而web框架一直是悬而未决&#xff0c;说到底还是因为没有官方成熟的方案指引&#xff0c;大家各玩各的&#xff0c;互不兼容&#xff0c;白白浪费精力。 这个事情一直等到半官方组织tokio推出axum有了改善。但是市场上…
阅读更多...
如何将本地Android studio项目上传到GitHub

如何将本地Android studio项目上传到GitHub

操作步骤&#xff1a; 1、在GitHub上创建账户 2、在androd studio中添加上述创建的GitHub账号 3、在android studio上找到"share project on GitHub"&#xff0c;点击此选项上传当前项目到GitHub 上传成功后&#xff0c;会在GitHub上创建默认仓库repository 注&a…
阅读更多...
mysql-sql-练习题-2-窗口函数

mysql-sql-练习题-2-窗口函数

窗口函数 访问量max sum建表窗口函数连接 直播间人数 第1、3名建表排名sum 访问量max sum 每个用户截止到每月为止&#xff0c;最大单月访问次数&#xff0c;累计到该月的总访问次数 建表 create table visit(uid1 varchar(5) comment 用户id,month1 varchar(10) comment 月…
阅读更多...
阳光能源，创造永远：光模块的未来”：随着大数据、区块链、云计算和5G的发展，光模块成为满足不断增长的数据流量需求的关键技术

阳光能源，创造永远：光模块的未来”：随着大数据、区块链、云计算和5G的发展，光模块成为满足不断增长的数据流量需求的关键技术

光模块的类型介绍&#xff1a; 为了适应不同的应用需求&#xff0c;不同参数和功能的光模块应运而生。光模块的分类方式及类型详见如下&#xff1a; &#x1f50e;封装形式&#x1f50d;&#xff1a; &#x1f4e3;&#x1f4e2;光模块按照封装形式来分有以下几种常见类型&a…
阅读更多...
声光控路灯控制系统设计与仿真

声光控路灯控制系统设计与仿真

目录 前言 一、设计任务 二、系统组成及工作原理 1、总体设计思路 2、电路各模块设计简介 &#xff08;1&#xff09;光控电路 &#xff08;2&#xff09;声控电路 (3) 逻辑控制电路 (4) 延时电路 三、系统中电源模块的设计 1、方案比较和确定 2、 设计思路 3、直流…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023