12.Java 数组

Java 语言中提供的数组是用来存储固定大小的同类型元素

数组 (Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理

# 数组的相关概念
> 数组名
> 元素
> 角标、下标、索引
> 数组的长度：元素的个数

# 数组的特点
1. 数组属于引用类型的变量。数组的元素，既可以是基本数据类型，可以是引用数据类型。
2. 创建数组对象会在内存中开辟一整块连续的空间；
3. 数组的长度一旦确定，就不能修改 
4. 数组是有序排列的

创建数组方式  4种方式

数组元素类型是基本类型中的整数类型（byte、short、int、long），则数组元素的值是0
数组元素类型是基本类型中的浮点类型（float、double），则数组元素的值是0.0
数组元素类型是基本类型中的字符类型（char），则数组元素的值是'\u0000'
数组元素类型是基本类型中的布尔类型（boolean），则数组元素的值是false
数组元素类型是基本类型中的引用类型（类、接口、数组），则数组元素的值是null

一维数组

// 1.声明整型数组
 int[] intArray0 ;
 int intArray1 [];

// 创建数组，如果在创建的同时不初始化数组则必须指定其大小
 intArray0 = new int[3];

// 创建数组时，不指定数组大小则必须在创建的同时初始化数组
  intArray1 = new int[]{0,1,2};

 // 静态初始化
 int intArray2 [] = new int[]{20,21,22};

  // 静态初始化简化方式
 int intArray3 [] = {30,31,32};

  // 动态初始化
 int[] intArray4 = new int[3]; 

 常用方法

1.clone（）方法： 创建并返回此对象的副本
int [] arr = {7, 8, 9};
int [] cloneArr = arr.clone();//调用数组的clone()方法，将数组复制一份，并让cloneArr指向复制出来的数组
cloneArr[2] = 888;
System.out.println(Arrays.toString(arr));//[7, 8, 9]
System.out.println(Arrays.toString(cloneArr));//[7, 8, 888]


2.equals（）方法： 指示一些其他对象是否等于此
int[] arr1 = {123};
int[] arr2={123};
System.out.println(arr1.equals(arr2));//false   因为这两个数组没有指向同一个内存地址
int[] arr3=arr1; 
System.out.println(arr1.equals(arr3));//true

3.Arrays.equals() 如果两个指定的数组彼此 相等 ，则返回true
int[] arr1 = {123};
int[] arr2={123};
System.out.println(Arrays.equals(arr1,arr2));//true

4.hashCode（）方法： 根据指定数组的内容返回哈希码。
Arrays.hashCode() 方法：根据指定数组的内容返回哈希码
int[] arr1 = {1};
System.out.println(arr1.hashCode());//1915503092
System.out.println(Arrays.hashCode(arr1));//32


5.toString（）方法： 返回对象的字符串表示形式。
Arrays.toString() 方法：返回指定数组的内容的字符串表示形式
int[] arr = {1};
String arrString = Arrays.toString(arr);
System.out.println(arr);// [I@722c41f4   直接输出，为内存地址
System.out.println(arrString );// [1]

6.getClass（）方法： 返回此 Object的运行时类
int a[][] = {{1},{2}};
System.out.println(a.getClass());//class [[I
System.out.println(a.getClass().getName());//[[I  几维数组就有几个[


7.Arrays.asList() 方法： 返回由指定数组支持的固定大小的列表。 或判断数组中是否有指定字符串
String[] arr={"1","2","3"};
//作用一
System.out.println(Arrays.asList(arr));//[1, 2, 3]
//作用二
System.out.println(Arrays.asList(arr).contains("2"));//true


8.Arrays.binarySearch() 方法： 使用二进制搜索算法搜索指定值的指定数组内容。要求被查找的一维数组必须是有序的，否则结果是错误的
String[] arr={"1","2","3"};
int[] a = {5,1,2,3,6,4};
Arrays.sort(a);
System.out.println(Arrays.binarySearch(a,4));//3
System.out.println(Arrays.binarySearch(a,1,5,4));//3       对查询的东西指定范围(1,5)为范围


9.Arrays.copyOf() 方法： 复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度
String[] arr={"1","2","3"};
int [] arr = {1,9,3,7};
int [] arr1=Arrays.copyOf(arr,6);
System.out.println(Arrays.toString(arr1));//[1, 9, 3, 7, 0, 0]


10.Arrays.copyOfRange() 方法： 将指定数组的指定范围复制到新数组中
String[] arr={"1","2","3"};
//作用一
int [] arr = {1,9,3,7};
int [] arr2=Arrays.copyOfRange(arr,1,3);//范围包含1不含3
System.out.println(Arrays.toString(arr2));//[9, 3]


11.Arrays.deepEquals() 方法： 如果两个指定的数组彼此 深度相等 ，则返回 true
int a[][] = new int[][]{{0}, {1, 2, 3, 5, 4}};
int b[][] = new int[][]{{0}, {1, 2, 3, 5, 4}};
int c[][] = new int[][]{{0}};
System.out.println(Arrays.deepEquals(a, b));//deepEquals适用于多层次,true
System.out.println(Arrays.deepEquals(a, c));//false


12.Arrays.parallelPrefix() 方法： 使用提供的功能，并行地计算给定阵列的每个元素
int[] a = {2,8,51,13,46,11,22};
Arrays.parallelPrefix(a, new IntBinaryOperator() {
@Override
public int applyAsInt(int left, int right) {
//除下表为0的元素以外所有元素扩大二倍
return 2*right;//修改的值是1---length-1，位置0的元素不会被修改
    }
});
System.out.println(Arrays.toString(a));//[2, 16, 102, 26, 92, 22, 44]


13.Arrays.fill() 方法： 将指定的字节值分配给指定字节数组的每个元素
int[] arr=new int[3];
Arrays.fill(arr,6);
System.out.println(Arrays.toString(arr));//[6, 6, 6]


14.Arrays.parallelSetAll() 方法： 使用提供的生成函数来并行设置指定数组的所有元素来计算每个元素
int[] a = {2,8,51,13,46,11,22};
Arrays.parallelSetAll(a, new IntUnaryOperator() {
@Override
public int applyAsInt(int operand) {
return operand*2;
    }
});
System.out.println(Arrays.toString(a));//[0, 2, 4, 6, 8, 10, 12]


15.Arrays.parallelSort() 方法： 按照数字顺序排列数组的指定范围
int[] a = {1,8,51,13,46,11,22};
Arrays.parallelSort(a);
System.out.println(Arrays.toString(a));//[1, 8, 11, 13, 22, 46, 51]


16.Arrays.setAll() 方法： 使用提供的生成函数来计算每个元素，设置指定数组的所有元素
int[] a = {2,8,51,13,46,11,22};
Arrays.setAll(a, new IntUnaryOperator() {
@Override
public int applyAsInt(int operand) {
return operand*2;
    }
});
System.out.println(Arrays.toString(a));//[0, 2, 4, 6, 8, 10, 12]



17.Arrays.sort() 方法： 按照数字顺序排列指定的数组
//作用一
int[] arr1={1,9,3,7};
Arrays.sort(arr1);
System.out.println(Arrays.toString(arr1));//[1, 3, 7, 9]
//作用二
int[] arr2={1,9,3,7,2,5};
Arrays.sort(arr2,1,4);//范围包含1不包4
System.out.println(Arrays.toString(arr2));//[1, 3, 9, 7, 2, 5]


18.length（）方法： 获得此数组的长度
//作用一
int[] arr={1,5,6,8,2,3,7};
System.out.println(arr.length);


19.Arrays.stream() 方法： 返回顺序IntStream与指定的数组作为源的指定范围
//作用一
int[] a = {2,8,51,13,46,11,22};
IntStream stream = Arrays.stream(a);
System.out.println(Arrays.toString(stream.toArray()));//[2, 8, 51, 13, 46, 11, 22]
System.out.println(Arrays.toString(a));//[2, 8, 51, 13, 46, 11, 22]

遍历数组

//1.for循环遍历
int[] array3 = {1,2,3,4,5};

for(int i = 0; i <= array3.length;i++){
  System.out.print(array3[i]);

}

//2.for-each遍历
int[] array3 = {1,2,3,4,5};
 
 for (int item: array3 ) {
    System.out.println(item);
  }

自定义数组的工具类

public class ArrayUtil{
# 求数组的最大值
  public int getMax(int[] arr) {
    int maxValue = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (maxValue < arr[i]) {
            maxValue = arr[i];
        }
    }
    return maxValue;
}

# 求数组的最小值
public int getMin(int[] arr) {
    int minValue = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (maxValue > arr[i]) {
            minValue = arr[i];
        }
    }
    return minValue;
 }
 
# 求数组的总和
public int getSum(int[] arr){
	int Sum = 0;
	for(int i = 0; i < arr.length; i++){
		Sum += arr[i]; 
		}
 	return Sum; 
}
 
# 求数组的平均值
public int getAvg(int[] arr){
	int AvgValue = getSum(arr)/arr.length;
 	return avgValue; 
 }
 
# 反转数组
public void reverse(int[] arr){
	for(int i = 0; i < arr.length / 2; i++){
	int temp = arr[i];
	arr[i] = arr[arr.length - i - 1];
	arr[arr.length - i - 1] = temp;
	}
}

# 复制数组
public int[] copy(int[] arr){
	int[] arr1 = new int[arr.length];
	for(int i = 0 ; i < arr.length ; i++){
	arr1[i] = arr[i];
	}
 return null; 
}
 
# 数组排序
public void sort(int[] arr){
	for(int i = 0 ; i < arr.length - 1 ; i++){
	for(int j = 0 ; j < arr.length - 1 - i ; j++){
	if(arr[j] > arr[j + 1]){
	int temp = arr[j];
	arr[j] = arr[j + 1];
	arr[j + 1] = temp;
 		}
 	}
 }
}

# 遍历数组
public void print(int[] arr){
	system.out.print("["
	for(int i = 0 ; i < arr.length ; i++){
	system.out.print(arr[i] + ",");
 	}
	system,out.println("]");
}

# 查找指定元素
public int getIndex(int[] arr , int dest){
 	// 线性查找
	for(int i = 0 ; i < arr.length; i++){
	if(dest == arr[i]){
 	return i;
			 }
		 }
	return i - 1;
	}
}