数组的描述
在数组中每个元素都具有相同的数据类型，是有序数据的集合。通俗的说数组就相当于一个容器。数组分为一维数组、二维数组和多维数组。
数组的特点：
- 数组类型是从抽象基类 Array 派生的引用类型。
- 数值数组元素的默认值为 0，而引用元素的默认值为 null。
- 数组中存放元素的类型必须与创建数组时声明的类型相一致。
- 数组的类型可以是任意数据类型，包括基本数据类型和引用数据类型，如String[]、int[] 、float[]…
- 数组的索引是从0开始的，如果数组有n个元素，那么它的最大索引为n-1，（数组索引的取值范围[0,n-1]）。
数组的创建及赋值
一维数组的创建及赋值
一维数组内存格式（如下图）：
动态创建数组（如下）：
/* 数据类型[] 数组名; //（建议使用）
* 数组名 = new 数组类型[数组长度];
*/
String[] str;
str = new String[10];
str[2] = "Hello";
/* 或
* 数据类型 数组名[];
* 数组名 = new 数组类型[数组长度];
*/
String str1[];
str1 = new String[10];
// 数组名[索引下标] = 元素值;
str1[2] = "Hello";
/*
* 元素类型[] 数组名 = new 元素类型[数组长度]; (建议使用这一种)
* 元素类型 数组名[] = new 元素类型[数组长度];
*/
String[] str2 = new String[20]; //（建议使用）
String str2[] = new String[20];
str2[2] = "Hello";
静态创建数组（如下）：
// 元素类型[] 数组名 = {元素1, 元素2, 元素3，…};
int sum = {1,2,3,4,5,6};
//元素类型[] 数组名 = new 元素类型[]{元素1, 元素2, 元素3，…};
String[] str2 = new String[]{"a","b","1","2"};
二维数组的创建及赋值
二维数组内存格式（如下图）：
动态创建二维数组（如下）：
数组类型[][] 数组名 = new 数组元素类型[行数][列数]
注意：二维数组中声明列数时可以省略，但行数必须写。
/* 数据类型[][] 数组名; //（建议使用）
* 数组名 = new 数组元素类型[行数][]}
*/
String[][] str;
str = new String[5][];
str[0][1] = new String("Hello");
/* 或
* 数据类型 数组名[][];
* 数组名 = new 数组元素类型[行数][列数]}
*/
String str1[][];
str1 = new String[2][3];
str1[0][1] = new String("Hello");
/*
* 元素类型[][] 数组名 = new 元素类型[数组长度1][数组长度2]; (建议使用)
* 元素类型[] 数组名[] = new 元素类型[数组长度1][数组长度2];
* 元素类型 数组名[][] = new 元素类型[数组长度1][数组长度2];
* (数组长度1和数组长度2都必须是正整数；数组长度1为行数，数组长度2为列数；数组长度1必须声明长度)
*/
String[][] str2 = new String[2][3]; // 可以认为创建一个两行三列的数组
String[] str2[] = new String[2][3];
String str2[][] = new String[2][3];
str2[0][1] = new String("Hello");
静态创建二维数组（如下）：
//数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
String[][] str = {{"a","1"},{"b","2"}};
//数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
String[][] str2 = new String[][]{{"a","1"},{"b","2"}};
数组的遍历
一维数组遍历
使用for循环遍历获取数组元素
int[] arr = {11, 22, 33, 44, 55, 66, 77};
// for循环遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
使用for-each循环遍历获取数组元素
优点：语法简洁，相对执行效率较高
缺点：遍历过程中，无法获得数组|集合索引
int[] arr = {11, 22, 33, 44, 55, 66, 77};
// 增强for循环遍历数组
for (int value : arr) {
System.out.println(value);
}
二维数组遍历
// 使用嵌套循环（两层for循环）遍历
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++){
sum +=arr[i][j];
System.out.print(arr[i][j] + " ");
}
}
数组数据结构的优势和劣势
优势：数组能够实现快速寻址，所以执行“修改”和“查询”的效率非常高！
快速寻址公式：首地址 + 索引值 * 存储元素占用的字节数。
劣势：数组实现“插入”和“删除”的效率非常低！
插入：
a)插入元素之前，先判断数组是否还能存得下插入的元素，如果存不下那么需要执行扩容操作。
原因：数组一旦创建完毕，那么数组的空间长度就不能发生变化了！
b)插入元素时，为了保证数组是一块连续的内容空间，那么我们需要对插入位置之后的元素做位移操作。
位移操作：向后移动一位
删除：
a)删除元素时，为了保证数组是一块连续的内容空间，那么我们需要对删除位置之后的元素做位移操作。
位移操作：向前移动一位
数组中常见的方法
import java.util.Arrays;
public class ArraysUtil {
public static void main(String[] args) {
int[] arr = { 5, 12, 90, 18, 77, 76, 45, 28, 59, 72 };
// 字符串输出
//toString(arr);
// 升序排序
//sort(arr);
// 判断数组是否相等
//equals();
// 二分法查找
//binarySearch();
// 数组复制
//copyOf(arr);
//copyOfRange(arr);
/* System类中的arraycopy方法
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
作用：就是用于实现数组元素的拷贝工作。
建议：如果需要实现对数组元素的拷贝工作，建议使用System类中的arraycopy方法，而不要去用Arrays工具类中的copyOf()和copyOfRange()方法
方法参数分析：
src：需要被拷贝的数组(源数组)
srcPos：从源数组中的那个位置开始拷贝，传递是一个索引值
dest：目标数组，也就是把拷贝的元素放入目标数组中
destPos：把拷贝的元素放在目标数组中的哪个位置，传递是一个索引值
length：拷贝数组的元素个数*/
// 复制数组建议使用这种
int[] dest = new int[5];
System.arraycopy(arr, 2, dest, 0, 5);
System.out.println(Arrays.toString(dest));
/*native关键字介绍：
使用关键字“native”修饰的方法，我们称之为本地方法。
本地方法特点：只有方法的声明，没有方法的实现(没有方法体)。
为什么会有本地方法的出现呢？？？
java虽然很强大，但是也有局限性。java不能直接操作硬件！
java中提供的本地方法，本质上就是通过本地方法来调用别的语言（例如：C语言）来操作硬件。*/
}
/**
* 范围复制数组
* @param arr 传入的数组
*/
public static void copyOfRange(int[] arr) {
/*int[] copyOfRange = Arrays.copyOfRange(arr, 2, 8);
for (int i : copyOfRange) {
System.out.print(i + " ");
}*/
int[] copyOfRangeArrays = copyOfRangeArrays(arr, 2, 8);
for (int i : copyOfRangeArrays) {
System.out.print(i + " ");
}
}
/**
* 手写实现范围复制数组
* @param arr 传入的数组
* @param from 取值的初始索引
* @param to 取值的结束索引
* @return 返回的新数组
*/
public static int[] copyOfRangeArrays(int[] arr,int from,int to) {
// 0.判断form和to是否合法
if (to < from || to < 0 || from < 0 || to >= arr.length) {
System.out.println("传入的to或from不合法！");
throw new RuntimeException();
}
int length = to - from;
int[] arr2 = new int[length];
// 方案一：
for (int i = 0; i < arr2.length; i++) {
arr2[i] = arr[from + i];
}
/*// 方案二：
for(int i = from; i < to; i++) {
arr2[i - from] = arr[i];
}*/
/*// 方法三：
for(int i = from, j = 0; i < to; i++, j++) {
arr2[j] = arr[i];
}*/
arr = arr2;
return arr;
}
/**
* 赋值数组
* @param arr 传入的数组
*/
public static void copyOf(int[] arr) {
/*int[] arr2 = new int[4];
int[] copyOf = Arrays.copyOf(arr, 4);
arr2 = copyOf;
for (int i : arr2) {
System.out.print(i + " ");
}*/
int[] copyOfArrays = copyOfArrays(arr,4);
for (int i : copyOfArrays) {
System.out.print(i + " ");
}
}
/**
* 手写实现copy数组方法
* @param arr 传入的数组
* @param length 截取的长度
* @return 返回截取的数组
*/
public static int[] copyOfArrays(int[] arr,int length) {
int[] arr2 = new int[length];
for (int i = 0; i < arr2.length; i++) {
arr2[i] = arr[i];
}
arr = arr2;
return arr;
}
/**
* 二分法查找 （数组必须有序）
* @param arr 传入的数组
*/
public static void binarySearch() {
int[] arr = {1,2,3,4,5,6,7,8,9};
/*int binarySearch = Arrays.binarySearch(arr, 6);
System.out.println(binarySearch);*/
int binarySearch = binarySearch(arr, 6);
System.out.println(binarySearch);
}
/**
* 手写实现二分法查找
* @param arr 传入的数组
* @param value 传入的值
* @return 返回数组中查找值的索引
*/
public static int binarySearch(int[] arr,int value){
int min = 0,max = arr.length - 1,mid = 0;
for (int i = 0; i < arr.length; i++) {
mid = (min + max) / 2;
if (value > arr[mid]) {
min = mid + 1;
}else if(value < arr[mid]){
max = mid - 1;
}else {
return mid;
}
if (max < min) {
return -1;
}
}
return mid;
}
/**
* sort方法
* @param arr 传入的数组
*/
private static void sort(int[] arr) {
// Arrays.sort(arr);
int[] sortArrays = sortArrays(arr);
for (int i : sortArrays) {
System.out.print(i + " ");
}
}
/**
* 手写实现sort方法（冒泡法）
* @param arr 传入的数组
* @return 返回排序后（升序）的数组
*/
public static int[] sortArrays(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
// 假设数组是有序的
boolean flag= true;
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;
flag = false; // 推翻假设
}
}
if (flag) { // 如果有序直接跳出循环
break;
}
}
return arr;
}
/**
* toString方法
* @param arr 传入的数组
*/
public static void toString(int[] arr) {
// System.out.println(Arrays.toString(arr));
System.out.println(toStringArrys(arr));
}
/**
* 手写实现tostring方法
* @param arr 传入的数组
* @return 返回的字符串
*/
private static String toStringArrys(int[] arr) {
String str = "";
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i != arr.length - 1) {
str += arr[i] + ",";
} else {
str += arr[i] + "]";
}
}
return str;
}
/**
* rquals方法
*/
public static void equals() {
int[] arr1 = {1,2,3,4};
int[] arr2 = {1,2,3,4};
/*boolean equals = Arrays.equals(arr1, arr2);
System.out.println(equals);*/
boolean equals = equalsArrays(arr1, arr2);
System.out.println(equals);
}
/**
* 手写实现rquals方法
* @param arr1 传入的第一个数组
* @param arr2 传入的第二个数组
* @return 如果相同则为true，不同则为false
*/
public static boolean equalsArrays(int[] arr1, int[] arr2) {
if (arr1 == arr2)
return true;
if (arr1 == null || arr2 == null)
return false;
if (arr1.length != arr2.length)
return false;
for (int i = 0; i < arr2.length; i++) {
if (arr1[i] != arr1[i]) {
return false;
}
}
return true;
}
}