【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 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;
	}

}

可变参数的特点：

  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@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();
		}
		
	}
}

二维数组遍历的规律：

  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. 每一行的第一列和最后一列的值为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();
		}
	}

}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

从业务经营到企业战略，构建制药企业数字化应用新能力

从业务经营到企业战略，构建制药企业数字化应用新能力

我国医药的消费正处在一个高速增长的阶段&#xff0c;人口增长、老龄化加剧、经济总体增长、人均消费增长、农村收入提高&#xff0c;这五大因素是医药市场蓬勃发展的动力。在这五大因素的驱动下&#xff0c;我国的医药市场需求将会在未来相当长的时间内保持高速增长。从多个环…
阅读更多...
神经网络：手写数字图像识别

神经网络：手写数字图像识别

一、导入相关库函数 import matplotlib.pyplot as plt import tensorflow as tf import keras import numpy as np 二、载入mnist数据集 使用keras.中的mnist数据集 (train_images, train_labels), (test_images, test_labels)\ keras.datasets.mnist.load_data() 三、测…
阅读更多...
在微信上卖化妆品怎样发圈（学会写朋友圈段子卖货很简单）

在微信上卖化妆品怎样发圈（学会写朋友圈段子卖货很简单）

大家好&#xff0c;我是只说人话&#xff0c;不讲概念&#xff0c;专给创业者们开思维脑洞 今天咱们要分享的内容比较有趣&#xff0c;教你如何写段子故事在朋友圈里做促销活动。 首先我们来看一个硬蹭明星热点的朋友圈案例。发朋友圈的是一位做装修的&#xff0c;在明星结婚的…
阅读更多...
Python AI库 Pandas的常见操作的扩展知识

Python AI库 Pandas的常见操作的扩展知识

Python AI库 Pandas的常见操作的扩展知识 本文默认读者具备以下技能&#xff1a; 熟悉python基础知识&#xff0c;vscode或其它编辑工具 熟悉表格文件的基本操作 具备自主扩展学习能力 前文中对Pandas的数据结构以及基础操作做了介绍,本文中会在前文的基础上,对常见的操作进…
阅读更多...
Python自动化系统6

Python自动化系统6

元素的特征:根据页面设计规则&#xff0c;有些特征是唯一 开发遵循了这个规则 id :类比身份证号―仅限于当前页面 username username 注意:如果id 不是固定的话&#xff0c;就不能使用来定位! xpath: 1、绝对路径&#xff1a;/html/body/div/div/div[1]/a/b --根节点&#xff…
阅读更多...
2024公共管理与社会发展国际学术会议(ICPMSD 2024)

2024公共管理与社会发展国际学术会议(ICPMSD 2024)

2024公共管理与社会发展国际学术会议(ICPMSD 2024) 2024 International Conference on Public Management and Social Development 一、【会议简介】 2024公共管理与社会发展国际学术会议&#xff0c;将汇集全球顶尖学者&#xff0c;展开一场学术盛宴。 在这次会议上&#xff0…
阅读更多...
【UE C++】设置游戏模式

【UE C++】设置游戏模式

问题 我们都知道如何使用蓝图创建一个游戏模式并且在这个游戏模式蓝图中去设置“默认pawn类”、“HUD类”、“玩家控制器类”、“游戏状态类”、“玩家状态类”、“旁观者类”。那么如何使用C完成该操作呢&#xff1f; 步骤 1. 首先创建“GameMode”、“GameState”、“HUD”…
阅读更多...
如何用二维码实现现代仓库管理？

如何用二维码实现现代仓库管理？

随着科技的进步&#xff0c;二维码技术逐渐应用与各个领域&#xff0c;其中在仓库管理中的应用也日益广泛。 那话不多说&#xff0c;我们直接来看如何用二维码实现现代仓库管理 简道云仓库管理模板&#xff0c;可以点击安装配合阅读&#xff1a;https://www.jiandaoyun.com 二…
阅读更多...
Oracle集群ORA-03113:end-of-file on communication channel

Oracle集群ORA-03113:end-of-file on communication channel

一、问题场景描述 今天Oracle集群要更新各数据库的数据&#xff0c;折腾的启动不了了&#xff1a; --》数据量比较大&#xff0c;数据泵方式导出的dmp文件 准备导入集群 --》由于之前的生产数据库数据比较少&#xff0c;需要增大表空间。 --》于是在sqlplus命令窗口&#xff0c…
阅读更多...
暗区突围端游海外版|暗区突围免费加速器有吗 免费加速器推荐

暗区突围端游海外版|暗区突围免费加速器有吗 免费加速器推荐

游戏中玩家可以创建男性或女性角色&#xff0c;可以通过选择脸型、发型、发色对人物形象进行调整&#xff1b;在进入游戏后&#xff0c;除人物性别不能修改&#xff0c;脸型、发型、发色都可以进行调整。除此之外可以在衣橱中对角色的上衣、手套、裤子、鞋子、帽子进行更换。游…
阅读更多...
Leetcode—1017. 负二进制转换【中等】（string列表初始化、反向迭代器）

Leetcode—1017. 负二进制转换【中等】（string列表初始化、反向迭代器）

2024每日刷题&#xff08;120&#xff09; Leetcode—1017. 负二进制转换 实现代码 class Solution { public:string baseNeg2(int n) {string ans;while(n ! 0) {ans to_string(n & 1);n -(n >> 1);}return ans.empty() ? "0": string{ans.rbegin(),…
阅读更多...
R语言详解二

R语言详解二

一&#xff0c;列表详解 创建一个列表 > myList<-list(id2,name"张三",age20) > myList $id [1] 2$name [1] "张三"$age [1] 20 获取第一个元素 > myList[[2]] [1] "张三" 获取第一个子列表 > myList[2] $name [1] "张…
阅读更多...
百度 测试|测试开发 面试真题|面经 汇总

百度 测试|测试开发 面试真题|面经 汇总

百度测开 开发测试工程师 提前批一二三面面经 事业群&#xff1a;MEG base&#xff1a;北京 一面&#xff1a;2023.8.12 时长&#xff1a;50min 自我介绍 个人项目&#xff0c;我的项目是围绕着学校课程的项目来的&#xff0c;面试官就让我介绍这门课讲了些什么 &#xff…
阅读更多...
信息化项目总体计划书（Word）

信息化项目总体计划书（Word）

项目开发计划包括项目描述、项目组织、成本预算、人力资源估算、设备资源计划、沟通计划、采购计划、风险计划、项目过程定义及项目的进度安排和里程碑、质量计划、数据管理计划、度量和分析计划、监控计划和培训计划等。 软件全套精华资料包清单部分文件列表&#xff1a; 工作…
阅读更多...
03-JAVA设计模式-模板方法模式

03-JAVA设计模式-模板方法模式

模板方法模式 什么是模板方法 模板方法模式&#xff08;Template Method Pattern&#xff09;在Java中是一种行为型设计模式&#xff0c;它定义了一个操作中的算法骨架&#xff0c;而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重新定义该算法的某…
阅读更多...
7-34 通讯录的录入与显示

7-34 通讯录的录入与显示

题目链接&#xff1a;7-34 通讯录的录入与显示 一. 题目 1. 题目 2. 输入输出格式 3. 输入输出样例 4. 限制 二、代码 1. 代码实现 #include <iostream> using namespace std;// 单条记录的信息 class infoContext { private:char name[11];char date[11];char man;c…
阅读更多...
七、OSPF特殊区域及其特性

七、OSPF特殊区域及其特性

目录 OSPF区域分类 hello报文中option字段 1.末节区域&#xff08;Stub区域&#xff09; 2.完全末节区域&#xff08;Toally Stub区域&#xff09; 3.七类LSA 4.非完全末节区域&#xff08;NSSA区域&#xff09; 5.完全非完全末节区域&#xff08;Toally NSSA区域&#…
阅读更多...
计算机服务器中了helper勒索病毒怎么办，helper勒索病毒解密流程工具

计算机服务器中了helper勒索病毒怎么办，helper勒索病毒解密流程工具

在网络技术飞速发展的今天&#xff0c;越来越多的企业离不开网络&#xff0c;网络可以为企业带来更高的生产效率&#xff0c;提供更多的便捷服务&#xff0c;但网络是一把双刃剑&#xff0c;在为人们提供便利的同时&#xff0c;也为企业的数据安全带来严重威胁。近日&#xff0…
阅读更多...
微服务架构与SOA架构

微服务架构与SOA架构

SOA架构和微服务架构的区别 SOA关注的是服务重用&#xff0c;微服务在关注服务重用的同时&#xff0c;也同时关注快速交付&#xff1b; 微服务架构 80%的SOA服务架构思想 100%的组件化架构思想 80%的领域建模思想 首先SOA和微服务架构一个层面的东西&#xff0c;而对于ESB和…
阅读更多...
Python_AI库 Numpy常用的统计函数介绍

Python_AI库 Numpy常用的统计函数介绍

Python_AI库 Numpy常用的统计函数介绍 本文默认读者具备以下技能&#xff1a; 熟悉python基础知识&#xff0c;vscode或其它编辑工具 熟悉表格文件的基本操作 具备基本的高等数学常识,能看得懂矩阵运算 具备自主扩展学习能力 本文涉及的函数主要包含&#xff1a; np.sum(arr…
阅读更多...
最新文章

Copyright @ 2022~2023