java 数组详解 数组 数组的四种定义方式： 数组的内存分析 二维数组： 数组排序： 数组的基本操作
概念：数组是一个定长的容器,数组中存储的数据类型需要是一致的
数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
数组的四种定义方式：
数据类型是数组中元素的数据类型
数组是有默认值的{0,0,0,0,0,0,0,0,0,0,}
int数据类型是数组中元素的数据类型
数组的数据类型是 int[]
元素 --> 数组中储存的值
数组的长度 --> 数组中的元素个数
//数据类型[] 数组名 = new 数据类型[数组中元素的个数]
int[] array = new int[10];
2.先声明数组，然后再进行赋值
//在类中，定义成员变量，方法传递
int[] array2;
array2 = new int[10];
3.创建数组的同时，给定当前数组中储存元素的值
//数组的长度：后面{}中储存多少个值，数组就有多长
int[] array3 = new int[]{1,2,3,4}
4.第3的简化版本
int[] array4 = {1,2,3,4}
数组的概念
同一种类型数据的集合。其实数组就是一个容器。运算的时候有很多数据参与运算,那么首先需要做的是什么.不是如何运算而是如何保存这些数据以便于后期的运算，那么数组就是一种用于存储数据的方式，能存数据的地方我们称之为容器，容器里装的东西就是数组的元素, 数组可以装任意类型的数据，虽然可以装任意类型的数据,但是定义好的数组只能装一种元素， 也就是数组一旦定义，那么里边存储的数据类型也就确定了。
数组的内存分析
数组声明后实际上是在栈内存中保存了此数组的名称，接下来便是要在堆内存中配置数组所需的内存，其中“元素的个数”（数组的长度）是告诉编译器，所声明的数组要存放多少个元素，而“new”则是命令编译器根据括号里的长度开辟空间。
二维数组：
Arrays的使用
遍历： toString() 将数组的元素以字符串的形式返回
排序： sort() 将数组按照升序排列
int[] arr = {23,64,2,37,43,67,1};
Arrays.sort(arr); //升序
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
查找： binarySearch()在指定数组中查找指定元素，返回元素的索引，如果没有找到返回（-插入点-1） 注意：使用查找的功能的时候，数组一定要先排序。
二维数组：实质就是存储是一维数组。
数组定义：
数组类型[][] 数组名 = new 数组类型[一维数组的个数][每一个一维数组中元素的个数];
数组排序：
数组排序有很多中:冒泡 ,选择,插入,快速,堆等等
* 速度最快的就是 堆 排序
冒泡排序 ( 两两相比 )
是相邻的两个数组元素进行比较
若当前元素大于后面的元素,交换两个元素的位置
若当前元素不大于后面的元素,就不交换
比较所有相邻的元素,最终的到一个有序的结果
冒泡最大的特点就是会先找出最大的值,然后放到数组的最后一位
升序(从小到大),降序(从大小) --> 默认排序都是升序
只要经过一轮排序,肯定会有一个数放到正确的位置上
3,7,4,6,9,1 --> 存储到数组中是无序,通过冒泡排序,数组升序排列
3,4,6,7,1,9 -- > 9
3,4,6,1,7,9 --> 7,9
3,4,1,6,7,9 --> 6,7,9
3,1,4,6,7,9 --> 4,6,7,9
1,3,4,6,7,9 --> 1,3,4,6,7,9
for(int i = 0 ; i < array.length - 1 ; i++){
for(int j = 0 ; j < array.length -1 -i ; j++){
if(array[j] > array[j + 1]){
int tmp = array[j];
array[j] = array[j+1];
array[j + 1] = tmp;
}
}
选择排序 ( 固定一位一次向后比 )
升序(从小到大),降序(从大小) --> 默认排序都是升序
固定一个元素,依次和后面的元素进行比较
若当前元素大于后面的元素,交换
若当前元素不大于后面的元素,不交换
每次比较完成们都会有一个数放到正确的位置上,小的那个数
3,7,4,6,9,1 --> 存储到数组中是无序,通过冒泡排序,数组升序排列
1,7,4,6,9,3 --> 1
1,3,7,6,9,4 --> 1,3
1,3,4,7,9,6 --> 1,3,4
1,3,4,6,9,7 --> 1,3,4,6
1,3,4,6,7,9 --> 1,3,4,6,7,9
for(int i = 0 ; i < array.length ; i++){
for(int j = i+1 ; j < array.length ;j++){
if(array[i] > array[j]){
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
}
}
数组的复制
int[] a = {10,20,30,40,50};
//数组的扩容(创建了新的数组并将源数组的数据复制过去了)
a = Arrays.copyOf(a,a.length+1); //
for(int i=0;i<a.length;i++) {
System.out.println(a[i]); //10 20 30 40 50 0
}
int[] a = {10,20,30,40,50};
//a:源数组
//a1:目标数组
//6:目标数组的长度(多则补默认值，少则截取)
int[] a1 = Arrays.copyOf(a,6); //灵活性差
for(int i=0;i<a1.length;i++) {
System.out.println(a1[i]); //10 20 30 40 50 0
}
int[] a = {10,20,30,40,50};
int[] a1 = new int[6]; //0,0,0,0,0,0
//a:源数组
//1:源数组的起始下标
//a1:目标数组
//0:目标数组的起始下标
//4:要复制的元素个数
System.arraycopy(a,1,a1,0,4); //灵活性好
for(int i=0;i<a1.length;i++) {
System.out.println(a1[i]); //20 30 40 50 0 0
}
操作数组的工具类：Arrays
java.util.Arrays类包含了用来操作数组（比如排序和搜索）的各种方法，它提供的所有这些方法都是静态的。
Arrays拥有一组static方法：
|
public static int binarySearch(Object[] a, Object key) |
|
public static boolean equals(long[] a, long[] a2) |
|
public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 |
|
public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。 |
public class Test {
public static void main(String[] args) {
int array[] = { 2, 5, 8, 3, 1, 4, 9, 6, 7 }; // 声明一个整型数组
System.out.println("Object的toString："array.toString()); //Object的toString()方法
Arrays.sort(array); // 数组排序
System.out.println("排序后的数组: " + Arrays.toString(array)) ;
int point = Arrays.binarySearch(array, 3) ; // 检索数据位置
System.out.println("元素‘3’的位置在：" + point) ;
Arrays.fill(array, 6) ; // 填充数组
System.out.print("数组填充：" + Arrays.toString(array)) ;
}
}
执行结果
Object的toString：[I@7852e922 排序后的数组: [1, 2, 3, 4, 5, 6, 7, 8, 9] 元素‘3’的位置在：2 数组填充：[6, 6, 6, 6, 6, 6, 6, 6, 6]
数组的基本操作
线性查找(顺序查找)
从数组中的第一个元素开始,依次向后查找,直到找当前要查找的值
要么是找到了,要么就是没有找到
//顺序查找 for (int i = 0; i < array.length; i++) { if(n == array[i]){ return i; //需要范围找到的下标,系统API } } return -1; //返回一个负数 return i; //需要范围找到的下标,系统API } } return -1; //返回一个负数
折半查找(二分查找) 先排序
一定是一个有序的数组,通过待查找的数和数组中间索引值进行比较
大于: 待查找值大于中间索引值,就需要向数组的右半边进行查找
等于:待查找值等于中间索引值,就是找到了
小于:待查找值下于中间索引值,就需要向数组的左半边进行查找
//定义开始值
int beginIndex = 0;
//定义结束值
int endIndex = array.length-1;
//获取中间值
int middleIndex = (beginIndex+endIndex)/2;
//进行比较 用中间值来比较要查找的值
//第一种比较的次数应该是数组的长度
//第二中死循环
while(true){
//缩小范围
if(n > array[middleIndex]){
//修改开始值
beginIndex = middleIndex+1;
}else if(n < array[middleIndex]){
//修改结束值
endIndex = middleIndex -1;
}else{
return middleIndex;
}
//无论是开始值还是结束中发生了改变
//就要重新结算中间值
middleIndex = (beginIndex+endIndex)/2;
//若出现了一种情况 开始 > 结束
if(beginIndex > endIndex){
return -1;
}
}