原文地址：https://www.cnblogs.com/lyang-a/p/11434528.html
一维数组定义：
// 1数据类型[] 数组名 = new 数组类型[数组长度]; String[] str = new String[10]; //2数据类型[] 对象数组名 = new 类名称[] {对象，对象......}; String[] str = new String[]{“a”,"b"}
//数据类型[] 对象数组名 = {对象，对象......};
String[] str = {“a”,"b"}
二维数组定义：
//元素类型[][] 数组名 = new 元素类型[数组长度1][数组长度2]; String[][] str2 = new String[2][3]; // 可以认为创建一个两行三列的数组 //数据类型[][] 数组名 = {{元素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循环： for (int s ： arr) { System.out.println(s); }
二维数组遍历
/ 使用嵌套循环（两层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] + "\t"); } }
数组的操作：
插入：
a)插入元素之前，先判断数组是否还能存得下插入的元素，如果存不下那么需要执行扩容操作。
原因：数组一旦创建完毕，那么数组的空间长度就不能发生变化了！
b)插入元素时，为了保证数组是一块连续的内容空间，那么我们需要对插入位置之后的元素做位移操作。
位移操作：向后移动一位
删除：
a)删除元素时，为了保证数组是一块连续的内容空间，那么我们需要对删除位置之后的元素做位移操作。
位移操作：向前移动一位
/* * 增删改查 * */ /** * 根据下标查询元素 * * @param arr * @param index * @return 整型元素 * @author ZZY * @time 2018-12-07 14:35 */ public static int queryElementByIndex(int[] arr, int index) { return arr[index]; } /** * 根据元素查找下标 * * @param arr * @param ele * @return 元素下标 */ public static int queryIndexByElement(int[] arr, int ele) { int index = -1; // 用来记录下标的变量 // 1：遍历所有的元素 for (int i = 0; i < arr.length; i++) { // 2 用你要查找的元素和所有的元素做==比较 if (arr[i] == ele) { // 3 相等判断成立，记录当前元素的下标 index = i;// 记录当前元素的下标 break; // 后面元素就不用判断了 } } return index; } /** * 求数组的最大值 * * @param arr * @return 最大值 */ public static int maxValue(int[] arr) { // 1 假设第一个元素是最大值 int max = arr[0]; // 2:遍历数组 for (int i = 1; i < arr.length; i++) { // 3 用这个个最大值和后面的元素做大于比较 if (arr[i] > max) { // 4如果后面的元素比这个最大值还大，那么后面的元素就是最大值 max = arr[i]; } } return max; } /** * 求数组的最小值 * * @param arr * @return 最小值 */ public static int minValue(int[] arr) { // 1 假设第一个元素是最小值 int min = arr[0]; // 2:遍历数组 for (int i = 1; i < arr.length; i++) { // 3 用后面的元素这个最小值和做小于比较 if (arr[i] < min) { // 4如果后面的元素比这个最小值还小，那么后面的元素就是最小值 min = arr[i]; } } return min; } /** * 给数组添加元素 * @param arr * @param ele * @param index * @return 返回新的数组 */ public static int[] addElement(int[] arr, int ele, int index) { // 1：新建一个数组，长度是原数组长度+1 数组扩容 int[] newArr = new int[arr.length + 1]; if(index>=0 && index<newArr.length){ // 2 拿到下标为3的前面的元素，放到新数组按照0 1 2 顺序依次存放 for (int i = 0; i < index; i++) { newArr[i] = arr[i]; } // 3 把要添加的元素100放入新数组下标为3的位置 newArr[index] = 100; // 4 拿到下标为3的后面的元素，放到新数组按照 4 5 顺序依次存放 for (int i = index; i < arr.length; i++) { newArr[i + 1] = arr[i]; } }else{ System.out.println("索引超出范围"); //超出范围，返回旧数组 return arr; } // 5:返回新数组 return newArr; } /** * 根据下标删除元素 * @param arr * @param index * @return 原数组 */ public static int[] delEleByIndex(int[] arr,int index){ if(index>=0 && index<arr.length){ //1：找到下标为2的元素，后面的元素依次覆盖前面的元素 for(int i = index;i<arr.length-1;i++){ arr[i] = arr[i+1]; } //2：把最后一位赋值为0 arr[arr.length-1] = 0; }else{ System.out.println("没有此下标"); } //3 返回删除后的数组 return arr; } /** * 根据元素删除元素 * @param arr * @param ele * @return 下标 */ public static int delEleByEle(int[] arr,int ele){ //1 :定义删除元素的下标 int index = -1; //2：用你要删除的元素和数组里面的每一个元素做==比较 for(int i = 0;i<arr.length;i++){ if(ele==arr[i]){ //3：找到要删除的元素后，记录下当前元素的下标 index = i; break; //后面就不要比较了 } } //如果index是-1，直接返回，不需要移位 if(index==-1){ return index; } //4：然后后面的下标依次向前移位 for(int i = index;i<arr.length-1;i++){ arr[i] = arr[i+1]; } //5：把最后一位置为0 arr[arr.length-1] = 0; //6 返回数组的下标即可 return index; } public static void main(String[] args) { int[] arr = { 10, 20, 300, 40, 50 }; int index = delEleByEle(arr,300); if(index!=-1){ for (int i : arr) { System.out.println(i); } }else{ System.out.println("没有此元素"); } /*arr = delEleByIndex(arr,2); for (int i : arr) { System.out.println(i); } */ /* int[] newArr = addElement(arr,100,-12); for (int i : newArr) { System.out.println(i); }*/ /*int max = maxValue(arr); int min = minValue(arr); System.out.println("最大值是:" + max); System.out.println("最小值是:" + min);
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; } }
原文：https://www.cnblogs.com/shanghuliu/p/13593908.html