JAVA基础知识 --- 数组

数组概述

• 引入：现在需要统计学生的基本情况，例如平均学习成绩、最高成绩等。假设某班有50名学生，用前面所学的知识，程序首先需要声明50个变量来分别记住每个学生的考试成绩，然后在进行操作，数据量会很多，很麻烦。
  为了解决这种问题，Java就提供了数组供。
• 数组的概念：数组是一种数据结构（相当于一个容器），用来存储同一类型数据的集合。既可以存储基本数据类型，也可以存储引用数据类型
• 分类：一维数组、二维数组、多维数组
  （一般只需用一维数组和二维数组，以下为一维数组）
• 数组声明：在声明数组变量时，需要指出数组类型和数组的名字
  格式1： 数据类型 [ ] 数组名;
  格式2： 数据类型 数组名[ ];
  如：定义了一个int类型的数组a ： int[] a 或 int a[]; 常用第一种定义方式。
• 访问方法：当创建好一个数组后，系统就会分配索引（下标），其从0开始。
  通过一个整型下标来访问数据中的每一个元素。-----如：a是一个整型数组，那么a[i]就是数组a中下标为i的整数。

数组的初始化

• 定义：数组也是变量，必须初始化才能使用。数组初始化就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
• 初始化分类：
  • a.动态初始化: 只指定长度，由系统给出初始化值
    格式： 数据类型[] 数组名 = new 数据类型[数组长度];
    数组长度其实就是数组中元素的个数，表示方法：数组名.length
    -----如： int[] arr = new int[3]; 定义了一个int类型的数组arr，这个数组可以存放3个int类型的值。
  • b.静态初始化: 给出初始化值，由系统决定长度
    格式： 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
    -----如： int[] arr = new int[]{1,2,3};
    简化格式： 数据类型 [] 数组名 = {元素1,元素2,…};
    ----如： int[] arr = {1,2,3};

- 说明：数组一旦创建，就不能再改变他的大小，只能改变每一个数组元素。

• 代码：创建一个数组，存入数据并取出数组中的元素。

 public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] arr = new int[3];
        arr[0] = 10;
        arr[1] = 20;
        int num = arr[0];
        int num2 = arr[2];
        System.out.println(num);
        System.out.println(num2);
    }
}

• 要对此代码分析，需掌握java对内存的分配。

JAVA的内存分配

• a.栈内存: 存放的是局部变量
  局部变量：在方法定义中或者方法声明上的变量都是局部变量。
  b.堆内存: 存放的是所有new出来的东西
  特点：1) 每一个new出来的东西都会为其分配一个地制值。
  2)每一个变量都有一个默认的值：

    - byte，short，int，long  --- 0；
    - float，double --- 0.0；
    - char  --- '\u0000'；boolean --- false；
    - 引用数据类型	 --- null	。			     
  

  3)使用完毕就变成了垃圾，等待垃圾回收器对其回收
  c.方法区:加载.class文件先到发方法区，面向对象(面向对象部分详细讲解)
  d.本地方法区:和系统相关
  e.寄存器:cpu使用
  

• 程序在内存中的执行步骤：

  • step1：先将ArrarDemo2.class文件加载进方法区，其中有main方法；
  • step2：main方法进栈执行，执行int[] arr = new int[3];，每new一次，堆内存为数组分配一个地址为0x001的空间，空间大小为3，并附初始值0；则数组arr通过地址值0x001指向堆内存的这段空间，并对其进行操作；
  • step3：继续执行arr[0] = 10;为数组arr的第一个空间赋值10，覆盖初始值0，执行arr[1] = 20;为数组arr的第三个空间赋值20，覆盖初始值0；
  • step4：int num = arr[0];取出数组arr中的第一个元素赋值num，int num2 = arr[2];取出数组arr中的第一个元素赋值num2；
  • step5：main方法执行完后出栈，堆内存的空间等待系统自动回收。

此处为引用数据类型：
    使用new关键字初始化的数据，数组，类，接口，枚举等为引用数据类型。

数组操作的两个常见小问题

• 数组索引（角标）越界：原因：数组是大小固定的，访问了不存在的索引。
  ArrayIndexOutOfBoundsException 数组角标越界异常
• 空指针异常：原因：数组已经不再指向堆内存，此时数组名不能再去访问其元素。
  NullPointerException 空指针异常

int[] arr = new int[]{10, 20, 30};
arr[3]=100;
  // System.out.println(arr[3]); //ArrayIndexOutOfBoundsException 数组角标越界异常
arr = null;// 人为置空
        //NullPointerException 空指针异常

数组的操作

• 1、数组遍历：就是依次输出数组中的每一个元素。

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr={10,20,50,40,102};
        //数组的遍历
        //for(int i=0;i<arr.length;i++){
        //    System.out.println(arr[i]);
        //}
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("---------------------------");
        
        //反向遍历
        for(int i=arr.length-1;i>=0;i--){
            System.out.println(arr[i]);
        }
    }
}

• 2、数组获取最值：获取数组中的最大值或者最小值

public class ArrayDemo2 {
    public static void main(String[] args) {
        //获取数组中的最大值或最小值
        int[] arr = {10, 20, 50, 40, 102};
        int max = getMax(arr);
        System.out.println("最大值是" + max);
        int[] arr2 = {10, 20, 50, 40, 102,1000,1};
        int max1 = getMax(arr2);
        System.out.println("最大值是" + max1);
    }
    
    public static int getMax(int[] arr){
        //定义一个参照值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
}

• 3、数组元素反转：就是把元素对调

public class ArrayDemo3 {
    public static void main(String[] args) {
        //数组元素对调
        int[] arr = {10, 20, 30, 40, 50};
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }
        showArray(arr);      //50 40 30 20 10
    }
    
    //数组元素遍历
    private static void showArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }
    }
}

• 4、数组查表法：根据键盘录入索引,查找对应星期几

public class shuzu4 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int index = sc.nextInt();
        getWeek(index);
    }
    
    private static void getWeek(int index) {
        String[] str ={"星期一","星期二","星期三","星期四","星期五","星期六","星期天"};
        if (index >= 1 && index <= 7) {
            return arr[index - 1];
        } else {
            return "查无此元素";
        }
    }
}

• 5、数组元素查找：查找指定元素第一次在数组中出现的索引

public class shuzu5 {
    public static void main(String[] args) {
        //根据元素查索引
        Scanner scc = new Scanner(System.in);
        String[] arr = {"星期一","星期二","星期三","星期四","星期五","星期六","星期天"};
        System.out.println("请输入一个星期");
        String str = scc.nextLine();    //获取用户输入的字符串
        int index = getIndex(str,arr);
        System.out.println("该元素的索引是"+index);
    }
    
    private static int getIndex(String a,String[] arr) {
        for (int i = 0; i < arr.length ; i++) {
            if (a.equals(arr[i] )) {   比较字符串
                return i;
            }
        }
       return -1;   //-1 代表没找到
    }
}

二维数组

• 引入：某校一年级每个班有多个学生，学生姓名可以用数组来存储，而一个年级有多个班，这也需要用一个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组。
  由此可见：二维数组其实就是每一个元素为一维数组的数组。
• 二维数组格式：
  • 格式1： 数据类型[][] 变量名 = new 数据类型[m][n];
    m表示这个二维数组有多少个一维数组 （必须写），n表示每一个一维数组的元素个数（可写可不写）。
    ----如：int[][] arr = new int[3][2]; 定义了一个二维数组arr，这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]，每个一维数组有2个元素，可以通过arr[m][n]来获取，表示获取第m+1个一维数组的第n+1个元素。
  • 格式2： 数据类型[][] 变量名 = new 数据类型[m][];
    m表示这个二维数组有多少个一维数组，这一次没有直接给出一维数组的元素个数，可以动态的给出。
    ----如：int[][] arr = new int[3][]; arr[0] = new int[2]; arr[1] = new int[3]; arr[2] = new int[1];
  • 格式3：数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}...};
    简化版: 数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};//此格式属于静态初始化，由我们指定具体的元素值,由系统给分配长度
    ----如：int[][] arr = {{1,2,3},{4,5,6},{7,8,9}}; int[][] arr = {{1,2,3},{5,6},{7}};

二维数组的操作

• 1、二维数组遍历：

public class ArrayDemo {
    public static void main(String[] args) {
        int[][] arr = {{2, 4}, {10, 30}, {10, 30, 40}, {10, 1}};
        //二维数组的遍历
        //外循环控制的是二维数组的长度，其实就是一维数组的个数。
        for (int i = 0; i < arr.length; i++) {    
            for (int j = 0; j < arr[i].length; j++) {      //内循环控制的是一维数组的长度。
                System.out.println(arr[i][j]);
            }
        }
    }
}

• 2、打印杨辉三角：
  1
  1 1
  1 2 1
  1 3 3 1
  1 4 6 4 1
  1 5 10 10 5 1
  分析规律：A:任何一行的第一列和最后一列都是1
  B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
  步骤：
  A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。 这个n的数据来自于键盘录入。
  B:给这个二维数组任何一行的第一列和最后一列赋值为1
  C:按照规律给其他元素赋值，从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
  D:遍历这个二维数组。

public class ArrayDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入行数");
        int n = sc.nextInt(）;
        int[][] arr=new int[n][n];        //定义一个数组，行列数都一样
        for (int i = 0; i < arr.length; i++) {
            arr[i][0]=1;        //将每一行的第一个数，置成1
            arr[i][i]=1;          //将三角形的每一行的最后一个元素置成1
        }
        //计算中间元素
        for (int i =2; i < arr.length; i++) {
            for (int j =1; j <= i-1; j++) {
                //第三行开始，中间的数等于我上一行的前一列的数和我上一行本列的数之和
               arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
            }
        }
        //遍历二维数组
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j <=i; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}