java数组

数组的遍历：访问到数组中的每一个元素。并且可以对每个元素进行一系列操作

方法一：循环遍历

for (int i=0;i<a.length;i++){
    System.out.print(a[i]+" ");//i表示下标
}

方法二：foreach遍历

 for (int i : a){
            i++;//数组中每一个数加一。
    System.out.print(i+" ");//表示数组中的每一个内存单元。

       }

方法二可以不去理解，它就相当于方法一的简化，但是两者都有一定的区别；方法一可以控制遍历的区间，而方法二只能将所有的元素都进行遍历

常见的查找方法：

①顺序查找，也就是按照顺序一位一位的查找

public class S201_05_05_数组的查找 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入需要查找的数为：");
        int num = sc.nextInt();
        int [] arr={2,4,6,8,10,12,14,16};
        int index=find(arr,num);
        if (index==-1) {
            System.out.println("没得找到");
        }else {
            System.out.println(index);
        }
    }
    public static int find(int [] arr,int num){
        int count=0;
        for (int i: arr) {
            if (i==num){
                return count;
            }
            count++;
        }
        return -1;//表示没得找到
    }

弊端：数据量大的时候，在最差的情况下，计算机的负载也非常大，效率低

②折半查找（二分查找）：优化了查找的效率

private static int find(int[] arr, int num) {
    int start=0;
    int end=arr.length-1;
    while (start<=end){
        int mid=(start+end)/2;//找到中间值
        if (arr[mid]==num){//num表示自己输入的值
            return mid;
        }
        if (arr[mid]>num){
            end=mid-1;
        }else {
            start=mid+1;
        }
    }
     return -1;//表示没有找到
}

弊端：必须对一个有序的数组进行查找。

数组的排序

①冒泡排序

public class S201_05_07_冒泡排序 extends A201_01_04_数组的遍历{
    public static void main(String[] args) {
        int [] arr = {5,3,2,4,1,8,9,7,0,6};
         sort(arr);
         write(arr);
    }

    private static void sort(int[] arr) {
        int temp = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length-1; j++) {
                if (arr[i] < arr[j]) {
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }

②选择排序

/*每一次从待排序的数据元素中选出最小（或最大）的一个元素，
存放在序列的起始位置，直到全部待排序的数据元素排完。
 选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，
 导致第一个5挪动到第二个5后面）。
 用第一个数与后面的每一个数作比较，发现比他小的后交换位置*/
public class S201_05_08_选择排序 {
    public static void main(String[] args) {
        int [] arr = {5,3,2,4,1,8,9,7,0,6};
        sort(arr);
    }
    private static void sort(int[] arr) {
        for(int i = 0; i < arr.length - 1; i++) {// 做第i趟排序
                int k = i;
            for(int j = i + 1; j < arr.length; j++){// 选最小的记录
                if(arr[k] > arr[j]){
                    k = j; //记下目前找的最小值到所在的位置
                }
            }
            //在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换
            if(i != k){  //交换a[i]和a[k]
                int temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }
        }
        System.out.println();
        System.out.println("交换后：");
        for(int num:arr){
            System.out.print(num+" ");
        }
    }

二维数组：

二维数组的每一个元素是一个一维数组

定义格式：

数组类型[][]数组名 = new数据类型[二维数组的长度/包含的一维数组的个数][没一个数组的长度]

int[][] arr = new int[3][5];--一个定义了一个整形的二维数组，其中包含了3个一维数组，每个一维数组可以储存5个整数

arr[1]---下表为0的位置上的一维数组

arr[1][3]---如果要获取具体的元素需要两个下标

数据类型[][] 数组名 = new 数据类型[二维数组的长度/包含的一维数组的个数][]；

数据类型[][] 数组名 = {{元素1}，{元素2}，{元素3}......}；、

int[][] arr = {{2,5},{1},{3,2,4},{1,3,5,7}};

注意：[]在变量名前的时候，是紧跟数据类型的，如果[]在后，则相当于变量。

二维数组的长度：数组名.length---每个一维数组：数组名[下标].length

二维数组的遍历---两重for循环

for(int i = 0; i < arr.length; i++){ //遍历二维数组，遍历出来的每一个元素是一个一维数组for(int j = 0; j < arr[i].length; j++){ //遍历对应位置上的一维数组

System.out.println(arr[i][j]);

}

}

二维数组的反转--头尾交换

for(int start = 0, end = arr.length -1; start < end; start++,end--){int[] temp = arr[start];

arr[start] = arr[end];

arr[end] = temp;

}