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虚拟机栈的特点
- 先进后出(Firt in last out FILO),类似于子弹夹
- 栈区中的数据仅在作用域内有效，使用完毕之后立马自动释放
- 栈内的变量没有默认值，如果没有给出默认值就直接报错
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];
}
数组其实也一个变量，存储相同类型的一组数据
作用：告诉计算机数据类型是什么
特点：
- 数据类型相同
- 数组名实际上就是一个变量，既然是变量，那就必须先赋值在使用
- 数组的每一个元素既可以是基本数据类型，也可以是引用数据类型
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]);
}
注意事项：
- 标识符：数组的名称，用于区分不同的数组
- 数组元素：向数组中存放的数据
- 元素下标，从0开始，数据中的每个元素都可以通过下标来访问
- 元素类型：数组元素的数据类型
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 选择排序
选择排序原理为：随机确定一个标志位（一般为第一个数字）作为最小数，然后向后遍历，找到比标志位更小的数便与标志位互换位置并更新最小数，实现步骤为：
- 将数组的第一个数字设置为标志位最小数并记录最小数下标。
- 向后遍历，发现更小数后将该数与标志位互换位置并更新最小数与最小数下标。
- 循环完成排序
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循环对比：
- foreach循环更适合遍历数据
- foreach循环没有下标，普通for循环适合做添加，删除操作
- 本质上面foreach循环就是普通for循环
9. 可变的参数列表
可变参数列表的语法规则
参数类型 ... 变量名称
package com.bobo.array;
public class ArrayDemo05 {
/**
* 方法的形参中出现了 类型相同，个数不同的情况，这时我们可以使用 可变参数列表来实现
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.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;
}
}
可变参数的特点：
- …的位置 放在参数类型和变量名之间即可
- 可变参数列表必须出现在参数列表的最后面，而且一个方法的形参中最多只能有一个可变参数列表
- 可变参数列表本质上就是数组，既然是数组那么就可以按照数组的思路来处理
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@15db9742
System.out.println(arr[1]); //[I@6d06d69c
System.out.println(arr[2]); //[I@7852e922
//System.out.println(arr[3]); // 数组 越界
System.out.println(arr[0][0]); // 0
System.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]); // 100
System.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]); //null
System.out.println(arr[1]); //null
System.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]); // 0
System.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]); // 100
System.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();
}
}
}
二维数组遍历的规律：
- 外层循环控制一维数组的个数
- 内存循环控制每一个一维数组的元素个数
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
规则：
- n行有n列，类似于九九乘法表
- 每一行的第一列和最后一列的值为1
- 从第三行开始，除了第一列和最后一列，每个元素的值等于上一行的前一列加上上一行的本列的值之和
package com.bobo.array;
import java.util.Scanner;
public class ArrayDemo11 {
/**
* 规则：
1. n行有n列，类似于九九乘法表
2. 每一行的第一列和最后一列的值为1
3. 从第三行开始，除了第一列和最后一列，
每个元素的值等于上一行的前一列加上上一行的本列的值之和
* @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.给每一行的第一列和最后一列的值为1
for(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();
}
}
}
