JavaSE ——数组

数组

1.什么是数组

数组就是相同数据的有序集合

2.创建数组

2.1 声明一个数组

如：int[ ] nums; 声明一个数组

2.2 创建一个数组

nums = new int[10];

2.3 给数组元素赋值

nums[0] = 0;

nums[1] = 1;

nums[2] = 2;

nums[3] = 3;

…

nums[9] = 9;

数组的下标是从0开始的，所以定义一个长度为10的数组，下标最大为9

2.4 访问数组元素

通过数组的名称[下标]来访问

如：nums[9] 的值为9

public class Demo1{
    
    public static void main(String[] args){
    	int[] nums = new int[10];
        
        //通过for循环来给数组赋值
        for(int i = 0;i < nums.length;i++){
            nums[i] = i;
        }
        
        //通过for循环来取值
        for(int j = 0;j < nums.length;j++){
            System.out.println(nums[j]);
        }
        //输出的结果为0 1 2 3 4 5 6 7 8 9
        /*
        	注：长度为10的数组下标最大为9，如果出现10就会报错
        */
    }
    
}

如果查询nums[10]，就会报错

3.数组的两种初始化方式

3.1 静态初始化(创建时必须给定值)

public class Demo1{
    
    public static void main(String[] args){
   		int[] arrays = {1,2,3,4,5,6,7,8,9,9,9};
        System.out.print(arrays[0]);//会输出arrays数组的第一位元素1
    }
    
}

3.2 动态初始化(创建时不必给定值，但需给定长度，如果不给定，所有的值默认为0)

public class Demo1{
    
    public static void main(String[] args){
   		int[] arrays = new int[10];
        arrays[9] = 10;
        for(int i = 0;i < arrays.length;i++){
            System.out.print(arrays[i]);
        }
        // 输出的结果为 0 0 0 0 0 0 0 0 0 10
    }
    
}

4.数组的特点

4.1 数组的长度时确定的，一旦被创建就无法更改

4.2 数组的元素必须时相同的类型，不能出现其他的类型

4.3 数组的类型可以是任意类型，基本类型也可以，引用类型也可以

public class Demo1{
    
    public static void main(String[] args){
        // 引用类型的数组
   		String[] str = {"AAA","BBB","CCC"};
        for(int i = 0;i < str.length;i++){
            System.out.print(str[i]);
        }
        // 输出的结果为 AAA BBB CCC
    }
    
}

4.4 数组可以看作时一个引用类型(能new的都是引用类型)，数组中的元素可以看作是对象中的成员变量(成员变量就是全局变量，也可以叫实例变量)，数组是保存在堆中的

public class Demo1{
   
   	int a = 10;//a就是一个成员变量 
    
    public static void main(String[] args){
   		int[] arrays = new int[10];//arrays是一个局部变量
        arrays[9] = 10;
        for(int i = 0;i < arrays.length;i++){
            System.out.print(arrays[i]);
        }
    }
    /*
    	成员变量：也叫属性，也可以叫实例变量，全局变量，它在类中定义，只要是类中的方法都可以对它直接访问
    	局部变量：在方法中的变量只能在方法中访问，在其它方法中不能直接访问
    */
    
}

5. 数组下标越界异常

ArrayIndexOutOfBoundsException

5.1 一个合法的数组的的取值范围为[0 ~ length - 1],如果越界就会报错

5.2 数组下标越界异常：ArrayIndexOutOfBoundsException

5.3 一旦出现这个异常，就去检查你的数组的下标是否越界

6.数组的使用

6.1 for-each 循环

6.1.1 普通的输出数组(适用于对数组中的单个元素的操作)

public class Demo1{
    public static void main(String[] args){
        int[] arr = new int[10];
        // 为数组赋值
        for(int i = 0;i < arr.length;i++){
            arr[i] = i;
        }
        
        // 普通的for循环输出数组
        for(int j = 0;j < arr.length;j++){
            System.out.print(arr[j]);
        }
    }
}

6.1.1 增强型for循环(适用于对数组元素进行输出)

public class Demo1{
    public static void main(String[] args){
        int[] arrs = new int[10];
        // 为数组赋值
        for(int i = 0;i < arrs.length;i++){
            arrs[i] = i;
        }
        
        // 增强型for循环输出数组
        for(int arr : arrs){
            System.out.print(arr);
        }
    }
}

6.2 数组可以作为参数传递

public class Demo2{
    public static void main(String[] args){
        int[] arrs = new int[10];
        // 为数组赋值
        for(int i = 0;i < arrs.length;i++){
            arrs[i] = i;
        }
        
        //将数组arrs作为参数传递给printArray方法
        printArray(arrs);
        
    }
    
    public static void printArray(int[] arr){
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i]);
        }
    }
    
}

6.3 数组作为返回参数

// 案例:将数组中的数进行反转
package 数组;

public class Demo01 {
    public static void main(String[] args){
        int[] arrs = new int[10];
        // 为数组赋值
        for(int i = 0;i < arrs.length;i++){
            arrs[i] = i;
        }

        // 将数组进行反转
        int[] ints = reverse(arrs);
        for(int i = 0;i < ints.length;i++){
            System.out.print(ints[i]);
        }

    }

    public static int[] reverse(int[] arr){
        int[] result = new int[10];
        for(int i = 0,j = arr.length - 1;i < arr.length;i++,j--){
            result[j] = arr[i];
        }

     return result;
    }
}

7.二维数组

7.1 什么是多维数组？？？

多维数组就是数组的数组

7.2 什么是二维数组？？？

普通的数组是在数组里面存放一个数，而二维数组就是在数组里面在存放一个数

package 数组;

public class Demo2 {

    public static void main(String[] args) {
        int[] arr1 = new int[10];// 这是一个普通的数组
        int[][] arr2 = new int[10][10];//这是一个二维数组

        //为普通数组赋值
        for(int i = 0;i < arr1.length;i++){
            arr1[i] = i;
        }

        //为二维数组赋值
        for(int i = 0;i < arr2.length;i++){
            for(int j = 0;j < arr2[i].length;j++){
                arr2[i][j] = i + j;
            }
        }
        System.out.println("普通数组输出：");
        //普通数组输出
        for(int i = 0;i < arr1.length;i++){
            System.out.print(arr1[i] + " ");
        }
        System.out.println();
        System.out.println("二维数组输出：");
        // 二维数组输出
        for(int i = 0;i < arr2.length;i++){
            for(int j = 0;j < arr2[i].length;j++){
                System.out.print(arr2[i][j] + "\t");
            }
            System.out.println();
        }
    }

}

二维数组就可以看成是一张表格，第一个[ ]表示它有多少行，第二个[ ]表示它有多少列

8.对数组操作的类Arrays

什么是Arrays???

Arrays是Java的一个类，使用它可以对数组进行一些操作

import java.util.Arrays;

public class Demo5 {

    public static void main(String[] args) {
        int[] arr = {111,11,11222,3,2244,55,433234,24543245,4242,21123,23543};

        //直接打印arr [I@1540e19d
        System.out.println(arr);

        //使用toString方法将数组打印出来
        // [111, 11, 11222, 3, 2244, 55, 433234, 24543245, 4242, 21123, 23543]
        System.out.println(Arrays.toString(arr));

        //使用sort方法对数组的元素进行排序
        //[3, 11, 55, 111, 2244, 4242, 11222, 21123, 23543, 433234, 24543245]
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

    }

}

使用工具类可以帮我们更加快捷的完成一些对数组的操作

9.冒泡排序

9.1 冒泡排序的原理

1）比较数组中，两个相邻的元素，如果第一个数比第二个数大，就交换他们的位置

2）每一次比较都会产生一个最大或者最小的数

3）下一次就可以少一次排序

4）依次循环，直到结束

import java.util.Arrays;

public class Demo6 {

    public static void main(String[] args) {
        int zh = 0;//用于两个数交换位置
        int[] arr = {123,234,123,1232,34123,23123,123,232342,22};
        for(int i = 0;i < arr.length - 1;i++){//arr.length - 1是因为经历了arr.length - 2次遍历后，实际上已经将数组排好序了
            for(int j = 0;j < arr.length - 1 - i;j++){
                if(arr[j + 1] > arr[j]){
                    zh = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = zh;
                }
            }
        }
        //输出循环后的数组
        System.out.println(Arrays.toString(arr));
        //输出结果：[232342, 34123, 23123, 1232, 234, 123, 123, 123, 22]
    }

}