java中一维数组、二维数组的打乱

day5

1.数组介绍

数组：存储多种数据类型的多个数。
int [ ] arr={80，76，65}

2.数组定义格式和静态初始化

静态初始化：在内存中，为数组容器开辟空间，并将元素存入空间

定义格式：

01完整格式：
数组类型【】 数组名 = new 数据类型【】{元素1，元素2，元素3…}；
02简化格式：
数组类型【】 数组名 = {元素1，元素2，元素3…};
打印数组名：

public static void main(String[] args) {
			//创建一个数组
    double [] arr1 =new double[]{11.1,11.2,11.3};

​			//元素访问：数组名【索引】即arr1[1]

​    System.out.println(arr1[1]);
​    }

​ —数组在内存中的十六进制地址值
​ @ ：分隔符
​ 【 ：当前空间是一个数组类型，一堆数组
​ [D@16b98e56

注：打印数组名：运行后得到数组在内存中十六进制地址

3.数组元素访问

格式：数组名【索引】

索引：每一个数对应的编号，从0开始，逐1增加

public static void main(String[] args) {
//创建一个数组
double [] arr1 =new double[]{11.1,11.2,11.3};

​ //元素访问：数组名【索引】即arr1[1]

​ System.out.println(arr1[1]);
​ }

4.数组遍历操作

定义：将元素取出来（打印，求和，求最大值、最小值、平均值）

01打印所有元素

public static void main(String[] args) {
 double arr[] ={11.1,22.2};
 	System.out.println(arr[0]);
 	System.out.println(arr[1]);
 }

02求偶数和

需求：已知数组元素为 {11,22,33,44,55} 请将数组中偶数元素取出并求和,最后打印求和结果

public static void main(String[] args) {
/*
	分析：
		1.静态初始化数组
		
		2.定义求和变量
		
		3.遍历数组取出每一个元素
		
		4.判断当前元素是否是偶数，是的话跟求和变量做累加操作
		
		5.打印求和变量
*/
//创建数组
int arr[]={11,22,33,44,55};
//定义求和变量
int sum =0;
//遍历循环
for (int i = 0; i < arr.length; i++) {
//条件判断
   if (arr[i]%2==0){
   //累计求和
       sum+=arr[i];
   }
}
//打印求和变量
System.out.println(sum);
}

03求最大值

需求: 从数组中找最大值

分析：
public static void main(String[] args) {
/*	
	分析：	1.假设数组中的第一个元素, 就是最大值

			2.遍历数组, 获取剩余的每一个元素, 准备进行比较(索引从1开始）

			3.在遍历的过程中, 逐个进行比较

			4.如果找到了更大的， 就让max变量, 记录更大的元素

			5.在遍历结束后, 打印max所记录的值.
*/
	
    int arr[] ={11,98,34,45,105};
    int max=arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i]>max){
            max=arr[i];
        }
    }
    System.out.println
    (max);
}

值为："+sum/arr.length);
}

04.打乱一维数组数组：

需求：已知数组内部元素为 1 ~ 9 请将数组中元素随机打乱，随后遍历打印数组

分析：

1.准备 Random 产生随机数

2.循环遍历数组, 从 0 号索引开始访问每一个位置上的元素

3.在循环中, 根据数组的长度产生随机数 – 表示随机索引位置

4.数组元素交换

5.遍历打印数组

public static void main(String[] args) {
   			 //创建一个数组
    int nums[]={1,2,3,4,5,6,7,8,9};
            //  0 1 2 3 4 5 6 7 8
            //  i
            //  index
   			 //产生随机数
    Random r=new Random();
    		//遍历
    for (int i = 0; i < nums.length ;i++) {
        //定义一个变量接收随机数
        int index = r.nextInt(nums.length);
        //打乱数组
​    int temp=nums[i];
​    nums[i]= nums [index];
​    nums[index]=temp;
}
   		 //循环遍历打印结果查看
    for (int i = 0; i < nums.length; i++) {
        System.out.println(nums[i]);
    }
}

5.数组的动态初始化

手动指定长度, 由系统分配默认初始化值。

int[] arr = new int[3];

System.out.println(arr[0]);  // 0
System.out.println(arr[1]);  // 0
System.out.println(arr[2]);  // 0

动态初始化的格式 :
*

 数据类型[]  数组名 = new 数据类型[数组的长度];
  如： double[]  Arr = new double[5];

• 不同类型的默认初始化值
  • 整数 : 0
  • 小数 : 0.0
  • 字符 : ‘\u0000’ 空白字符
  • 布尔 : false
  • 引用数据类型 : null
• 引用数据类型 :
  • 类
  • 数组
  • 接口

问题: 两种初始化的区别?

• 动态初始化 : 手动指定[长度], 系统分配默认初始化值

• 静态初始化 : 手动指定 {元素} , 系统会自动计算出该数组的长度.

两种初始化的应用场景 :

• 静态初始化 : 如果要操作的数据, 已经非常明确了, 那就直接静态初始化

需求: 统计体重, 61，62，63，64，65，66，67
		int[] arr = {61,62,63,64,65，66，67};

• 动态初始化 : 如果只明确元素个数, 不明确具体数值的时候

  需求1: 键盘录入3个整数, 并存入数组
  int[] arr = new int[3];

  需求2: 产生10个1-100之间的随机数, 并存入数组.
  int[] arr = new int[10];

注意事项 :

• 动态初始化和静态初始化不能结合使用

int[] arr = new int[3]{1，2，3};  // 错误代码

6.数组的内存图

了解：

单个数组的内存图

两个数组指向相同内存图

java的内存分配：

1. 方法区：字节码文件加载时
2. 栈：方法运行的时候所加载的内存
3. 堆：new出来的东西都进入堆内存，开辟空间所产生地址值，还有默认初始化值
4. 本地方法栈
5. 寄存器

7.数组常见问题：

数组索引越界

ArrayIndexOutOfBoundsExceptions：

原因 : 当访问了不存在的索引, 就会出现此异常

int[] arr = {11,22,33};
// arr = 0x0011;

空指针异常

NullPointerException :

原因 : 当一个引用数据类型的变量, 被赋值为null之后, 跟堆内存的地址指向就被切断了, 这时候还想访问堆内存数据

arr = null; System.out.println(arr[0]); 
// 引发空指针异常

8.二维数组

存储一维数组。

9.二维数组静态初始化

完整格式：

数据类型【】【】数组名=new 数据类型【】【】{

​					{元素1, 元素2},
​					{元素3, 元素4}

}；

如：	int[][] arr = new int[][] {
		{11,22},
		{33,44}
};

简化格式：

数据类型【】【】数组名={

​					{元素1，元素2}，

​					{元素3，元素4}

}；

	如：		int[][] arr = {
				{11,22},
				{33,44}
				};

• 二维数组的访问：

二维数组中, 存储的都是一维数组, 真正存储的是一维数组的 [地址值]
arr[0] ; 只能获取到一维数组的地址值

• 二维数组的元素访问格式:

1. 数组名[索引A][索引·B]
2. 索引A: 二维数组中的一维数组
3. 索引B: 一维数组中的具体元素

10-二维数组遍历操作

思路 : 遍历二维数组, 先获取到里面的每一个一维数组, 随后再对一维数组进行遍历, 从而获取到具体的元素

int[][] arr = {
	{11,22},
	{33,44}
};

for(int i = 0; i < arr.length; i++){
	// arr[i] : 代表的是每一个一维数组
	for(int j = 0; j < arr[i].length; j++){
		System.out.println(arr[i][j]);
	}

}

12.二维数组动态初始化

格式 :
数据类型[][] 数组名 = new 数据类型[m][n];

m : 当前二维数组可以存储多少个一维数组
n : 每一个一维数组中可以存储多少个元素

int[] arr = new int[1][2];
表示当前这个二维数组可以存储1个一维数组, 每一个一维数组中可以存储2个元素

12.二维数组内存图

存储一维数组，即一维数组的地址值。

13.打乱二维数组

分析：

• 打乱一维数组
• 动态初始化一个二维数组, 准备存储打乱之后的数据
• 将打乱后的数据, 存入二维数组当中

import java.util.Random;

public class Test1 {
    /*
        需求: 打乱二维数组

       1. 准备一维数组并打乱
          2. 准备二维数组, 准备存储打乱之后的数据
             3. 将打乱后的数据, 存入二维数组中.
                */
                public static void main(String[] args) {
                // 1. 准备一维数组并打乱
                int[] nums = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};

​    Random r = new Random();

​    for (int i = 0; i < nums.length; i++) {
​        int index = r.nextInt(nums.length);
​        // nums[i] nums[index]
​        int temp = nums[i];
​        nums[i] = nums[index];
​        nums[index] = temp;
​    }

​    // 2. 准备二维数组, 准备存储打乱之后的数据
​    int[][] arr = new int[4][4];

​    // 3. 将打乱后的数据, 存入二维数组中.
​    int a = 0;
​    for (int i = 0; i < arr.length; i++) {
​        for (int j = 0; j < arr[i].length; j++) {
​            arr[i][j] = nums[a];
​            a++;
​        }
​    }

​    // 4. 遍历二维数组并打印.
​    for (int i = 0; i < arr.length; i++) {
​        for (int j = 0; j < arr[i].length; j++) {
​            System.out.print(arr[i][j] + "\t");
​        }
​        System.out.println();
​    }
}