数组主要解决的就是多数据处理的情况。
变量与变量之间是独立存在的，他们之间是没有联系，变量的空间在内存中划分的时候，地址是随机
的。最终我们通过一个个变量名来访问该空间内的元素数据。
数组就相当于是一个有规则的容器，将所有的数据都存储在容器里，我们就可以方便统一操作这些数
据。
数组的本质
数组其实就是一堆变量的总称 ！只不过 这些变量的地址是连续的 ！那么地址既然连
续，今后在操作这些数据的时候，就会方便很多。
Java当中数组的一些特点
1.数组中的每一个变量空间的数据类型必须是一致的 数组一旦创建出来，其长度不可修改。但是其内容可以在兼容的情况下修改。
2.数组提供角标来访问元素。长度为n的数组，角标0~n-1 数组本身是一个对象！数组是在堆内存中创建的！在堆内存中创建的数据有一个特点，
3.就是有默 认初始化值，相对应的数据类型的零值 既然数组在堆内存中创建的，如何来访问数组呢？我们函数中的引用数据类型变量存储的是数组在
4.堆内存中首元素的地址。 数组有且只有一个属性 length 表示数组的长度
如何在Java中创建一个数组
数组的内存图解
一维数组常用操作
最值问题
public class Sample {
public static void main(String[] args) {
int[] arr = {5,7,9,3,1,2,4,8,6};
int max = arr[0];
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
if (arr[i] < min) {
min = arr[i];
}
}
System.out.println("max = " + max);
System.out.println("min = " + min);
}
}
扩容问题
public class Sample {
public static void main(String[] args) {
int[] arr = {5,7,9,3,1,2,4,8,6}; //10
//数组的长度一旦确定 其不能改
//如果非要改数组的长度 只能创建一个新的数组来操作
arr = add(arr,10);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
public static int[] add(int[] arr, int e) {
//1.创建一个新数组 是原先数组的长度+1
int[] newArr = new int[arr.length + 1]
//2.将原先数组中的元素挨个赋值到新数组中
for (int i = 0; i < arr.length; i++) {
newArr[i] = arr[i];
}
//3.将新元素放入到新数组最后面即可
newArr[newArr.length - 1] = e;
return newArr;
}
}
二分查找
public class Sample {//O(logn)
public static void main(String[] args) {
//线性查找O(n)
//二分查找 前提数组必须有序的(升序 降序)
int[] arr = {1,2,3,4,5,6,7,8,9,10};
int key = 11;
int min = 0;
int max = arr.length - 1;
int mid = (min + max) / 2;
while (true) {
if (key < arr[mid]) {
max = mid -1;
} else if (arr[mid] < key) {
min = mid + 1;
} else {
break;
}
if (min > max) {
mid = -1;
break;
}
mid = (min + max) / 2;
}
System.out.println(mid);
}
}
选择排序
public class Sample {
public static void main(String[] args) {
//选择排序 O(n^2)
int[] arr = {2,6,3,7,4,5,1,8,9};
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
冒泡排序
public class Sample {
public static void main(String[] args) {
int[] arr = {3,6,4,2,1,9,7,8,5};
//i仅仅表示轮数 -1 表示9个数字比8轮
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]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
插入排序
计数排序
属于一种非比较类排序
public class Sample
插入排序
public class Sample {
public static void main(String[] args) {
int[] arr = {3,6,4,2,1,9,7,8,5};
for (int i = 1; i < arr.length; i++) {
for (int j = i; j > 0 && arr[j - 1] > arr[j]; j--) {
int temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
计数排序
public class Sample {
public static void main(String[] args) {
int[] arr = {3,12,-2,-1,0,1,-2,3,-1,6,4,2,1,8,5,10};
//1.找最大值和最小值
int min = arr[0];
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
if (arr[i] < min) {
min = arr[i];
}
}
//2 3确定计数数组的长度
int[] temp = new int[max - min + 1];
//4.遍历原先的数组，将原数组中的数字进行计数
for (int i = 0; i < arr.length; i++) {
int number = arr[i];
int index = number - min;
temp[index]++;
}
//5.遍历计数数组 将数字按照记录的次数打印出来即可
int i = 0;//i表示arr当中的角标
for (int index = 0; index < temp.length; index++) {
//temp[index] 表示index+min这个数字出现的次数！
while (temp[index] != 0) {
arr[i] = index + min;
i++;
temp[index]--;
}
}
for (i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
多维数组
二维数组的本质其实还是一个一维数组，只不过我们之前说的一维数组中，存的是一些常量值
int[] arr = {1,2,3,4,5,6,7,8,9}
对于二维数组而言，就是一个一维数组中，存储的所有元素是另外的一维数组而已
int[][] arr = { {1,2,3} , {4,5,6} , {7,8,9}}
