Java基础----数组基础

数组(一维数组)

int a = 10;
a = 20;
String name = "张三丰";
name = "蔡徐坤";

数组的概念

数组就是用来存储一组相同数据类型元素的容器

注意:数组本身也是一种数据类型,是一种引用数据类型

详细解释:
	1.数组中单个元素的数据类型必须一致
	2.如果要想获取数组中的元素,一般是通过下标获取
	3.数组也是一种数据类型，是引用数据类型
	4.数组中元素的数据类型可以是基本数据类型,也可以是引用数据类型

数组的定义

在Java中，可以使用以下方式来定义一个数组，如下:
	元素的数据类型[] 数组名 = new 元素的数据类型[数组的长度或者叫做数组的容量];
	double[] a = new double[41];
	上述语句就相当于在内存中定义了41个double类型的变量，第一个变量的名称为a[0],第二个变量的名称为a[1].依次类推，一直到第41个变量的名称为a[40],而且这些变量的默认值都为0.0；上述语句还可以这样写:
	double[] a;
	a = new double[41];
	
	int[] i = new int[250];
	String[] str = new String[20];
	
	int[] i = new int[250];//建议使用此种方法,可读性高
	int a[] = new int[25];

数组的初始化

静态初始化

在数组的初始化时，有两种方式，一种是静态的初始化，另一种是动态初始化
	静态初始化就是在定义数组的同时为数组中的每一个元素赋值，数组的静态初始化有两种方式，具体格式如下：
		1.元素的数据类型[] 数组名 = {元素1,元素2,....};//建议使用此种方式
		2.元素的数据类型[] 数组名 = new 元素的数据类型[] {元素1,元素2,....};
//静态初始化
		int[] ar = {10,20,30,250};//声明了一个整数类型的数组,名为ar,其中有四个元素,分别为10,20,30,250,建议使用此方法
		int[] ar1 = new int[] {10,20,30,250};//声明了一个整数类型的数组,名为ar1,其中有四个元素,分别为10,20,30,250

动态初始化

 在定义数组时,数组就有了默认的值
int		0
double	0.0
boolean	false
引用类型	null
String[] str = new String[3];//{null,null,null}
如果在使用数组时,不想使用这些默认值,也可以显示位数组中的元素赋值
在定义数组时只指定数组的长度，由系统自动位元素赋初始值的方式叫动态初始化
格式: 元素的数据类型[] 数组名 = new 元素的数据类型[数组的长度]
	 数组名[第n个元素] = 数据类型的值
//动态初始化
	int[] arr = new int[3];//[0,0,0]
	arr[0] = 10;//将10赋值给数组arr中的第一个元素[10,0,0]
	arr[2] = 20;//将20赋值给数组arr中的第三个元素[10,0,20]

什么时候使用静态初始化，什么时候使用动态初始化:
	当我们事先知道需要存储哪一些数据的时候，选用静态初始化
	当我们事先不知道需要存储哪一些数据的时候，选用动态初始化

数组的访问

数组的访问就要通过索引(下标)去访问数组中的元素

特别注意:数组中的索引(下标)都是从0开始

通过索引(下标)取值
int[] arr = new int[3];
int set = arr[0];//获取数组arr中第一个元素的值，赋值给set
int[] x = arr[1];
int[] y = arr[2];
int[] z = arr[3];//编译正确，运行异常(数组下标越界异常)

数组中下标的最大值位数组的长度减1

数组的长度可以通过数组名.length来获取该数组的最大长度(该数组中最多能存多少个元素)

//获取数组arr中的长度
	int length = arr.length;
	System.out.println("arr中最大长度为:" + length);

数组一旦定义,长度是不可以改变的,若要改变,则必须扩容或者复制到新的数组中

数组的基本操作

1.数组的基本操作:
	获取元素:	元素类型 变量 = 数组名[index];
	设置元素:	数组名[index]= 值;
	数组长度:	int len = 数组名.length;length是属性,不是方法
	索引范围:	从0开始,逐一递增	[0,数组名.length-1]

2.操作数组常见异常:
	1)：NullPointerException:空指针异常(空引用)
        当数组还未初始化，就直接操作数组
     String[]bs = null;
	 System.out.println(bs.length);
	2）：ArrayIndexOutOfBoundsException:数组的索引越界异常

数组的遍历

//案例:随机点名
		String[] names = {"张三丰","蔡徐坤","徐Dragon","大碗宽面","梅超风"};
		String name = names[(int)(Math.random()*5)];
		System.out.println(name);
		System.out.println("--------------------");
		//数组的遍历
		for(int z= 0;z<names.length;z++) {
			System.out.println(names[z]);
		}

forEach循环称为新型for循环，增强for循环，是在JDK1.5新增，用于数组或集合的遍历

	int[] arr = new int[3];//[0,0,0]
	arr[0] = 10;//将10赋值给数组arr中的第一个元素[10,0,0]
	arr[2] = 20;//将20赋值给数组arr中的第三个元素[10,0,20]
	//使用forEach遍历
	/*forEach的语法
		for(数组或集合中元素的数据类型 元素的变量名 ： 需要遍历的数组或者集合){
			对元素进行操作
		}
	*/
    for(int a : arr){
		System.out.println(a);
    }

数组的扩容与复制

int[] arr = {10,20,30};
//在此数组中添加一个元素40
源数组名 = Arrays.copyOf(源数组名，扩容后的长度)
    
		System.arraycopy(arr0,index,arr1,enindex,size)
		 * arr0:源数组
		 * index:从源数组指定下标开始复制
		 * arr1:目标数组
		 * enindex:从目标数组指定下标开始存放
		 * size:复制的总元素个数

		// 源数组
		int[] arr = { 10, 20, 30 };
		// 要在该数组中添加一个元素
		// 创建一个新的数组,比源数组的长度大(需要添加多少个元素就比源数组的长度大多少)
		int[] arr1 = new int[arr.length + 1];
		// 将源数组中的元素赋值到新数组中
		int index = 0;
//		for (int i : arr) {
//			arr1[index] = i;
//			index++;
//		}
		// 普通for循环遍历
		for (int i = 0; i < arr.length; i++) {
			arr1[i] = arr[i];
		}
		// 在新数组的最后一个位置上添加一个元素40
		arr1[arr1.length - 1] = 40;
		// 遍历新数组
		for (int a : arr1) {
			System.out.print(a + " ");
		}
		// 将新数组的地址赋值给源数组
		arr = arr1;
		// 将新数组的变量赋值为null,其目的就是为了释放内存资源
		arr1 = null;
		for (int a : arr) {
			System.out.print(a + " ");
		}

源数组名 = Arrays.copyOf(源数组名，扩容后的长度)

	// 源数组
    int[] arr = { 10, 20, 30 };
    //数组的扩容
	arr = Arrays.copyOf(arr, arr.length + 1);
    System.out.println(arr.length);
    for (int i : arr) {
        System.out.print(i + " ");
    }

//源数组
int[] arr = {10,20,30,40,50};
//需要将20，30，40这三个元素复制到新的数组中，并从新数组的第二位开始存放
int[] arr1 = {0,20,30,40,0,0};

二维数组

int[] score = {90,80,70,95};
int[][] scores = {{90,80,70,95},{90,90,70,60,100},{90,80,80,80}};
//上面代码一旦执行就定义了一个二维数组，其中有三个元素，每个元素分别为{90,80,70,95}、{90,90,70,60,100}、{90,80,80,80}

int[] arr = new int[5];
int[][] arr = new int[m][n];//m表示二维数组中有多少个一维数组、n表示每个一维数组中有多少个元素

int[] a = new int[]{10,20,30};
int[][] a1 = new int[][]{{10,20},{20,40}};

int[][] arr1 = new int[3][2];//{{0,0},{0,0},{0,0}}
//表示定义了一个二维数组名为arr1，其中有三个元素，每个元素都是一个数组，而每个一维数组中又有两个元素
//第一个元素名为arr1[0],只是该元素也是一个数组
//访问第一个元素中的第二个元素
int i = arr1[0][1]
//赋值
arr1[2][0]=10;

int y = arr1[0][2];//运行错误，索引越界异常

int[][] arr2 = new int[3][2];//{{0,0}{0,0}{0,0}}
//上面一句执行后实际上就是定义了3*2的二维数组，即二维数组的长度为3，二维数组中每个元素又是一个长度为2的数组

int[][] arr3 = new int[3][];//{{},{},{}} 3代表有3个数组,只是每个一维数组有多少个元素还没有被定义

二维数组的访问与遍历

对二维数组的访问也是通过下标的方式访问，例如需要访问二维数组中第一个元素的第二个元素，
则使用
arr[0][1//0表示该二维数组中下标为0的元素，1表示一维数组中下表为1的元素

二维数组总结

二维数组:
	它是一个用来装一组数组类型元素的容器,本质上还是一个数组,只是数组中的元素也是数组
	特点:二维数组中的每一个元素都是一堆数组
	格式:
		1):
			元素的数据类型[][] 数组名 = new 元素的数据类型[m][n];
			m:代表二维数组中一维数组的个数
			n:代表每个一维数组中元素的个数
		2):
			元素的数据类型[][] 数组名 = new 元素的数据类型[m][];
			m:代表二维数组中一维数组的个数
			每一个一维数组中元素的个数不确定,需要通过赋值来确定长度
		3):
			元素的数据类型[][] 数组名 = {{元素1,元素2,....},{元素1,元素2,....},{元素1,元素2,....}};
		4):
			元素的数据类型[][] 数组名 = new 元素的数据类型[][]{{元素1,元素2,....},{元素1,元素2,...}	,{元素1,元素2,....}};

要统计一个公司三个销售小组的销售金额以及全公司的总销售金额
第一小组销售金额为(11,12)万元
第二小组销售金额为(20,21,23)万元
第三小组销售金额为(30,31,32,33)万元

Arrays工具类

1.二分法查询:
1）int binarySearch(type[] a, type key)
	a --> 数组名
	key --> 查询元素值
2）int binarySearch(type[] a, int fromIndex, int toIndex, type key)
	fromIndex --> 开始索引
	toIndex --> 结束索引
"使用要求:数组已排好序"
2.复制:
1）type[] copyOf(type[] original, int length)
	original --> 源数组名 
	length --> 新数组长度
	若新数组长度小于源数组长度,新数组元素为源数组length个元素
	若新数组长度大于源数组长度,大于部分补充0(基本数据类型)，false(布尔类型),null(引用数据类型)
2）type[] copyOfRange(type[] original, int from, int to)
	from --> 开始索引
	to --> 结束索引
3.比较元素:
	boolean equals(type[] a, type[] a2)
	如果数组a长度与元素跟a2一样,则返回true
4.赋值:
1）void fill(type[] a, type val)
 	a数组的所有元素都赋值为 val
2）void fill(type[] a, int fromIndex, int toIndex, type val)
	fromIndex --> 开始索引
	toIndex --> 结束索引
	赋值给val
5.排序:
1):void sort(type[] a)
    
2）void sort(type[] a, int fromIndex, int toIndex)
	对fromIndex到toIndex 索引的元素进行排序。
6.数组转成字符串:
10）String toString(type[] a)
	该方法按顺序把多个数组元素连缀在一起，多个数组元素使用英文逗号,和空格隔开。

import java.util.Arrays;

public class ArraysTest {
	public static void main(String[] args) {
		int[] arr = {6,3,7,9,4,1,10};
		//排序
		//1):sort
		Arrays.sort(arr);
		//2):parallelSort(Java8支持)
		Arrays.parallelSort(arr);
		for (int i : arr) {
			System.out.print(i +" ");
		}
		System.out.println("-----------");
		//二分法查询(返回该元素所在的下标)
		int a = Arrays.binarySearch(arr, 6);
		System.out.println(a);
		//复制
		int[] arr1 = Arrays.copyOf(arr, arr.length);
		for (int i : arr1) {
			System.out.print(i+" ");
		}
		System.out.println("**********");
		//比较元素
		System.out.println(Arrays.equals(arr, arr1));
//		//赋值
//		int b = 0;
//		Arrays.fill(arr, b);
//		System.out.println(b);
		//数组转成字符串
		System.out.println(Arrays.toString(arr));
	}
}