java中数组的使用

数组：
什么是数组（Array）：
数组是一种连续内存、大小固定的线性表，是一种数据结构，用来解决大量的存储问题。

为什么学习数组：
解决大量数据存储问题

容器（collection）：
容器一般是一种数据结构
是用来解决多个数据保存和计算的容器
线性表：
数组
栈
队列
链表
哈希表：
树
图

数组的特点：
1、大小固定
2、连续内存地址
3、存储的数据类型固定
4、数组是保存在堆内存中！因此数组是对象

Java中如何定义数组
// 第一种定义方式
数据类型[] 变量名称 = new 数据类型[size];

// 第二种定义方式
数据类型[] 变量名称 = new 数据类型[]{值1, 值2……};

// 第三种定义方式
数据类型[] 变量名称 = {值1, 值2……};

数组的长度（元素的个数）：
数组对象.length // 属性

访问数组元素（element）：
通过下标来访问，注意：在编程中，99%情况下，下标都是从0开始

数组对象[下标] // 通过下标来访问元素的个数

数组下标越界异常：

修改元素的数值：
数组对象[下标] = 新值

遍历数组：制作一个索引
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}

int i = 0;
while(i < arr.length) {
System.out.println(arr[i]);
i++;
}

foreach // 循环加强，是jdk5的新特性，是一种迭代容器操作
for (数据类型 临时变量: 可迭代对象) {
System.out.println(临时变量);
}

算法
该算法指的是《数据结构与算法》中的算法
|-- 排序
|-- 查找

排序（sort）
将无序的数据安装特定的规则排成有序数据（升序、降序）
常见的排序算法，有十几种，比较多，有些非常抽象。

|-- 冒泡
|-- 选择
|-- 插入

冒泡分析：
arr = [1, 100, -10, 50, 3, -5, 96] 7个元素

大数上浮法：

如何完成排序：
原有顺序 1, 100, -10, 50, 3, -5, 96
1 1, -10, 50, 3, -5, 96, 100 // 100（找最大值）
2 -10, 1, 3, -5, 50, 96, 100 // 96
3 -10, 1, -5, 3, 50, 96, 100 // 50
4 -10, -5, 1, 3, 50, 96, 100 // 3

小数下沉法

选择分析：
1, 100, -10, 50, 3, -5, 96

最小值：
假设第一个值为最小值，之后一直查找，直到找到真正的最小值，交换这两个数

原 1, 100, -10, 50, 3, -5, 96
1 -10, 100, 1, 50, 3, -5, 96
2 -10, -5, 1, 50, 3, 100, 96
3 -10, -5, 1, 50, 3, 100, 96
4 -10, -5, 1, 3, 50, 100, 96
5 -10, -5, 1, 3, 50, 100, 96
6 -10, -5, 1, 3, 50, 96, 100

插入分析
1, 100, -10, 50, 3, -5, 96
以第一个为有序数组，之后的所有元素依次插入到这个有序数组中，插入时，必须保证数组一直有序！

原 1, 100, -10, 50, 3, -5, 96

1 1,100, -10, 50, 3, -5, 96
2 -10,1,100, 50, 3, -5, 96
3 -10,1, 50,100, 3, -5, 96
4 -10,1,3, 50,100, -5, 96
5 -10, -5,1,3, 50,100, 96
6 -10, -5,1,3, 50,96, 100

算法的特性：
算法的时间复杂度
冒泡：O(n^2)
选择：O(n^2)

算法的空间复杂度（时间复杂度和空间复杂度大概率是成反比）

算法的稳定性
冒泡：稳定的排序算法
选择：不稳定的排序算法（原生的选择排序稳定性非常差）

值传递和引用传递的区别

class TestObjectOrValue {
	public static void main(String[] args) {
		int a = 10, b = 20;
		
		// 值传递，也就是仅仅发生了一次值的拷贝
		// change(a, b);
		//System.out.println("a = "+ a +", b = "+ b);

		int[] arr = {1, 2};
		// 引用传递，内存地址（对象）
		change(arr);
		for (int i : arr) {
			System.out.print(i + ", ");
		}
	}

	public static void change(int a, int b) {
		int temp = a;
		a = b;
		b = temp;
	}

	public static void change(int[] a) {
		if (a.length < 2) {
			return;
		}
		a[0] = a[0] + a[1];
		a[1] = a[0] - a[1];
		a[0] = a[0] - a[1];
	}
}

查找算法：都是针对有序数据而言的！

二分查找（折半查找）：
针对于有序的序列，可以直接查找中间值

import java.util.Scanner;

public class TestSort {
	public static void main(String[] args) {
		int[] arr = {1, 100, -10, 50, 3, -5, 96};
		
		System.out.println("排序前：") ;
		for (int i : arr) {
			System.out.print(i + ", ");
		}

		// 冒泡排序
		// bubbleSort(arr);

		// 选择排序
		// selectSort(arr);
		// selectSort02(arr);
	
		// 插入排序
		insertSort(arr);
		System.out.println("\n排序后：") ;
		for (int i : arr) {
			System.out.print(i + ", ");
		}
		
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入您要查找的数：");
		int target = sc.nextInt();
		
		// 使用二分查找完成数据查询
		// int index = binarySearch01(arr, target);

		// 使用递归完成二分查找
		int index = binarySearch02(arr, target, 0, arr.length - 1);

		System.out.println("你要查找的数，在数组的"+ index +"位置");
		

	}

	// 二分查找，递归完成
	public static int binarySearch02(int[] arr, int target, int start, int end) {
		if (start > end) {
			return -1;
		}

		int middle = (start + end) >> 1;
		if (target == arr[middle]) {
			return middle;
		} else if (target > arr[middle]) {
			return binarySearch02(arr, target, middle + 1, end);
		} else {
			return binarySearch02(arr, target, start, middle - 1);
		} 
	}


	// 二分查找
	public static int binarySearch01(int[] arr, int target) {
		int start = 0, end = arr.length - 1;
		while (start <= end) {
			int middle = (start + end) >> 1;
			
			if (arr[middle] > target) {
				end = middle - 1;
			} else if (arr[middle] < target) {
				start = middle + 1;
			} else {
				return middle;
			}
		}
		return -1;
	}

	// 插入排序
	public static void insertSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			// 取下一个元素，倒着插入，保证插入时数组一直有序
			for (int j = i + 1; j > 0; j--) {
				if (arr[j] < arr[j - 1]) {
					swap(arr, j, j - 1);
				}
			}
		}
	}

	// 选择排序
	public static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			int min = i;
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[j] < arr[min]) {
					// j对应的下标才是最小值
					min = j;
				}
			}
			// 假设失败，真正的最小值是min
			if (min != i) {
				swap(arr, min, i);
			}
		}
	}

	// 选择排序改进，让代码的稳定性增加，效率提高
	public static void selectSort02(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[j] < arr[i]) {
					swap(arr, j, i);
				}
			}
		}
	}

	
	// 冒泡排序
	public static void bubbleSort(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]) {
					swap(arr, j, j + 1);
				}
			}
		}
	}

	private static void swap(int[] arr, int i, int j) {
		arr[j] = arr[j] ^ arr[i];   
		arr[i] = arr[j] ^ arr[i]; 
		arr[j] = arr[j] ^ arr[i];  
	}
}

一维数组 线性表
也存在多维数组，比如说二维数组

二维数组的定义
数据类型[][] 变量名称 = new 数据类型[行数][列数];

int[][] arr = new int[3][4];
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr[0].length; j++) {
				arr[i][j] = i;
				arr[i][3] = 100;
				System.out.print(arr[i][j] + " ");
			}
			System.out.println();
		}
		
		// 也可以使用简单的方式定义二维数组
		int[][] arr2 = {
				{1, 2, 3, 4, 5},
				{2, 3, 4, 5, 6},
				{3, 4, 5, 6, 7},
				{4, 5, 6, 7, 8},
		};
		
		System.out.println(arr2.length);
		System.out.println(arr2[0].length);
		
	}

}