JAVA数组

1.1 数组的概念

所谓数组(array)，就是相同数据类型的元素按一定顺序排列的集合，就是把有限个类型相同的变量用一个名字命名，以便统一管理他们，然后用编号区分他们，这个名字称为数组名，编号称为下标或索引(index)。组成数组的各个变量称为数组的元素(element)。数组中元素的个数称为数组的长度(length)。

1.2 数组的分类

1、按照维度分：

一维数组: 存储一组数据

二维数组: 存储多组数据,(大肠包小肠).就是数组中的每个位置都放了一个一维的数组;

注意：无论数组的元素是基本数据类型还是引用数据类型，数组本身都是引用数据类型。

1.3 一维数组的声明和使用

        //推荐
//        元素的数据类型[] 数组名;例
        int[] arr1;

        //不推荐
//        元素的数据类型  数组名[];例
        int arr2[];

1.3.1 一维数组的静态初始化

初始化就是确认数组元素的总个数(即数组的长度)和元素的值.

静态初始化就是用静态数据(编译时已知,就是已确认的)为数组初始化.此时数组的长度有静态数据的个数决定.

        //声明 静态初始化
        //第一种
//        int[] ageArr = {1, 2, 3, 4, 5};//数组长度就为5
        //错误方式，不可以先声明再赋值
//        int[] ageArr1;
//        ageArr1 = {1,2,3,5};

//        //第二种 静态初始化
        引用数据类型
//        int[] ageArr=new int[]{1,2,3,5,5,6};//数组长度就为6
//        //可以先声明后赋值
//        int[] ageArr1;
//        ageArr1 = new int[]{1,2,3,4,5};//数组长度就为5

1.3.2 一维数组的使用

数组的长度属性：** 每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度，语句为：`数组名.length` ，属性length的执行结果是数组的长度，int类型结果。

每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引(index)或下标，可以通过数组的索引/下标访问到数组中的元素。

数组名[索引/下标]

1.3.3 一维数组的遍历

float[] score = {95f, 45, 96f, 87f};
//        0  ~ score.length-1
        for (int i = 0; i < score.length; i++) {
            System.out.println(score[i]);
        }

1.3.4 数组下标越界异常

当访问数组元素时，下标指定超出[0, 数组名.length-1]的范围时，就会报数组下标越界异常：ArrayIndexOutOfBoundsException。

1.3.5 一维数组的动态初始化

动态初始化就是先确定元素的个数（即数组的长度），而元素此时只是默认值，并不是真正的数据。元素真正的数据需要后续单独一个一个赋值。

//        动态初始化时,已经给了初始值
        int[] arr = new int[5];
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

输出结果：

1.4 一维数组的常见算法

1.4.1数组统计：求总和、均值、统计偶数个数等

        求和和平均值
        int str = arr[0];
        for (int i = 1;i < arr.length;i++){
                str+=arr[i];
                }
        System.out.println("总和为"+str);
        System.out.println("均值为"+str/(arr.length+1));
        求总乘积
        for (int i = 1;i < arr.length;i++){
            str*=arr[i];
        }
        System.out.println("乘积为"+str);
        奇数偶数个数
        int count1=0;//记录偶数个数
        int count2=0;//记录奇数个数
        for (int i = 0;i < arr.length;i++){
            if (arr[i]%2==0){
                System.out.println(arr[i]+"是偶数");
                count1++;
            }else {
                System.out.println(arr[i]+"是奇数");
                count2++;
            }
        }
        System.out.println("偶数有"+count1+"个");
        System.out.println("奇数有"+count2+"个");

1.4.2找最大值/最小值

public class Test11ArrayMax {
    public static void main(String[] args) {
        int[] arr = {4,5,6,1,9};
        //找最大值
        int max = arr[0];
        for(int i=1; i<arr.length; i++){//此处i从1开始，是max不需要与arr[0]再比较一次了
            if(arr[i] > max){
                max = arr[i];
            }
        }
        System.out.println("max = " + max);
    }
}

1.4.3 数组的元素查找（重点）

1、顺序查找

顺序查找：挨个查看

要求：对数组元素的顺序没要求

        int[] arr = {5,8,6,2,3};
            //按照循环设定目标位置
        for (int i = 0;i<arr.length;i++){
            //目标后面的元素进行一一对比
            //记录对比的两个值中更小的那个一的索引
            int index = i;
            //记录对比的两个值中更小的那个一的数值
            int min =arr[i];
            //将数组中每轮对应的值与该值后的每一位进行对比，如果对比的值更小，就将更小的值赋给min,将更小值的索引记录在index
            for (int j = i+1;j<arr.length;j++){
                if (arr[j]<min){
                    min = arr[j];
                    index=j;
                }
            }
 //交换数值，如果初始开始与其他值对比的值也就是arr[i]不是最小值，那就把在循环中找到的最小值与其进行互相转换
            int temp;
            if (index != i){
                temp = arr[i];
                arr[i]=arr[index];
                arr[index] = temp;
            }
        }
        for (int i = 0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

2、二分查找

        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入查找的目标值");
        int target = scan.nextInt();
        //设置起始的下标位
        int left = 0;
        //设置结尾的下标位
        int right = arr.length-1;

        int index = -1;//记录目标的索引下标
        while (left<=right){
            //设置一个再数组中间位置的数字
            int mid = (left+right)/2;
//      也可以这么写      int mid = left+(right-left)/2;
            //判断比较
            if (arr[mid]==target){
                index=mid;
                break;
            }else if(target>arr[mid]){
                left=mid+1;
            }else {
                right=mid-1;
            }
        }
        //判断是否找到目标
        if (index !=-1){
            System.out.println("索引下标为"+index);
        }else {
            System.out.println("没有找到");
        }

3、冒泡排序

//        趟数
        int tang = 0;
//        每趟比较的次数
        int count = 0;
        int[] arr = {6, 3, 12, 4, 8};
//        趟数 每趟产生一个最值在最右端
        for (int i = 0; i < arr.length - 1; i++) {
//            假设数组已经是有序的
            boolean flag = true;
//            比较的次数  由于每次都减少一个比较熟所有减去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;
                    flag = false;
                }
                count++;
            }
//            如果flag为true,则代表排好顺序
            if(flag){
                break;
            }
            tang++;
        }
        System.out.println("次数"+count);
        System.out.println("趟数"+tang);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }

1.4.4 排序算法排序