JAVA一维数组

1、 理解数组
（1）在Java中，数组是用来存储一组相同类型数据的数据结构。

（2）当数组初始化完毕后，Java为数组在内存中分配一段连续的空间，其在内存中开辟的空间也将随之固定，此时数组的长度就不能再发生改变。

（3）即使数组中没有保存任何数据，数组所占据的空间依然存在。

2、 定义数组
在Java中，定义数组的语法有如下两种：

        数据类型[] 数组名 = new 数据类型[数组长度];

或者：

        数据类型 数组名[] = new 数据类型[数组长度];

        --->定义数组时一定要指定数组名和数组类型

        --->必须书写“[]”，表示定义了一个数组，而不是一个普通的变量。

        --->“[数组长度]”决定连续分配的空间的个数，通过数组的length属性可获取此长度。

        --->数组的数据类型用于确定分配的每个空间的大小。

        --->数组元素分配的初始值如下

数据元素类型                                                    默认值

byte、short、int、long                                      0

float、double                                                     0.0

char                                                                    ‘\u0000’(空格)

boolean                                                              false

引用数据类型                                                     null

3、 数组元素的表示与赋值  
（1）数组元素在数组里顺序排列编号，该编号即元素下标，它标明了元素在数组中的位置。

（2）首元素（第一个元素）的编号规定为0，因此，数组的下标依次为0、1、2、3、4······依次递增，每次增长数是1.

（3）数组中的每个元素都可以通过下标来访问。

       获取数组元素的语法格式如下：

       数组名[下标值]

4、 数组的初始化
        所谓数组的初始化，就是在定义数组的同时一并完成赋值操作。

        数组初始化的语法格式如下：

                数据类型[] 数组名 = {值1,值2,值3,····,值n};

        或者：

                数据类型[] 数组名 = new 数据类型[]{值1,值2,值3,····,值n};

        注意：第二种初始化数组的方式里new 数据类型[]的[]括号里不能写数组长度。

5、 遍历数组
（1）使用for循环遍历数组

        for(int i = 0;i<数组名.length;i++){
            System.out.println(数组名[i]);
        }
（2）使用增强for循环遍历数组

        for(元素类型 变量名:数组名){
            System.out.println(变量名);
        }
---->增强for循环是JDK1.5之后提供的，用来实现对数组和集合中数据的访问，增强for循环的语法格式如下：

        for(元素类型 变量名 : 要循环的数组或集合名){
            ······
        }
-->第一个元素类型是数组或集合中元素的类型。

-->变量名在循环时用来保存每个元素的值。

-->冒号后面是要循环的数组或集合名称。

6、 数组应用
（1）求数组中的最大值/最小值
思路：

        1）先假设数组中的第1个元素（下标为0）为最大值
        2）依次将数组中后面的元素与这个最大值进行比较，如果比这个最大值还要大，取代它称为新的最大值
        3）比较到最后一个元素，就可以获取这个数组中的最大值

 
        int[] nums = { 56, 60, 78, 42, 311, 88, 12 };
        // 1）先假设数组中的第1个元素（下标为0）为最大值
        int max = nums[0];
 
        // 2）依次将数组中后面的元素与这个最大值进行比较，如果比这个最大值还要大，取代它称为新的最大值
 
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > max) {
                max = nums[i];
            }
        }
 
        System.out.println("数组中的最大值：" + max);
 
        // 获取最小值思路与获取最大值思路一样
        // 假设数组中第一个元素为最小值
        int min = nums[0];
        // 依次将数组中的元素取出来与这个最小值进行比较，如果元素值比这个最小值还小，就成为新的最小值，比较到最后一个元素，就可以得到数组中的最小值
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] < min) {
                min = nums[i];
            }
        }
        System.out.println("数组中的最小值：" + min);

（2）向数组中添加元素
思路：

        1）声明一个长度比原来数组长度大1的数组
        2）将原来数组里元素按照顺序存入到新的数组中
        3）使用Scanner类获取你要增加的学员成绩
        4）通过循环比较获取增加的学员成绩的插入位置
        5）从插入元素插入位置开始及之后的元素依次往后移动一位（从最后一个元素开始，倒着移动）
        6）将要插入的成绩存储到插入位置

    public static void main(String[] args) {
        
        
        //创建Scanner类对象
        Scanner sc=new Scanner(System.in);
        
        int[] scores={99,85,83,63,60};
        
        //1）声明一个长度比原来数组长度大1的数组
        int[] newScores=new int[scores.length+1];
        
        //2）将原来数组里元素按照顺序存入到新的数组中
        for (int i = 0; i < scores.length; i++) {
            newScores[i]=scores[i];
        }
        System.out.println("插入学生成绩前的数组：");
        for (int i : newScores) {
            System.out.print(i+" ");
        }
        System.out.println();
        
        //3）使用Scanner类获取你要增加的学员成绩
        System.out.println("请输入你要增加的学员成绩：");
        int insert =sc.nextInt();
        //设置插入的成绩插入的位置，默认将其插入在数组最后位置
        int index=newScores.length-1;
        
        //4）通过循环比较获取增加的学员成绩的插入位置
        for (int i = 0; i < newScores.length; i++) {
            if (insert>newScores[i]) {
                index=i;
                break;
            }
        }
        
        //5）从插入元素插入位置开始及之后的元素依次往后移动一位（从最后一个元素开始，倒着移动）
        for (int i = newScores.length-1; i < index; i--) {
            newScores[i]=newScores[i-1];
        }
        
        //6）将要插入的成绩存储到插入位置
        newScores[index]=insert;
        
        //输出新数组所有元素
        System.out.println("插入学生成绩后的数组：");
        for (int i : newScores) {
            System.out.print(i+" ");
        }
    }

（3）修改数组中的元素
思路：

        1）找到要修改的元素。

        2）修改元素。

（4）删除数组中的元素
思路：

        1）找到要删除的元素。

        2）删除元素。

        3）将删除元素后面的元素依次前移，最后位置的元素修改为默认值。

    public static void main(String[] args) {
 
        String[] strs = { "hello", "java", "html", "css", "JavaScript" };
        System.out.println("---元素删除前---");
        for (int i = 0; i < strs.length; i++) {
            System.out.print(strs[i] + " ");
        }
        System.out.println();
 
        /*
         * 删除数组strs中的某个元素，删除完这个元素之后，后面的元素依次往前移动一位
         */
 
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你想删除的元素的下标(0-4):");
        int index = sc.nextInt();
 
        if (index == 4) {
            strs[4] = null;
        } else {
            for (int i = index; i < strs.length - 1; i++) {
                strs[i] = strs[i + 1];
            }
            // 元素往前移动之后，最后一个元素赋值为null
            strs[strs.length - 1] = null;
        }
 
        System.out.println("---元素删除后---");
        for (int i = 0; i < strs.length; i++) {
            System.out.print(strs[i] + " ");
        }
        System.out.println();
 
    }

（5）数组冒泡排序
思路：

        1）将数组中元素两两比较，大的数（小的数）往后排（往前排）。

        2）每一轮将大数（小数）排在最后面（最前面）位置。

        3）多轮比较后，得出升序（降序）排列的数组。

        代码（升序排序）：以int类型的数组arr为例

            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;
                    }
                }
            }
（6）Arrays类的使用
        使用java.util.Arrays类

                java.util包提供的工具类

                Arrays类提供操作数组的方法，如：排序、查询

                Arrays类的sort()方法: 对数组进行升序排列

 

    public static void main(String[] args) {
 
        int[] nums1 = { 11, 22, 33, 44, 55 };
        int[] nums2 = { 11, 22, 33, 44, 55 };
 
        // Arrays.equals(数组名1,数组名2)：比较两个数组是否相同，返回一个布尔值，如果两个数组相同，返回true，否则返回false
        boolean result1 = Arrays.equals(nums1, nums2);
        System.out.println("nums1数组和nums2数组相同：" + result1);
 
        // Arrays.toString(数组名)：将数组转换成字符串
        String result2 = Arrays.toString(nums1);
        System.out.println(result2);// [11, 22, 33, 44, 55]
 
        // Arrays.fill(数组名,数据):将数组中的所有元素值替换为你指定的值
        Arrays.fill(nums2, 99);
        System.out.println(Arrays.toString(nums2));// [99, 99, 99, 99, 99]
 
        // Arrays.copyOf(数组名,复制长度)：将某个数组进行指定长度的复制
        int[] newNums1 = Arrays.copyOf(nums1, 3);
        System.out.println(Arrays.toString(newNums1));// [11, 22, 33]
 
        int[] newNums2 = Arrays.copyOf(nums1, 5);
        System.out.println(Arrays.toString(newNums2));// [11, 22, 33, 44, 55]
 
        int[] newNums3 = Arrays.copyOf(nums1, 8);
        System.out.println(Arrays.toString(newNums3));// [11, 22, 33, 44, 55, 0,
                                                        // 0, 0]
 
        System.out.println("----------------------");
 
        // Arrays.binarySearch(查找的数组名称,你想要查找的值)：在指定的数组中查找你要找的数据，返回这个数据的下标，如果找不到这个值，返回一个负值。使用这个方法之前，要确保数组进行了排序，否则不能保证查询结果的正确性
        int[] number = { 11, 55, 69, 34, 78, 16, 84 };
        Arrays.sort(number);
        System.out.println(Arrays.toString(number));// [11, 16, 34, 55, 69, 78,
                                                    // 84]
        int index = Arrays.binarySearch(number, 78);
        System.out.println("你要查找的数据下标：" + index);
 
    }

7、 常见问题
        1、数组下标越界异常：ArrayIndexOutOfBoundsException

        数组下标从0开始，而不是从1开始。

        如果访问数组元素时指定的下标小于0或者大于等于数组的长度，都将出现下标越界异常。