Java学习-数组

一、基础

1.1 基础

项目	含义
含义	数组是一个固定长度的，包含了相同类型数据的 容器
作用	临时存储数据
特点	长度固定
下标基	下标0，代表数组里的第一个数
长度	int arr1Length = arr1.length;
默认值	根据数据类型的默认值。

1.2 引用概念

含义：若一个变量代表一个对象，则把这个变量叫做这个对象的引用。

// ==============引用类型==============
int[] a = new int[5];
// a叫做new int[5]实例对象的引用。
// 即，让a这个引用，指向数组（new int[5]）实例对象。
People p = new Student();
// 含义：父类（People）的引用（p）指向子类（Student）。
// ==============基本类型==============
int c = 5; 
// 含义：给c赋值为5 。

二、创建数组

创建方式：声明、分配空间（长度）、赋值组合。

声明：仅仅是声明，不会创建数组

int[] arr1;

分配空间：指定数组的长度。也叫创建数组

arr1 = new int[5]; 

赋值：给数组元素赋值。

// 全赋值
arr1 = {1,2,3};
// 注意：此时，是让引用变量arr1，指向数组new int[5]。
// 一个一个赋值。
arr1[0] = 1;

2.1 未指明数组长度

不常用。

// 方式一；声明并赋值。
// 语法 ：数据类型[] 数组名 = {元素1,元素2,....};
public int[] getArray(int arrayLength){
	int[] arr1 = {1,2,3};
	int[] arr2 = new int[]{1,2,3};
	return arr1;
}
// 方式二：先声明，再赋值。
int[] arr1;
arr1 = {1,2,3};

2.2 指明数组长度

常用。

int[] arr1 = new int[5];
// 此时，系统自动赋值，数字型全部元素为0，字符串型全部为null。
// Java中的数组再规定了长度之后，不可再增加。
arr1 = {1,2,3,4,5}; // 直接赋全值
arr1[0] = 0; // 一个一个赋值（或修改元素）。

三、数组元素CRUD

3.1 遍历

// ===============for循环===============
int[] arr3 = {1,2,3,4}
for(int i = 0; i < arr3.length; i++){
  System.out.println(arr3[i]); // 结果：1 2 3 4  
  arr3[i] = 2;// 循环体内可以改变数组元素。
}
System.out.println(Arrays.toString(arr3));
// 结果：[1,2,3,4]
// ===============foreach循环===============
int[] arr4 = {1,2,3,4};
for(int e : arr4){
  System.out.println(e); // 结果：1 2 3 4   
  e = 2; // 循环体内不可改变数组元素。
}
System.out.println(Arrays.toString(arr4));// 结果：[1,2,3,4]。
// ===============打印数组===============
// 语法：Arrays.toString(数组名);
// 注意：该语法会把数组转化为字符串，但保留了“[”、“,”和“]”。
int[] ar5 = {1,2,3,4};
String str = Arrays.toString(arr5);
System.out.println(str);
// 结果：[1,2,3,4]
System.out.println(str.charAt(0));
// 结果：[

3.2 增加与复制

由于数组的长度是固定的，因此不能直接增加元素，只能改变引用的指向。
复制数组方式一：

System.arraycopy(src, srcPos, dest, destPos, length);
//src: 源数组
//srcPos: 从源数组复制数据的起始位置
//dest: 目标数组
//destPos: 复制到目标数组的起始位置
//length: 复制的长度  

复制数组方式二：

int[] dest = Arrays.copyOfRange(src, srcPos, srcEnd);
//dest: 目标数组
//src: 源数组
//srcPos: 从源数组复制数据的起始位置(取得到)
//srcEnd: 从源数组复制数据的结束位置(取不到)

复制数组方式三：

int[] dest = new int[src.length];
for(int i = srcPos; i < length;i++){
	dest[i] = src[i];
}

增加数组元素。

int[] a = {1,2,3};
int[] b = {4,5};
a = add(a,b);
// 把两个数组合并。
public static int[] add(int[] a, int[] b){
	int aLength = a.length;
	int bLength = b.length;
	int[] c = new int[aLength+bLength];
	System.arraycopy(a, 0, c, 0, aLength);
	System.arraycopy(b, 0, c, aLength, bLength);
	return c;
}

3.3 修改

// 直接通过索引修改。
arr1[2] = 3;
// 填充数组
Arrays.fill(src,start,end,fillValue);

3.4 删除

由于数组的长度是固定的，因此不能直接增加元素，只能改变引用的指向。

int[] a = {1,2,3};
int index = 1;
a = add(a,index);
// 把两个数组合并。
public static int[] remove(int[] a,int index){
	int aLength = a.length;
	int[] c = new int[aLength - 1];
	if( index == 0){
		System.arraycopy(a, 1, c, 0, c.length);
	}else if(index == aLength){
		System.arraycopy(a, 0, c, 0, c.length);
	}else{
		System.arraycopy(a, 0, c, 0, index);
		System.arraycopy(a, index + 1, c, index, aLength -(index + 1));
	}	
	return c;
}

四、数组元素比较

4.1 数组与数组

语法：Arrays.equals(数组1,数组2)

int[] arr3 = {1,2,3,4};
int[] arr4 = {1,2,3,5};
boolean isEquals = Arrays.equals(arr3, arr4);
System.out.println(isEquals); // 结果：false。

4.2 元素与数组

boolean isEquals = (arr[i] == target) ? true:false;
int index = Arrays.binarySearch(arr, 62)

五、数组元素排序

5.1 从小到大

语法：Arrays.sort(数组名)

int[] arr3 = {1,3,2,4};
Arrays.sort(arr3);
System.out.println( Arrays.toString(arr3));
// 结果：[1,2,3,4]

5.2 从大到小

int[] arr3 = {1,3,2,4};
Arrays.sort(arr3);
System.out.println( Arrays.toString(arr3));
for(int i = 0; i < arr3.length/2; i++){
	int temp = arr[i];
	arr[i] = arr[(arr3.length - 1) - i];
	arr[(arr3.length - 1) - i] = temp;
}

六、数组转换

6.1 数组与字符串

// 数组转字符串
String arrStr = Arrays.toString(arr);
// 字符串转数组
String str = "abc,eda,efa,gce";
String[] arr1 = str.split(",");
System.out.println(Arrays.toString(arr1));
// [abc, eda, efa, gce]
char[] arr2 = str.toCharArray();
System.out.println(Arrays.toString(arr2));
// [a, b, c, ,, e, d, a, ,, e, f, a, ,, g, c, e]

6.2 数组与集合

// 数组转集合
String[] arr = new String[]{"haha", "xixi", "heihei"};
List<String> list = Arrays.asList(arr);
// 集合转数组
List<Integer> list = new ArrayList<Integer>(); 
Integer[] arr = new Integer[list.size()];
list.toArray(arr);

七、二维数组

本质：把一维数组的元素类型，变成了一维数组。

7.1 创建

// 方式一：不显示指明分配空间。
int arr1[][] = {{1,2,3},{4,5,6},{7,8,9}};
// 方式二：显示指明分配空间。数据类型 数组名[][] = new int[行数][列数];
int arr3[][] = new int[2][];
arr3[0] = new int[2];
arr3[1] = new int[3];
arr3[0][0] = 0;

7.2 遍历

int arr1[][] = {{1,2,3},{4,5,6},{7,8,9}};
for(int i = 0; i < arr1.length; i++){
  for(int j = 0; j < arr1[i].length; j++){
    System.out.println(arr1[i][j]);
  }
}