Java的数组

数组。

数组引入和定义
int
char

数组：是一种数据类型符号为[].这种数据类型可以保存一组数，是一组数的集合。这一组数数据的类型必须是相同的。

数组的定义：
定义变量：
int age = 10;
定义数组：
int[] ages = new int[10];
int[] ages;
ages = new int[10];

语法：
数组元素类型[] 数组名 = new 数组元素类型[元素个数];

每个元素都是一个变量。如何访问每一个元素：数组名[元素的序号]
元素的序号从0开始，0序的。最大的序号 是 【个数-1】

小练习

需求：10个学生，有各自的成绩。score [60-100] 求这十个学生的平均成绩和总成绩。

static void testArray(){
		int avg = 0,sum = 0;
		//定义数组，10个int 类型的数据空间
		int[] scores = new int[10];
		//给每一个数组的元素赋值。element
		for(int i=0;i<10;i++){
			scores[i] = getRandomNumberByRange(60,101);
			sum += scores[i];
		}
		avg = sum/10;
		
		System.out.println("avg = "+avg);
		System.out.println("sum = "+sum);
		
		for(int i=0;i<10;i++){
			System.out.println("scores["+i+"] = "+scores[i]);
		}
	}

数组的特点

关于数组的细节的内容：

1：数组里面的包含的数据的类型必须是唯一的，每一个数据被称为数组的元素 element。
2：数组元素在堆内存中连续分配。每个元素会有一个序号。称之为 下标、索引、角标。下标从0开始。0序的。 index
3：数组通过 数组名+[下标] 来访问每个元素。每个元素都可以被看作是一个普通的变量来对待。
4：数组有一个长度的属性（元素的个数）. 用 数组名.length 获得。 类型为 int。
5：数组的下标的范围 [0, 数组名.length-1] [.]点引用符。
6: 数组是一种引用数据类型，数组变量名是指向堆内存中数组元素的首地址的引用。
7：数组的长度一旦确定，就不能再更改了。
8：数组的元素的类型是java支持的任意类型。

int[] arr =new int[20];

arr[10] = 10;

连续分配的好处：
快速定位元素：元素地址 == 首地址+元素类型所占的字节数*下标。
坏处：每个数组对空间的要求都是连续的，如果没有连续的这么大的请求的空间，那么就报错了。

数组的初始化

数组的初始化分为两种：

1：动态初始化。
例子：int[] ages = new int[10];

特点：
1：动态初始化，需要显式的指定数组的元素的个数和类型。
2：使用new 关键字进行动态初始化。
3：new 关键字的作用：1：向jvm 申请内存空间 2：将申请得来的内存空间的首地址带回 赋值给 数组变量。
4：动态初始化的数组的每个元素都会被赋予默认值。
整数类型默认值：0 byte short int long char 中0 对应的字符。
浮点数默认值：0.0
布尔类型：flase。
引用数据类型的默认值： null。 是一个关键字，代表空 空指向。
5：动态初始化，声明和赋值可以分开进行。
int[] ages = null; ages = new int[10];

2：静态初始化
例子：
int[] ages = new int[]{12,23,45,56};

特点：
1：数组的长度由右边大括号中的值的个数来确定。
2：每个元素的默认值由大括号中的数值来初始化。没给大括号中的值用 逗号 分割。
3：静态初始也可以声明和赋值分开。
int[] ages; ages = new int[]{2,3,54,5};

静态初始化还有一种语法：
int[] ages = {12,4,5,5}; 糖语法。

特点：赋值和声明必须在同一行进行。不能声明和赋值分开进行。

数组定义的多种语法：
int[] ages = new int[10];
int ages[] = new int[10];
int []ages = new int[10];
int [] ages = new int[10];

数组练习题

//定义一个boolean类型的数组，动态初始化，长度随机[5-10];并打印输出数组的长度。然后对数组元素随机赋值 Random提供的nextBoolean 方法。
//遍历输出数组的元素的内容。 上述内容，在一个自定义的方法内实现。
//在写一个方法：功能要求：定义一个byte类型的数组，长度为5，静态初始化，元素的数值要求随机，范围[0-100],最后遍历输出数组的内容。

import java.util.Random;
public class TestArray1{
	
	public static void main(String[] args){
		test2();
	}
	
	static void test1(){
		Random random = new Random();
		int length = (int)(Math.random()*(11-5)+5);
		System.out.println("length = "+length);
		boolean[] bools = new boolean[length];
		
		for(int i = 0;i<bools.length;i++){
			System.out.print(bools[i]+"\t");
		}
		System.out.print("\n");
		
		for(int i = 0;i<bools.length;i++){
			bools[i] = random.nextBoolean();
			System.out.print(bools[i]+"\t");
		}
	}
	
	static void test2(){
		byte[] values = {
			getRandomNumberByRange(0,101),
			getRandomNumberByRange(0,101),
			getRandomNumberByRange(0,101),
			getRandomNumberByRange(0,101),
			getRandomNumberByRange(0,101)
		};
		for(int i=0;i<values.length;i++){
			System.out.println("values["+i+"] = "+values[i]);
		}
	}
	
	public static byte getRandomNumberByRange(int min,int max){
		byte number = (byte)(Math.random()*(max-min)+min);
		return number;
	}
	
	
}

// 1:定义一个方法，根据给定的长度，动态初始化一个int类型元素数组，然后对元素随机赋值,根据指定的区间， 返回该数组 就是返回数组变量。

// 2:通过上面的方法，得到一个数组之后，再自定一个方法，对给定的数组，求出该数组中存在内容为指定值(随机产生[10-20] 并打印输出一下)的元素的数量。
// 有多少个元素和指定的值相同，，最后输出结果。

// 3:方法要求：将指定数组元素的内容为指定值 的 索引(数组下标)全部返回。返回一个数组，数组中包含的是指定数组的元素的索引值。

public class TestArray3{
	
	public static void main(String[] args){
		int[] arr = getRandomArrayByLength(12,10,17);
		
		printArray(arr);
		
		System.out.println(getCountByTheValue(arr,12));
		
		int[] indexs = getValueIndexs(arr,15);
		
		printArray(indexs);
	}
	
	//得到指定的长度，指定元素区间的int 类型的数组
	public static int[] getRandomArrayByLength(int length,int min,int max){
		//动态初始化一个数组
		int[] temp = new int[length];
		//对数组的元素随机赋值
		for(int i=0;i<length;i++){
			temp[i] = getRandomNumberByRange(min,max);
		}
		return temp;
	}
	
	//得到指定数组，中指定值的数量
	public static int getCountByTheValue(int[] array,int value){
		int counter = 0;
		final int LEN = array.length;
		for(int i=0;i< LEN ;i++){
			if(array[i] == value){
				counter ++;
			}
		}
		return counter;
	}
	
	//得到指定的数组中的指定值的索引的集合
	public static int[] getValueIndexs(int[] array,int value){
		//先得到相同数据的个数
		int length = getCountByTheValue(array,value);
		int[] indexs = new int[length];
		//
		int index = 0;
		for(int i=0;i<array.length;i++){
			if(array[i] == value){
				indexs[index++] = i;
				// index ++;
			}
		}
		return indexs;
	}
	
	//对指定的int 类型的数组，进行打印元素内容[1,2,3,5,5,43] 
	public static void printArray(int[] array){
		System.out.print("[");
		for(int i=0;i<array.length-1;i++){
			System.out.print(array[i]+",");
		}
		System.out.print(array[array.length-1]);
		System.out.print("]\n");
	}
	
	public static byte getRandomNumberByRange(int min,int max){
		byte number = (byte)(Math.random()*(max-min)+min);
		return number;
	}
	
}

自定义方法，对与给定数组，求出最大值。

// 定义方法，求指定的数是否是 偶数

public class TestArray4{
	
	public static void main(String[] args){
		// int[] array = getRandomArrayByLength(10,10,20);
		// int max = getArrayMaxValue(array);
		// System.out.println(max);
		//System.out.println(getArrayMaxValue(getRandomArrayByLength(10,10,20)));
		int[] array = getRandomArrayByLength(2,10,20);
		changeArrayValue(array);
		printArray(array);
	}
	
	
	//求指定的数是否是偶数
	public static boolean isEven(int value){
		return value % 2 == 0;
	}
	
	//自定义方法，对与给定int数组，求出最大值。
	public static int getArrayMaxValue(int[] array){
		int max = array[0];
		final int LEN = array.length;
		//和后续的元素逐个比较，比max大，就把元素的值赋值给max
		for(int i = 1;i<LEN ;i++){
			if(max < array[i]){
				max = array[i];
			}
		}
		return max;
	}
	
	//对指定的长度为2的数组，交换该数组的两个元素的值。
	public static void changeArrayValue(int[] array){
		int temp = array[0];
		array[0] = array[1];
		array[1] = temp;
	}
	
	
	//得到指定的长度，指定元素区间的int 类型的数组
	public static int[] getRandomArrayByLength(int length,int min,int max){
		//动态初始化一个数组
		int[] temp = new int[length];
		//对数组的元素随机赋值
		for(int i=0;i<length;i++){
			temp[i] = getRandomNumberByRange(min,max);
		}
		
		printArray(temp);
		
		return temp;
	}

	//对指定的int 类型的数组，进行打印元素内容[1,2,3,5,5,43] 
	public static void printArray(int[] array){
		System.out.print("[");
		for(int i=0;i<array.length-1;i++){
			System.out.print(array[i]+",");
		}
		System.out.print(array[array.length-1]);
		System.out.print("]\n");
	}
	
	public static byte getRandomNumberByRange(int min,int max){
		byte number = (byte)(Math.random()*(max-min)+min);
		return number;
	}
	
}

增强for循环

增强的for 循环：
for-each jdk 1.5 出现的新的语法形式。
主要是针对数组、容器进行遍历访问用的。

语法：
int[] array;
for(int value : array){

}

说明：
array：是被遍历的数组 或者是 容器。
value 是每次迭代（底层完成的），value 的值就是当前下标的元素的值。

问题：value 只是数组元素值的一个副本 、拷贝。
	通过value 没有办法去修改原本的数组的元素的值。

总结：增强的for 循环，只是比基本的for 循环语法简单了。但是只能用于遍历数组或者容器。
如果想通过循环给元素赋值，或者修改元素的值，是做不到的，必须通过数组名+下标的方式访问元素去修改。

数组删除元素

删除元素 （指定下标）：
2种实现
1：直接在源数组上删除。后续的元素需要整体前移。（最后的元素不需要处理）。 最后返回数组的有效数据的个数。
2：创建一个源数组长度 减1 的新数组。将源数组中不需要删除的内容，整体迁移到新数组中。并返回新数组。

//删除元素 在源数组

public static int delElementByIndex(int[] srcArr,int delIndex){
		int count = srcArr.length - delIndex - 1;
		
		for(int i= delIndex;i<delIndex + count;i++){
			srcArr[i] = srcArr[i+1];
		}
		return srcArr.length-1;
	}

在指定的索引的位置插入元素

在指定的索引处的插入一个元素。该位置的原来的元素和后续的所有的元素整体后移。挤掉最后一个元素
1：修改源数组，挤掉最后一个元素。
2：创建一个长度为源数组长度+1的新数组，然后将指定的内容和源数组的内容放置到新的数组中。 最后返回新数组。

//在指定的数组中的位置上插入指定的数据，返回新的数组

public static int[] insertElementByIndex(int[] srcArr,int insertIndex,int value){
		final int NEW_LEN = srcArr.length + 1;
		//创建新数组
		int[] temp = new int[NEW_LEN];
		//循环赋值
		for(int i=0;i<NEW_LEN;i++){
			if(i < insertIndex){
				temp[i] = srcArr[i];
			}else if(i == insertIndex){
				temp[i] = value;
			}else{
				temp[i] = srcArr[i-1];
			}
		}
		return temp;
	}

Arrays工具类

Math：数学工具类。

Arrays ：针对数组进行操作的工具类。

java.util.Arrays.
此类包含用来操作数组（比如排序和搜索）的各种方法。

常用的方法：
static int binarySearch(int[] a, int key)
使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。
static int binarySearch(int[] a, int fromIndex, int toIndex, int key)
使用二分搜索法来搜索指定的 int 型数组的范围，以获得指定的值。

static int[] copyOf(int[] original, int newLength)
复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。

static boolean equals(byte[] a, byte[] a2)
如果两个指定的 byte 型数组彼此相等，则返回 true。

static void fill(int[] a, int val)
将指定的 int 值分配给指定 int 型数组的每个元素。
static void fill(int[] a, int fromIndex, int toIndex, int val)
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。

static void sort(int[] a)
对指定的 int 型数组按数字升序进行排序。
static void sort(int[] a, int fromIndex, int toIndex)
对指定 int 型数组的指定范围按数字升序进行排序。

static String toString(int[] a)
返回指定数组内容的字符串表示形式。

变参-方法

jdk1.5的特性：变参方法

变参方法的语法：
(参数的类型 … 参数变量名)

特点：
1：变参方法可以接收的参数的数量为[0~n];
2: 如果有定参方法，有变参方法，优先匹配定参的方法执行。
3：如果参数列表中有变参的存在，那么变参参数只能在参数列表的末尾。后面不能在有参数。
4：一个参数列表中，变参的个数最多是一个。
5：变参参数底层使用数组实现。处理变参参数就和处理数组一样一样的。
6：变参参数可以接收数组作为实参。

多维数组

一维数组：
//线性分配空间的。
int[] array = {1,2,3,54,5,6,7,87,77};

多维数组：
严格意义上来说，java 就没有多维数组的概念。

二维数组：本质上还是一维数组，只不过数组的元素还是数组。

语法：
动态初始化
int[][] array  =new int[3][5];
前面中括号称之为 高纬
后面中括号称之为 低纬

可以先分配高纬度，然后再对每一个高纬数组元素分配空间。
//分配了一个一维数组，一位数组的元素是数组，元素数量为3，默认值为 null。
int[][] array  =new int[3][];
//给每一个低纬的一纬数组分配空间
array[0] = new int[10];
array[1] = new int[100];
array[2] = new int[150];


静态初始化。
int[][] array  =new int[][]{
	{1,2,3},
	{23,4,5,67,8,66},
	{12,234,45,56,65,45,34}
};

int[][] array  ={
	{1,2,3},
	{23,4,5,67,8,66},
	{12,234,45,56,65,45,34}
};

数组的知识还有很多，我只讲这么多。