数组

数组的概述

数组（Array）：

是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名。并通过编号的方式对这些数据进行统一管理

数组相关的概念

1.数组名
2.元素
3.角标、下标、索引
4.数组的长度（元素的个数）

数组的特点

1.数组是有序排列的
2.数组属于引用数据类型的变量，数组的元素，既可以是基本数据类型，也可以是引用数据类型
3.创建数组对象会在内存中开辟一整块连续的空间
4.数组的长度一旦确定，就不能修改

数组的分类

1.按照维数分：一维数组、二维数组……
2.按照数组元素的类型分：基本数据类型的数组、引用数据类型元素的数组

一维数组

声明和初始化

int[] ids; 声明
静态初始化：数组的初始化和数组元素的赋值操作同时进行
ids=new int[]{1001,1002,1003,1004};
动态初始化：数组的初始化和数组元素的赋值操作分开进行
String[] names=new String[5];
（长度）
错误写法：
int[] arr1=new int[];
int[5] arr2=new int[5];
int[] arr3=new int[3]{1,2,3};
注：数组一旦初始化完成，其长度就确定了

调用数组的指定位置的元素

通过角标的方式调用
注：数组的角标（或索引）从0开始的，到数组的长度-1结束
例：
int[] ids;
String[] names=new String[5];
names[0]=”苹果”;
names[1]=”香蕉”;
names[2]=”菠萝”;
names[3]=”鸭梨”;
names[4]=”西瓜”;

获取数组长度

属性：length
System.out.println(names.length);

遍历数组

for(int i=0;iSystem.out.println(names[i]);
}
无论多少个元素，这个结构都能遍历

数组元素的默认初始化值

1.整型：0
2.浮点型：0.0
3.char型：0或’\u0000’，而非’0’
4.boolean型：false
5.引用数据类型：null

内存简化结构

二维数组

声明和初始化

静态初始化：int[][] arr1=new int[][]{{1,2,3}，{4,5}，{6,7,8}};
动态初始化：
1.String[][] arr2=new String[3][2];
2.String[][] arr3=new String[3][];
错误的情况：
1.String[][] arr4=new String[][4];
2.String[3][4] arr5=new String[][];
3.int[][] arr6=new int[3][4]{{1,2,3}{4,5}};
其他正确的情况：
1.int[] arr4[]=new int[][]{{1,2,3}{4,5}};
2.int[] arr5[]={{1,2,3}{4,5,6}};

调用数组的指定位置的元素

System.out.println(arr1[0][1]); 2
System.out.println(arr2[1][1]); null

arr3[1]=new String[4];
System.out.println(arr3[1][0]);

获取数组长度

System.out.println(arr4.length); 3
System.out.println(arr4[0].length); 3
System.out.println(arr4[1].length); 2

遍历二维数组

for(int i=0;i<arr4.length;i++){
for(int j=0;j<arr4[i].lenggth;j++){
    System.out.print(arr4[i][j]+" ");
}
    System.out.println();
}

二维数组元素默认初始化值

规定：二维数组分为外层数组元素，内层数组元素
int[][] arr=new int[4][3];
外层元素：arr[0],arr[1]
内层元素:arr[0][0],arr[1][2]
方式一：int[][] arr=new int[4][3];
外层元素的初始化值：地址值
内层元素的初始化值：与一维数组初始化情况相同
方式二：int[][] arr=new int[4][];
外层元素的初始化值：null
内层元素的初始化值：不能调用，否则报错

二维数组内存解析

数组的复制

array2=new int[array1.length];
for(int i=0;i<array2.length;i++){
    array[i]=array1[i];
}

数组的反转

法1：

for(int i=0;i<arr.length/2;i++){
String temp=arr[i];
arr[i]=arr[arr.length-i-1];
arr[arr.length-i-1]=temp;
}

法2：

for(int i=0,j=arr.length-1;i<j;i++,j--){
String temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}

线性查找

String dest="要找的数据";
boolean isFlag=true;
for(int i=0;i<arr.length;i++){
    if(dest.equals(arr[i])){
        System.out.println("找到了指定的元素，位置为："+i);
        isFlag=false;
        break;
    }
}
if(isFlag){
    System.out.println("很遗憾，没有找到")
}

二分法查找

注：数组元素必须从小到大排列

int[] arr=new int[] {1,2,3,4,5};
        int find=63;
        int head=0;
        int end=arr.length-1;
        boolean isflag=true;
        while(head<=end) {
            int middle=(head+end)/2;
            if(find==arr[middle]) {
                System.out.println("找到了指定元素，位置为"+middle);
                isflag=false;
                break;
            }else if(arr[middle]>find) {
                end=middle-1;
            }else {
                head=middle+1;
            }
        }
        if(isflag) {
            System.out.println("很遗憾没有找到");
        }

冒泡排序

int[] arr = new int[] {19,27,3,16,55};
        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]);
        }

排序

数组中的工具类使用

1.equals(int[] a,int[] b) （boolean类型） 判断两个数组是否相等
例：
int[] arr1=new int[]{1,2,3,4};
int[] arr2=new int[]{1,3,2,4};
booleaan isEquals=Arrays.equals(arr1,arr2);
System.out.println(isEquals);
2.toString(int[] a) （String类型） 输出数组信息
例：
System.out.println(Arrays.toString(arr1));
3.fill(int[] a,int 指定值) 将指定值填充到数组之中
例：
Arrays.fill(arr1,10); (void类型)
System.out.println(Arrays.toString(arr1));
4.sort(int[] a) 对数组进行排序
例：
Array.sort(arr2); （void类型）
System.out.println(Array.toString(arr2));
5.binarySearch(int[] a,int 要查找的数) 进行二分法查找
例：
int[] arr3=new int[]{-98,-56,2,34,56};
int index=Array.binarySearch(arr3,210)；
if(index>=0){
System.out.println(index);
}e;se{
System.out.println(“未找到”)；
}