开始每日一更！得加快速度了！

数组

数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型，即：数组就是一组数据

例子

一个养鸡场有6只鸡，它们的体重分别是3kg，5kg，1kg，3.4kg，2kg，50kg。请问这六只鸡的总体重是多少?平均体重是多少？

数组的使用

1. 使用方式1-动态初始化

   • 数组的定义

   ​ 数组类型 数组名[] = new 数据类型[大小]

   ​ (也可以)数组类型[] 数组名 = new 数据类型[大小]

   ​ int a[] = new int[5]; //创建了一个数组，名字为a，存放5个int

   ​ 说明：这是定义数组的一种方法

   • 数组的引用（使用）

     数组名[下标/索引] 比如：你要使用a数组的第3个数 a[2]

     数组的下标从0开始

     //第1种动态分配方式
     double scores[] = new double[5];
     

     例子：循环输入5个成绩，保存到double数组，并输出

2. 使用方式2-动态初始化

   • 先声明数组

     语法：数据类型 数组名[]；也可以 数据类型[] 数组名；

     int a[]; 或者 int[] a;

   • 创建数组

     语法：数组名=new 数据类型[大小]

     a=new int[10];

     //第2种动态分配方式
     //先声明数组，再 new 分配空间
     double scores[];//声明数组，这时 scores 是 null
     scores = new double[5];//分配内存空间，可以存放数据
     

3. 使用方式3-静态初始化

   • 初始化数组

     语法：数据类型 数组名[] = {元素值,元素值…}

     int a[] = {2,5,6,7,8,89,90,34,56}, 如果知道数组有多少元素，具体值

     上面的用法相当于：int a[ ] = new int[9];

     ​ a[0] = 2; a[1] = 5; a[2] = 6; a[3] = 7; a[4] = 8;

     ​ a[5] = 89; a[6] = 90; a[7] = 34; a[8] = 56;

数组的注意事项和细节

1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理

2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用

3. 数组创建后，如果没有赋值，有默认值；int 0, short 0, byte 0, long 0, float 0.0, double 0.0, char \u0000, boolean false, String null

4. 使用数组的步骤（1）声明数组并开辟空间（2）给数组各个元素赋值（3）使用数组

5. 数组的下标是从0开始的

6. 数组的下标必须在指定范围内使用，否则报：下标越界异常

7. 数组属引用类型，数组型数据是对象

练习

1. 创建一个char类型的26个元素的数组，分别放置 ‘A’ - ‘Z’.使用for循环访问所有元素并打印出来。提示：char类型数据运算’A’ + 1 -> ‘B’

2. 请求出一个数组int[]的最大值{4，-1，9，10，23}，并得到对应的下标

数组赋值机制

1. 基本数据类型赋值，这个值就是具体的数据，而且互相不影响。

2. 数组在默认情况下是引用传递，赋的值是地址。

数组拷贝

• 编写代码 实现数组拷贝（内容复制）：将 int[] arr1 = {10,20,30};拷贝到arr2数组，要求数据空间是独立的

数组反转

• 把数组的元素内容反转：arr{11,22,33,44,55,66} → {66,55,44,33,22,11}

  方式1：通过找规律反转

  方式2：使用逆序赋值的方式

  

数组添加

• 实现动态的给数组添加元素效果，实现对数组扩容
  • 原始数组使用静态分配 int[] arr = {1,2,3}
  • 增加的元素，直接放在数组的最后 arr = {1,2,3,4} arrNew = {1,2,3,4}
  • 用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n

排序

排序是将多个数据，依指定的顺序进行排列的过程。

1. 内部排序

   将需要处理的所有数据都加载到内部存储器中进行排序。包括（交换式排序法、选择式排序法和插入式排序法）

2. 外部排序

   数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括（合并排序法和直接合并排序法）

冒泡排序

• 通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒。

• 
  冒泡排序的特点：

  • 一共有5个元素

  • 一共进行了4轮排序，可以看成是外层循环

  • 每1轮排序可以确定一个数的位置，比如第1轮排序确定最大数，第2轮排序确定第2大的数的位置，依次类推

  • 当进行比较时，如果前面的数大于后面的数，就交换

  • 每轮比较在减少4 ->3 -> 2 -> 1

    

查找

1. 顺序查找

   • 有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王猜数游戏：从键盘中任意输入一个名称，判断数列中是否包含名称 要求：如果找到了，就提示找到，并给出下标值

2. 二分查找（二分法，放在后面的算法中讲解）

多维数组 - 二维数组

• 二维数组的应用场景：比如开发一个五子棋游戏，棋盘就是需要二维数组来表示

二维数组的使用

• 使用方式1：动态初始化

  • 语法：类型[][] [] [] 数组名 = new 类型[大小] [大小] //第一个大小表示它包含几个一维数组，第二个大小表示每一个一维数组它的大小是多少

  • 比如：int a[] [] = new int[2] [3]

  • 使用演示

  • 二维数组在内存的存在形式

• 使用方式2：动态初始化

  • 先声明：类型 数组名[] [] ;

  • 再定义（开辟空间）数组名 = new 类型 [大小] [大小]

    int arr[][];//声明二维数组
    arr = new int[2][3];//再开空间
    

  • 赋值（有默认值，比如int 类型的就是0）

  • 使用演示

• 使用方式3：动态初始化 - 列数不确定

  

  

• 使用方式4：静态初始化

  • 定义 类型 数组名[] [] = {{值1, 值2 …}, {值1, 值2 …}, {值1, 值2 …}}

  • 使用即可 [固定方式访问]

    int[][] arr = {{1,1,1},{8,8,9},100};
    //1.定义了一个二维数组arr
    //2.arr有三个元素（每个元素都是一维数组）
    //3.第一个一维数组有3个元素，第二个一维数组有3个元素，第三个一维数组有1个元素
    

二维数组的遍历

• 例子：int arr[] [] = {{4,6},{1,4,5,7},{-2}};遍历该二维数组，并得到和

杨辉三角

• 第一行有1个元素，第n行有n个元素

• 每一行的第一个元素和最后一个元素都是1

• 从第三行开始，对于非第一个元素和最后一个元素的元素的值,arr[i] [j]

  arr[i] [j] = arr[i-1] [j] + arr[i-1] [j-1]

  

二维数组的使用细节和注意事项

1. 一维数组的声明方式有：

   int[] x 或者 int x[]
   

2. 二维数组的声明方式有：

   int[][] y 或者 int[] y[] 或者 int y[][]
   

3. 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。比如：map[] []是一个二维数组，map[] [] = {{1,2},{3,4,5}}，由map[0]是一个含有两个元素的一维数组，map[1]是一个含有三个元素的一维数组构成，我们也称为列数不等的二维数组。

练习

1. 

2.

A. 错误，char -> String

B. 正确

C. 把 new String去掉就对了

D. 正确

E. 错误 new String[]里面不能有具体的数字

3. 

bar[0]默认false，bar[1]也是false，所以最后结果是blue

4. 

结果是1 3 5 7

5. 

6. 

public class lianxierweishuzu{
	public static void main(String[] args){
		int[] arr = new int[10];
		//(int)(Math.random() * 100) + 1 生产 随机数 1-100
		for(int i = 0; i < arr.length; i ++){
			arr[i] = (int)(Math.random() * 100) + 1;
		}

		System.out.println("===arr的元素情况===");
		for(int i = 0; i < arr.length; i ++){
			System.out.print(arr[i] + "\t");
		}

		System.out.println("\n===arr的元素情况(倒序)===");
		for(int i = arr.length - 1; i >= 0; i --){
			System.out.print(arr[i] + "\t");
		}

		double sum = arr[0];
		int max = arr[0];
		int maxIndex = 0;
		for(int i = 1; i < arr.length; i ++){
			sum += arr[i];//累积和

			if(max < arr[i]){//说明max不是最大值，就变化
				max = arr[i];
				maxIndex = i;
			}
		}
		System.out.println("\nmax=" + max + " maxIndex=" + maxIndex);
		System.out.println("\n平均值=" + (sum / arr.length));

		//查找数组中是否有8 -> 使用顺序查找
		int findNum = 8;
		int index = -1;//如果找到，就把下标记录到index
		for(int i = 0; i < arr.length; i ++){
			if(findNum == arr[i]){
				System.out.println("找到数" + findNum + " 下标=" + i);
				index = i;
				break;
			}
		}
		if(index == -1){
			System.out.println("没有找到数" + findNum);
		}
	}
}

7. 

最后结果：a a

​ z z

​ 韩 韩

​ c c

8.