Java数组定义及方法

数组的描述

  在数组中每个元素都具有相同的数据类型，是有序数据的集合。通俗的说数组就相当于一个容器。数组分为一维数组、二维数组和多维数组。

数组的特点：

• 数组类型是从抽象基类 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;
	}
    
}