数组的相关内容

数组的作用
为什么需要数组
有时候变量太多，太繁琐了，不便于数据处理。

数组的定义：
数组是一个变量，存储相同数据类型的一组数据

数组基本要素

1. 标识符–>数组名
2. 数组元素 -->值
3. 元素下标：从0开始 （很重要）
4. 元素类型 -->类型

数组和变量的区别：
声明一个变量就是在内存空间划出一块合适的空间
声明一个数组就是在内存空间划出一串连续的空间

如何使用数组
1.声明数组 int[ ] a;
数据类型[ ] 数组名 ;

int a[];和 int []a; == >不常用

声明数组时不规定数组长度

2.分配（几个连续的）空间 a = new int[5];

1 和 2 可以结合在一起
数据类型[ ] 数组名 = new 数据类型[长度] ;
int[] a = new int[5];
new 是Java中在内存开辟空间的方式 优先级最高
new就是开辟新空间在堆中创建。
变量名a 存的是地址 指向堆。

数组元素根据类型不同，有不同的初始值

3.赋值 a [0] = 8;
当有多个赋值，可以使用如下：
方法1: 边声明边赋值

int[ ] scores = {89, 79, 76};//静态初始化
int[ ] scores = new int[3];//动态初始化
int[ ] scores = new int[ ]{89, 79, 76};// ==>不能指定数组长度  
//第三个 比较啰嗦，麻烦       

a[i]就是数组元素

方法2：动态地从键盘录入信息并赋值

Scanner input = new Scanner(System.in);
for(int i = 0; i < 30; i ++){
     scores[i] = input.nextInt();
}

4.处理数据 a [0] = a[0] * 10;

5.数组元素的默认初始化值

数组元素是整型：0
数组元素是浮点型：0.0
数组元素是char型：0或‘\u0000’，而非‘0’
数组元素是boolean型：false
数组元素是引用数据类型：null

遍历的两种例子：
第一种：

		//标准数组的遍历
		System.out.print("[");
		for(int i = 0;i < arr.length;i++) {
			if(i == arr.length -1 ) {
				System.out.print(arr[i] + "]");
			}else {
			System.out.print(arr[i] + ",");
			}
		}

第二种：

       //增强for遍历
		System.out.println("[|");
		for(int a:arr) {//类型   临时变量名：数组名
			System.out.println(a + "|");//a就相当于指定了每一个arr[i]
		}
		System.out.println("]");
		//[|2|4|6|8|10|]

数组的特点：
1.数组长度固定不变，避免数组越界
一旦你的元素超过了长度，虽然不会编译报错，但它会运行报错。

java.lang.ArrayIndexOutOfBoundsException

2.数组中的所有元素必须属于相同的数据类型

有一种特殊，就是 object 类型，那就是都包括。

3.int[] b = {1,2,3,4};
System.out.println(b);//输出的是地址

数组与内存：
数组里面也是有地址的，但往往不看，特别是基本数据类型，根本看不到。
栈相当于箱子，先进后厨，相当于书的目录或者前台，指向堆在里面快速找到内存 ，里面有地址，也就是值，如书的内容详细 ，所住的酒店。

常见错误：

1. 编译出错，没有写明数组的大小，如

int[ ] score = new int[ ];

2. 运行出错，数组越界
3. 编译出错，创建数组并赋值的方式必须在一条语句中完成，如

int[ ] score = new int[5];
score = {60, 80, 90, 70, 85};

int[ ] score2;
score2 = {60, 80, 90, 70, 85}; 

常用操作

1. 获取最大 最小值
   数组的求最大值步骤：
   1.声明一个数组a
   2.声明 int max = a[0],把值作为第一个
   3.然后与接下来的一 一比对，如果当max<a[i]
   4.则进行交换max=a[i]
   5.输出

2. 数字排序 （后面有）

3. 插入数字
   数组插入元素的步骤
   1.对b进行扩容
   2.把b[i] = a[i]，获取值，然后进行遍历
   3.声明一个数sum
   4.把sum与其他值进行比较
   sum跟前一个比较，如果sum大，那么另一个数就后移一格
   sum跟前一个比较时，如果sum小，那么sum才后移一格
   b[0]=num，当第一个的时候，就是sum最大。
   5.遍历

掌握冒泡排序算法
了解选择排序，插入排序，快速排序

冒泡排序：
如何实现数字升序排序？
使用二重循环实现冒泡排序
每次比较相邻两数，小的交换到前面
每轮结束后最大的数交换到最后。

import java.util.Arrays;
//演示冒泡排序
public class Sort1 {
	public static void main(String[] args) {
		int[] a= {29,7,14,27,5,8,12};         
		//要进行冒泡排序，需要从前向后遍历
		//遍历的过程中要不断的比较相邻两个值
		//不满足顺序的要交换位置
		for(int i =0;i<a.length-1;i++) {
		//外层循环控制轮数
			boolean isSorted = true;
			for(int j =0;j<a.length-1-i; j++) {
			//内层循环,控制每轮比较多少次		                               
				if(a[j]>a[j+1]) {              
					//交换数据
					int tmp= a[j];
	 				a[j] = a[j+1];
					a[j+1]=tmp;
					isSorted = false;
				}
			}
			if(isSorted) {//如果这一轮都没有交换，则认为已经有序
				break;
			}
		}			
		System.out.println(Arrays.toString(a));//遍历
	}
}

可以用一句话概括 ：
使用Arrays为数组排序
import java.util.Arrays;
//java.util包提供的工具类
//Arrays类提供操作数组的方法，如：排序、查询
Arrays.sort(数组名); // 升序
Arrays类的sort()方法: 对数组进行升序排列

Arrays类:使用Arrays类的各种方法

都需要导包 =》import java.util.Arrays;

Arrays.equals(a, b):比较的是里面的内容是不是相等

int[] a = {1,8,3,6,5,2};
int[] b = {1,8,3,6,5,2};
System.out.println(a);
System.out.println(b);
System.out.println(a == b);//比较的是内容和地址值 false
System.out.println(Arrays.equals(a, b));//true

Arrays.sort(a):升序排列

Arrays.toString(a):遍历 == >遍历的快捷方法

Arrays.fill(a,8):填充

int[] c = new int[4];
Arrays.fill(c, 8);
System.out.println(Arrays.toString(c));//[8, 8, 8, 8]

Arrays.copyOf(c，3):来选取固定长度，增加默认值或减少

int[] c = {2,5,7,4};
int[] d = Arrays.copyOf(c, 3);
System.out.println(Arrays.toString(d));//[2, 5, 7]

Arrays.copyOfRange(a,1,2):选取某个范围的数值

第二个参数表示开始(取得到) ,第三个参数表示结束(取不到)

int[] a = {1,8,3,5,9};
int[] f = Arrays.copyOfRange(a,0,3);//下标 左闭右开
System.out.println(Arrays.toString(f));//[1, 8, 3]

Arrays.binarySearch(a,1):查询某个元素在数组的下标

多维数组

1. 三维及以上的数组很少使用
2. 主要使用二维数组
3. 从语法上Java支持多维数组
4. 从内存分配原理的角度讲，只有一维数组

二维数组定义
二维数组实际上是一个以一维数组做为元素的一维数组
本质上是一维数组，元素为一维数组

<数据类型>  [ ][ ]  数组名;  
或者  
<数据类型>  数组名 [ ][ ];

定义赋值

int [ ][ ] scores;   //定义二维数组
scores=new int[5][50];  //分配内存空间
//或者
int [ ][ ] scores = new int[5][50];//动态初始化
String [ ][ ] arr = new String[5][];
int[][] scores=new int[][]{ { 90, 85, 78}, { 76, 80 }, { 87 }};//静态初始化
int scores[][] = {{ 90, 85, 78 }, { 76, 80 }, { 87 } };
int [ ][ ] scores = new int[5][];//这样也是可以 但是不能全不加数字。

二维也是对象，所以里面的元素类型要统一，
也不会默认转换，必须是一样的类型。

二维遍历

//遍历二维数组，获取其中的一维数组
for(int i=0;i<arr.length;i++) {
	//遍历每一个一维数组，获取其中的元素
	for(int j =0;j<arr[i].length;j++) { 
		System.out.println(arr[i][j] + "\t");	
	}
}

数组元素的默认初始化值（用动态方式，静态看不到有值了）
针对于初始化方式一：比如：int[][] arr = new int[4][3];
外层元素的初始值为：地址值
内层元素的初始化值为：与一维数组初始化情况相同
针对于初始化方式二：比如：int[][] arr = new int[4][];
外层元素的初始值为：null
内层元素的初始化值为：不能调用，否则报错

二维数组与内存

int[][] s =new int[3][5];

int[][] scores=new int[3][5];  
score[0][0]=90; 
score[2][3]=70;

题外话：
不一样的值
int [] a ={1，2，3，4，5，6}；
int [] b ={1，2，3，4，5，6}；
值都是一样，排序方式一样，但数组就是不一样 ，
因为地址不一样，类似对象，每个新建的对象都不一样。

源文件：用汇编语言或高级语言写出来的代码保存为文件后的结果。

Math.random()：[0,1)
Math.random()是系统随机选取大于等于 0.0 且小于 1.0 的伪随机 double 值

公式：获取[a,b]范围的随机数：（int）(Math.random() *(b-a + 1) ) + a

[10,99]
公式（int）(Math.random() *（90 -10 +1） + 10)
Math.random() : [0.0,1）
Math.random()*90 : [0.0,90.0）
（int）(Math.random() *90): [0,89]
（int）(Math.random() *90 + 10): [10,99]

Math.sqrt(double a)：
函数返回一个数的平方根。(double值）

如果参数是NaN或小于为零，那么结果是NaN.
如果参数是正无穷大，那么结果为正无穷大.
如果参数是正零或负零，那么结果是一样的参数.

Math.sqrt(9);   // 3.0
Math.sqrt(64);  // 8.0

数组出现的异常：
java.lang.ArrayIndexOutOfBoundsException
数组下标越界。

----2021.07.29&2021.07.30