4、Java数组-基础

1、数组：一组相同数据类型的数据，按照一定的顺序组合的集合。
把一组相同数据类型的变量，用统一的名称进行命名，然后又通过编号一一区别它们，这个统一的名称就是数组名，这个编号就是下标或索引。
组成数组的每一个数据就是一个元素，元素的总个数就是数组的长度。

2、容器：变量也是容器，但是只能存一个数据；数组是容器，可以存储多个数据 存储的是这块连续空间的首地址。

3、分类 一维数组：一个[] 二维数组：两个[] 多维数组：…

1、一维数组

1.1 语法

1、声明
	元素的数据类型[] 数组名;    
	或 	
	元素的数据类型 数组名[];
2、初始化
	（1）数组的长度 
	（2）元素的赋值

1.2 初始化

1.2.1 静态初始化

数组名 = new 元素的数据类型[]{元素1，元素2，。。。。}；

当声明与静态初始化在一个语句

元素的数据类型[] 数组名 = {元素1，元素2，。。。。}；

注意：静态初始化时，[]中不需要指定长度，数组的长度有{}中罗列的元素的个数决定。

1.2.2 动态初始化

数组名 = new 元素的数据类型[长度];

1、当声明与初始化在同一个语句
	元素的数据类型[] 数组名 = new 元素的数据类型[长度];
2、到这步为止，数组的元素是默认值。如果想要保存具体的值，那么需要为元素再赋值。
	（1）手动一个一个赋值
		数组名[0] = 值;
		数组名[1] = 值;
		...
	（2）循环赋值，适用于赋值规律
		for(int i=0; i<数组的长度; i++){
			数组名[i] = 值;//这个值可以是键盘输入，可以是表达式计算等
		}

1.3 初始化-数组元素的默认值：

基本数据类型：
	byte,short,int,long：0
	float,double：0.0
	char：\u0000
	boolean：false
引用数据类型：例如String
	默认值都是null

1.4 数组基本语法

数组的长度：数组名.length
数组的元素：数组名[下标]
下标的范围：[0,数组的长度-1] 一旦下标超过范围，会报异常：ArrayIndexOutOfBoundsException

1.5 遍历数组

（1）for循环
for(int i=0; i<数组的长度; i++){
	元素：数组名[i]
}

（2）foreach循环
foreach：只能用于遍历数组或集合等容器。
语法格式：（改变了和用了临时变量名称，并没有改原始数组数据）
for(元素的数据类型 临时变量元素名称 : 数组名称){
	元素名称 代表元素
}

（3） 案例
class TestForeachExer{
	public static void main(String[] args){
		String[] weeks = {"monday","tuesday","wednesday","thursday","friday","saturday","sunday"};

		for(String week : weeks){
			System.out.println(week);
		}
	}
}

（4）for和foreach的选择：
	（1）如果是显示数组的元素，在数组中查找，那么两个皆可以
	（2）如果在操作的过程中需要index下标的信息，那么只能选择for
	（3）如果想要修改数组的元素（即赋值），那么只能选择for
	（4）foreach效率更高，代码更简洁，但是没有下标信息，只适用于查看遍历数组不适用于修改元素。
	
结论：foreach可以用于查找遍历数组，但是实际开发中，foreach更多的是用于集合，
那么数组更多的选择的是for

1.6 一维数组相关算法

1.6.1 找最大值、最小值

class SuanFa1_Max{
	public static void main(String[] args){
		int[] arr = {-4,-5,-3,-7,-9,-2};
		
		int max = arr[0];
		for(int i=1; i<arr.length; i++){
			if(max < arr[i]){
				max = arr[i];
			}
		}
		System.out.println("最大值是：" + max);
	}
}

1.6.2 找最大（小）值及其下标

class SuanFa2_MaxIndex{
	public static void main(String[] args){
		int[] arr = {-4,-5,-3,-7,-9,-2};
		
		//方法一：
		/*
		int max = arr[0];
		int index = 0;
		
		for(int i=1; i<arr.length; i++){
			if(max < arr[i]){
				max = arr[i];
				index = i;
			}
		}
		System.out.println("最大值是：" + max);
		System.out.println("最大值的下标是：" + index);
		*/
		
		//方法二：
		int index = 0;
		for(int i=1; i<arr.length; i++){
			if(arr[index] < arr[i]){
				arr[index] = arr[i];
				index = i;
			}
		}
		System.out.println("最大值是：" + arr[index]);
		System.out.println("最大值的下标是：" + index);
	}
}

1.6.3 累加和和平均值

class SuanFa3_SumAvg{
	public static void main(String[] args){
		int[] arr = {3,4,5,6,7};
		
		//累加和，平均值
		double sum = 0;
		for(int i=0; i<arr.length; i++){
			sum += arr[i];
		}
		System.out.println("总和是：" + sum);
		System.out.println("平均值是：" + sum/arr.length);
	}
}

1.6.4 反转

class SuanFa3_Reverse{
	public static void main(String[] args){
		int[] arr = {3,4,5,6,7};
		 
		//交换的方式
		//(1)交换几次：arr.length/2
		//(2)谁和谁交换：首尾对应位置交换
		for(int i=0; i<arr.length/2; i++){
			//首：arr[i]
			//尾：arr[arr.length-1-i]
			
			int temp = arr[i];
			arr[i] = arr[arr.length-1-i];
			arr[arr.length-1-i] = temp;
		}
		//遍历显示
	}
}

1.6.5 普通查找

//查找
class SuanFa5_Find{
	public static void main(String[] args){
		int[] arr = {4,5,3,6,2};
		
		//查找数组中5的下标
		int find = 8;
		int index = -1;//这里不适合初始化为0，因为可能要找的数不存在
		for(int i=0; i<arr.length; i++){
			if(arr[i] == find){
				index = i;
				break;
			}
		}
		
		//这个位置才能确定没
		if(index==-1){
			System.out.println(find + "在数组中不存在");
		}else{
			System.out.println(find + "的下标是：" + index);
		}
	}
}

1.6.6 复制原数组[start]开始len个

import java.util.Scanner;

class SuanFa6_Copy3{
	public static void main(String[] args){
		int[] arr = {1,2,3,4,5};
		
		//复制原数组的一部分
		//从原数组的[start]开始复制，新数组的长度可能<,=,>原数组的长度
		Scanner input = new Scanner(System.in);
		
		System.out.print("请输入新数组的长度：");
		int length = input.nextInt();
		
		System.out.print("请输入从原数组的复制的起始下标：");
		int start = input.nextInt();
		
		//（1）先声明一个新数组，长度为length，数据类型和原数组一样
		int[] newArr = new int[length];
		
		//（2）把元素复制过去
		//注意:newArr[i-start]一定要在新数组的范围内
		//arr[i]下标一定要在旧数组的范围内
		for(int i=start; i-start<newArr.length && i<arr.length; i++){
			newArr[i-start] = arr[i];
		}
				
		//遍历显示
		System.out.println("原数组中的元素：");
		for(int i=0; i<arr.length; i++){
			System.out.println(arr[i]);
		}
		
		System.out.println("新数组中的元素：");
		for(int i=0; i<newArr.length; i++){
			System.out.println(newArr[i]);
		}
	}
}

1.6.7 冒泡排序

class SuanFa7_BubbleSort_2{
	public static void main(String[] args){
		int[] arr = {5,4,6,7,2};
		
		//轮数：数组的长度-1轮
		for(int i=1; i<arr.length; i++){//控制总轮数
			for(int j=0; j<arr.length-i; j++){
				if(arr[j] > arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		
		//显示结果：
		System.out.println("排序后：");
		for(int i=0; i<arr.length; i++){
			System.out.println(arr[i]);
		}
	}
}

2、二维数组

2.1 声明二维数组

元素的数据类型[][] 二维数组名;		//int[][] scores;//标准写法
int[] scores[];				//非标准写法
int scores[][];				//非标准写法
int[] m,n [];				//非标准写法	//m是一维数组，n是二维数组

2.2 二维数组初始化

（1）静态初始化：行数、列数、元素的值都同时确定

二维数组名 = new 元素的数据类型[][]{{元素1，元素2…},{元素1，元素2…},…};

当声明和静态初始化在同一个语句中完成：

元素的数据类型[][] 二维数组名 = {{元素1，元素2…},{元素1，元素2…},…};

（2）动态初始化1：规则，每一行的列数相同的

二维数组名 = new 元素的数据类型[总行数][每一行的总列数];

同时确定了行数，和每一行的列数，元素此时都是默认值。
可以在为元素赋值：

二维数组名[行下标][列下标] = 值;

（3）动态初始化2：不规则，每一行列数不相同（这种情况不能省略new 元素数据类型）
确定了总行数：

二维数组名 = new 元素的数据类型[总行数][];

依次确定每一行的列数（new 数据类型）不能少： 二维数组名[行下标] = new 元素的数据类型[列数];

二维数组名[行下标] = new 元素的数据类型[]{元素1，元素2…};

可以为每一个元素再赋值：

二维数组名[行下标][列下标] = 值;

2.3 二维数组的表示方式

总行数：二维数组名.length
每一行的列数：二维数组名[行下标].length
二维数组的元素：二维数组名[行下标][列下标]
行下标范围： [0, 二维数组名.length-1]
列下标范围：[0, 二维数组名[行下标].length -1 ]

2.4、遍历二维数组

（1）for循环
for(int i=0; i<二维数组名.length; i++){
	for(int j=0; j<二维数组名[i].length; j++){
		二维数组名[i][j]是元素
	}
}

（2）foreach循环
for(元素的数据类型[] 行名称 ： 二维数组名){
	for(元素的数据类型 元素 ： 行名称){
	}
}

4、内存结构图

3、foreach遍历

foreach遍历：用于数组、集合等可迭代，可遍历的容器的遍历
一维数组：
for(元素的数据类型  元素名 ： 一维数组名){
}

二维数组：
for(元素的数据类型[] 行名称 ： 二维数组名){
	for(元素的数据类型 元素 ： 行名称){
	}
}

和普通for的区别：
（1）没下标信息
（2）不能用于修改元素的值
（3）比普通for效率高，简洁

4、数组的工具类

import java.util.Arrays数组工具类。
常用的方法：
（1）Arrays.binarySearch(一维数组名，要查找的值value)：返回是下标，要求被查找的一维数组必须是有序的，否则结果是错误的,返回值说明返回num在arr数组中下标，如果num不存在，返回 (-(插入点) - 1)。
（2）Arrays.copyOf(原一维数组名，新数组的长度)：得到一个新的数组，需要接收，新数组的长度可以<,>,=原数组的长度，从原数组的[0]开始复制
（3）Arrays.copyOfRange（原一维数组名, from ,to）：得到一个新的数组，需要接收，新数组的长度可以<,>,=原数组的长度，从原数组的[from]开始复制
			from的值必须在原数组的下标范围内，to的值可以在原数组的下标范围外，新数组的长度是to - from，右边不包含！
（4）Arrays.sort(一维数组名)：实现从小到大排序，内部用快速排序
（5）Arrays.toString(一维数组名)：把一维数组的元素，拼接为一个字符串，[元素1，元素2，...]
（6）Arrays.fill(一维数组名，填充的值value)：把一维数组的每一个元素都填充为value，之前有的元素也替换，和sort一样单列一行就行，不用接收
（7）Arrays.fill（一维数组名，from，to， 填充的值value）：把一维数组的[from,to)的元素都填充为value，右边边界不包含。左右都不能越界
（8）System.arraycopy(一维数组名，复制的起始位置，目标一维数组名，粘贴过来的起始位置，复制长度)，删除下标index元素：System.arraycopy(team,index+1,team,index, length-index-1);
（9）Arrays.asList(1, 2, "hello", "world", "java"); 返回一个List集合  List<? extends Serializable>  ，只读的，不可更改了