Java中数组的知识简单了解！

1.数组：相同数据类型的有序集合。
区别变量和数组：变量存储单个数据，数组存储多个数据。
2.数组的特点：
1）数组是一个引用数据类型
2）数组是一个容器，长度一旦确定不能改变
3）数组中数据类型相同
4）数组中数据是有序的
3.数组的声明方式
1）数据类型【】 数组名；
数据类型：当前数组中所有数据的类型 基本数据类型或者引用数据类型
2）数据类型 数组名【】；-------不推荐使用
4.数组初始化
1)动态初始化：数据类型【】 数组名 = new 数据类型【长度】； 创建指定长度的数组
数组中的数据存在默认值：
byte/short/int/long ————>0
double/float————>0.0
char ————————>’ ’
boolean ————————>false
引用数据类型——————>null
2）静态初始化：
数据类型【】 数组名 = new 数据类型【】{值1，值2，值3，…}；定义数组中的值，长度也就确定
数据类型【】 数组名 = {值1，值2，值3…}；-------推荐使用
注意：简略形式不可以给数组重新赋值。
5.操作数组中的数据：0-数组名.length-1
索引|下标 从0开始
数组名【下标】
6.遍历数组的方法
1）普通for循环
2）增强for循环 for…each
for (数据类型 变量名i:容器名|数组名)
i就是 数组中的每一个数据，不是索引 从前面向后 遍历
}
只能获取值 不能赋值。
7.基本数据类型是值的传递；
引用数据类型是地址值的传递。
8.二维数组
数组中又放了数组就是二维数组
声明：
数据类型 [ ] [ ] 数组名 ；-------->推荐
数据类型 数组名 [ ] [ ] ;
数据类型 [ ] 数组名[ ];
初始化：
数据类型【】【】 数组名 = new 数据类型【一维数组的长度】【二维数的组长度】；
每一个第二维都是一样长度
数据类型【】【】数组名 = new 数据类型 【一维数组的长度】【】；
每一个第一维的空间中的数据都是一个小数组，但是每一个第二维数组都没有创建
public class Array07{
public static void main(String[] args){
int[][] arr=new int[2][3];
arr[0][0]=1;
arr[0][1]=2;
arr[0][2]=3;
arr[1][0]=4;
arr[1][1]=5;
arr[1][2]=6;
System.out.println(arr[0][0]);
System.out.println(arr[0][1]);
System.out.println(arr[0][2]);
System.out.println(arr[1][0]);
System.out.println(arr[1][1]);
System.out.println(arr[1][2]);
// 遍历 双重循环嵌套
for(int[] a:arr){ //遍历一维
for( int i : a){
System.out.print(i+" “);
}
System.out.println();
}
int[][] arr2=new int[2][];
/*
arr2[0]=new int[2];
arr2[1]=new int[3];
arr2[0][0]=7;
arr2[0][1]=8;
arr2[1][0]=9;
arr2[1][1]=10;
arr2[1][2]=11;
*/
arr2[0]=new int[]{1,2,3,4}; //不可以使用简略形式
arr2[1]=new int[]{1,2,3};
int[][] arr3=new int[][]{{1,2,3},{4,5}};
int[][] arr4={{11,12,13},{14,15}};
for(int i=0;i<=arr4.length-1;i++){ //二维数组中外层数组的索引
for(int j:arr4[i]){
System.out.print(j+” ");
}
}
}
}
9.可变参数：
参数的个数不确定，可以是0个或者多个，参数的数据类型必须相同
可变参数必须要写在参数列表的最后
…, 数据类型 … 参数名------>可变参数
操作可变参数，要通过使用数组的方式，编译器会隐式的在内部为我们构建一个数组，存储可变参数的值。
public class Demo02{
public static void main(String[] args){
getSum(1,1,1,2,3,4,5)
test(123,new String[]{“哈哈”},new String[]{“呵呵”});
}
//求多个数的和
public static void getSum(int … a){
System.out.println(“hhaahha”+a);
int sum=0;
for(int i:a){
sum+=i;
}
System.out.println(sum);
}
public static void test(int name1,String[] …name2){
System.out.println(name1);
System.out.println(name2);
for(String[] a:name2){
for(String s :a){
System.out.println(s);
}
}
}
}
10.数组排序：
例如给一个数组 int 【】 arr = 【9，10，5，7，4】；
冒泡排序：每两个相邻数之间进行比较，找到一个最小的或者最大的进行交换，把它放在这一轮的最后一个位置。
i=1~arr.length-1 两个数中的第一个j的变化范围
第一轮: 9,5,7,4,10 [0,arr.length-1) 能确定一个最大值,放在最后,下一轮不用比较
第二轮: 5,7,4,9 [0,arr.length-2)
第三轮: 5,4,7 [0,arr.length-3)
第四轮: 4,5 [0,arr.length-4)
选择排序：拿主场数和后面的每一个位置的数据比较大小，确保这一轮结束后，主场位置存放的是这一轮中最大或者最小值
轮数 i 1~arr.length-1 主场数的索引 i 与主场数比较的数的范围:
0 第一轮: 1,9,5,7,4 ,18 0 [i+1,arr.length-1]
1 第二轮: 3,5,7,4 ,8 1
2 第三轮: 7,5,4 ,8 2
3 第一轮: 5,4
public class ArraySort03{
public static void main(String[] args){
int[] arr={9,10,5,7,4};
//print(bubble(arr));
print(choice(arr));
System.out.println(find(arr,15));
}
//选择排序 升序
public static int[] choice(int[] arr){
//外层循环i控制轮数,主场数的索引
int max=0; //记录每一轮中最大数据的索引
for(int i=0;i<arr.length-1;i++){
max=i;
//与主场数比较的数的范围 m
for(int m=i+1;m<=arr.length-1;m++){
if(arr[max]>arr[m]){
max=m;
}
}
//max 最大数的位置
if(max!=i){
int temp=arr[i];
arr[i]=arr[max];
arr[max]=temp;
}
}
return arr;
}
//冒泡排序
public static int[] bubble(int[] arr){
//外层循环控制比较轮数 1~arr.length-1 比如5个数,比较4轮
for(int i=1;i<=arr.length-1;i++){
//内层循环的变量控制i 没两个数比较的第一个数的索引j 和 j+1 j的范围:0 ~ arr.length-i-1
for(int j=0;j<arr.length-i;j++){
if(arr[j]<arr[j+1]){
int temp=arr[j+1];
arr[j+1]=arr[j];
arr[j]=temp;
}
}
}
return arr;
}
//二分法查找:
//数组已经升序排序
//查找数组中指定的数据,找到返回它的索引,没有找到返回-1
public static int find(int[] arr,int i){
int min=0;
int max=arr.length-1;
int mid=(min+max)/2;
while(i!=arr[mid]){
if(i>arr[mid]){
min=mid+1;
}else if(i<arr[mid]){
max=mid-1;
}
if(max<min){
return -1;
}
mid=(min+max)/2;
}
return mid;
}
//遍历数组
public static void print(int[] arr){
for(int i:arr){
System.out.println(i);
}
}
}
11.Arrays工具类
static boolean equals(int[] a, int[] a2) 如果两个指定的 int 型数组彼此相等，则返回 true。
static String toString(int[] a) 返回指定数组内容的字符串表示形式。
static void sort(int[] a) 对指定的 int 型数组按数字升序进行排序。
static void sort(int[] a, int fromIndex, int toIndex) 对指定 int 型数组的指定范围按数字升序进行排序。
static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组的每个元素。
static int binarySearch(int[] a, int key) 使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。
static int[] copyOf(int[] original, int newLength) 将指定数组复制到一个新数组。
static int[] copyOfRange(int[] original, int from, int to) 将指定数组的指定范围复制到一个新数组。
static boolean deepEquals(Object[] a1, Object[] a2) 如果两个指定数组彼此是深层相等 的，则返回 true。
static String deepToString(Object[] a) 返回指定数组“深层内容”的字符串表示形式