一、数组的概述

  1. 数组的理解：数组是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

  2. 数组的相关概念：

    • 数组名
    • 元素
    • 角标,下标,索引
    • 数组的长度：元素的个数

  3. 数组的特点：

    • 数组是有序排列的
    • 数组属于引用数据类型的变量，数组的元素，既可以是基本数据类型，也可以是引用数据类型。
    • 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
    • 数组的长度一旦确定，就不能修改 （修改就要造一个新的）
    • new是从堆中开辟空间

  4. 数组的分类

    • 按照维数：一维数组、二维数组
    • 按照数组元素：基本数据类型元素的数组、引用数据类型元素的数组

二、一维数组的使用

    1. 一维数组的声明和初始化
    1. 如何调用数组的指定位置的元素（数组元素引用）
    1. 如何获取数组的长度
    1. 如何遍历数组
    1. 数组元素的默认初始化值
    1. 数组的内存解析

2.1 一维数组的声明和初始化

  • 动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行
  1. int[] arr = new int[3];
  2. arr[0] = 3;
  3. arr[1] = 9;
  4. arr[2] = 8;
  6. String names[];
  7. names = new String[3];
  8. names[0] = “钱学森”;
  9. names[1] = “邓稼先”;
  10. names[2] = “袁隆平”;
  • 静态初始化：在定义数组的同时就为数组元素分配空间并赋值
  1. int arr[] = new int[]{ 3, 9, 8};
  2. 或
  3. int[] arr = {3,9,8};//类型推断
  5. String names[] = {“李四光”,“茅以升”,“华罗庚” };//类型推断

2.2 数组元素的引用方式：数组名[数组元素下标]

  • 定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；

  • 数组元素的引用方式：数组名[数组元素下标]

    • 数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
    • 数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；如int a[] = new int[3]; 可引用的数组元素为a[0]、a[1]、a[2]

2.3 数组元素的默认初始化值

  • 每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长
    度(元素个数) ，数组一旦初始化，其长度是不可变的
  1. package com.atguigu.java;
  3. public class ArrayTest {
  4.     public static void main(String[] args){
  5.         //1.一维数组的声明和初始化
  6.         int num;//声明
  7.         num = 10;//初始化
  8.         int id = 1001;//声明 + 初始化 
  10.         int[] ids;//声明
  11.         //1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
  12.         ids = new int[]{1001,1002,1003};
  14.         int[] arr = {3,9,8};//类型推断
  15.         String names[] = {"AA","BB","CC"};//类型推断
  17.         //1.2 动态初始化:数组的初始化和数组元素的赋值操作分开进行
  18.         String[] names = new String[5];
  20.         //错误的写法
  21. //        int[] arr1 = new int[];//后边没写
  22. //        int[] arr3 = new int[3]{1,2,3};//不能加3
  24.         //总结：数组一旦初始化完成，其长度就确定了。
  26.         //2.如何调用数组指定位置的元素：通过索引的方式
  27.         //数组的角标（或索引）从0开始的，到数组长度-1结束
  29.         names[0] = "战国0";
  30.         names[1] = "春秋1";
  31.         names[2] = "隋唐2";
  32.         names[3] = "大宋3";
  33.         names[4] = "明清4";
  34.         //names[5] = "4";//数组下标越界
  36.         //3.如何获取数组的长度。
  37.         //属性：length
  38.         System.out.println(names.length);
  39.         System.out.println(ids.length);
  41.         //4.如何遍历数组
  42.         //快捷注释ctrl+shift+斜杆
  43.         //解除快捷注释ctrl+shift+反斜杆
  44.         /*System.out.println(names[0]);
  45.         System.out.println(names[0]);
  46.         System.out.println(names[0]);
  47.         System.out.println(names[0]);
  48.         System.out.println(names[0]);*/
  50.         for(int i = 0;i < names.length;i++){
  51.             System.out.println(names[i]);
  52.         }
  53.     }
  54. }

2.5 数组元素的默认初始值

  • 对于基本数据类型而言，默认初始化值各有不同

    • 数组元素是整型：0
    • 数组元素是浮点型：0.0
    • 数组元素是char型：0或’\u0000’,而非’0’
    • 数组元素是boolean型：false
  • 对于引用数据类型而言，默认初始化值为null(注意与0不同！) 
  1. package com.atguigu.java;
  3. /*
  4.  * 5.数组元素的默认初始值
  5.  * byte short int long
  6.  * >数组元素是整型：0 
  7.  * >数组元素是浮点型：0.0
  8.  * >数组元素是char型：0或'\u0000',而非'0'
  9.  * >数组元素是boolean型：false true
  10.  * >数组元素时引用数据类型：null
  11.  */
  13. public class ArrayTest1 {
  14.     public static void main(String[] args){
  16.         //5.数组元素的默认初始化值
  17.         int[] arr = new int[4];//动态
  18.         for(int i = 0;i < arr.length;i++){
  19.             System.out.println(arr[i]);
  20.         }
  21.         System.out.println("*****************");
  23.         short[] arr1 = new short[4];
  24.         for(int i = 0;i < arr.length;i++){
  25.             System.out.println(arr[i]);
  26.         }
  27.         System.out.println("*****************");
  29.         float[] arr2 = new float[5];
  30.         for(int i = 0;i < arr2.length;i++){
  31.             System.out.println(arr2[i]);
  32.         }//float默认类型为0.0
  33.         System.out.println("*****************");
  35.         char[] arr3 = new char[4];
  36.         for(int i =0;i < arr3.length; i++){
  37.             System.out.println("-----" + arr3[i] + "-----");
  38.         }//char默认为0
  40.         if(arr[3] == 0){
  41.             System.out.println("char默认类型为0");
  42.         }
  44.         System.out.println("*************");
  45.         boolean[] arr4 =new boolean[5];//用动态初始化去测
  46.         System.out.println(arr4[0]);//boolean默认为false
  48.         System.out.println("*************");
  49.         String[] arr5 = new String[5];
  50.         System.out.println(arr5[0]);//String默认为null
  52.         if(arr5[0] == null){
  53.             System.out.println("String默认为null");
  54.         } 
  55.     }    
  56. }

2.6 数组的内存解析

2.6.1 内存简化结构

2.6.2 一维数组的内存解析
  • 放在方法中的变量都叫做局部变量

  • 第一行代码new出来的放在堆中

    • 首地址值0x34ab赋值给arr
  • 第二行代码new出来的放在堆中（new出来的结构在堆中重新开辟空间）
  • 第三行代码进行赋值
  • 第四行代码：看到new，重新开辟空间

2.7 一维数组的使用：练习题

2.7.1 一维数组课后练习题1

升景坊单间短期出租4个月，550元/月（水电煤公摊，网费35元/月），空调、卫生间、厨房齐全。屋内均是IT行业人士，喜欢安静。所以要求来租者最好是同行或者刚毕业的年轻人，爱干净、安静。

  1. package com.atguigu.exer;
  3. public class ArrayDemo {
  5.     public static void main(String[] args) {
  6.         int[] arr = new int[]{8,2,1,0,3};
  7.         int[] index = new int[]{2,0,3,2,4,0,1,3,2,3,3};
  8.         String tel = "";
  9.         for(int i = 0;i < index.length;i++){
  11.              tel += arr[index[i]];
  12.         }  
  13.         System.out.println("联系方式：" + tel);//18..
  14.     }    
  15. }

2.7.2 一维数组课后练习题2

CTRL+SHIFT+回车：上面一行

SHIFT+回车：下面一行

  1. package com.atguigu.exer;
  3. /*从键盘读入学生成绩，找出最高分，
  4. 并输出学生成绩等级。
  5. 成绩>=最高分-10 等级为’A’ 
  6. 成绩>=最高分-20 等级为’B’
  7. 成绩>=最高分-30 等级为’C’ 
  8. 其余 等级为’D’
  9. 提示：先读入学生人数，根据人数创建int数组，
  10. 存放学生成绩。*/
  11. import java.util.Scanner;
  13. class ArrayDemo1 {
  15.     public static void main(String[] args) {
  17.         //1.使用Scanner，读取学生个数
  18.         Scanner scanner = new Scanner(System.in);
  19.         System.out.print("请输入数组元素个数");
  20.         int n = scanner.nextInt();
  22.         //创建数组，存储学生成绩，
  23.         int[] score = new int[n];//动态初始化
  25.         //给数组赋值
  26.         for(int i = 0;i < n;i++){
  27.             System.out.print("请输入数组元素（整型）");
  28.             score[i] = scanner.nextInt();
  29.         }
  31.         System.out.print("输出数组元素（整型）");
  32.         for(int i = 0;i < n;i++){
  33.             System.out.print(score[i]);
  34.         }
  36.         for(int i = 0;i < n-1;i++){//n-1趟
  37.              for(int j = 0; j < n - 1 - i;j++){//如果n为4，第一趟比较为3次
  38.                  if(score[j] > score[j + 1]){
  39.                      int temp = score[j];
  40.                      score[j] = score[j + 1];
  41.                      score[j + 1] = temp;
  42.                  }
  43.              } 
  44.         }
  46.         System.out.print("输出排序后的数组元素（整型）");
  47.         for(int i = 0;i < n;i++){
  48.             System.out.println(score[i]);
  49.         }
  51.         int max = score[n-1];
  52.         System.out.print("最高分为" + max);
  54.         char level;
  55.         for(int i = 0;i < score.length;i++ ){
  56.             if(max - score[i] <= 10){
  57.                 level = 'A';
  58.             }else if(max - score[i] <= 20){
  59.                 level = 'B';
  60.             }else if(max - score[i] <= 30){
  61.                 level = 'C';
  62.             }else{
  63.                 level = 'D';
  64.             }
  65.             System.out.println("student " + i + 
  66.                     "score is" + score[i] + ",grade is " + level);
  67.         }
  68.     }
  69. }

三、二维数组的使用

3.1 理解

对于二维数组的理解，可以看成一维数组array1又作为另一个一维数组array2得元素而存在。其实，从数组底层得运作机制来看，没有多维数组

引用类型就两种情况：要么null（没赋值），要么地址值

3.2 二维数组的使用

  • ①二维数组的声明和初始化

  • ②如何调用数组的指定位置的元素

  • ③如何获取数组的长度

  • ④如何遍历数组

  • ⑤数组元素的默认初始化值

  • ⑥数组的内存解析

    • 1、2、3、4 ```java package com.atguigu.java;

public class ArrayTest2 {

  1. public static void main(String[] args) {
  3.     //1.二维数组的声明和初始化
  4.     int[] arr = new int[]{1,2,3};//一维数组
  5.     //二维数组静态初始化
  6.     int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
  8.     //动态初始化1
  9.     String[][] arr2 = new String[3][2];//arr1[0][0]默认为0
  10.     //动态初始化2
  11.     String[][] arr3 = new String[3][];
  13.     //错误的情况
  14.     //String[][] arr4 = new String[][4];
  15.     //int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7}};
  17.     //也是正确的写法
  18.     int arr4[][] = new int[][]{{1,2,3},{4,5,6,8},{6,7,8}};//[][]放后面
  19.     int arr5[][] = {{1,2,3},{4,5},{6,7,8}};//类型推断
  21.     //2.如何调用数组的指定位置元素
  22.     System.out.println(arr1[0][1]);//2
  23.     System.out.println(arr2[1][1]);//默认null
  24.     //System.out.println(arr[1][0]);//报空指针的异常
  26.      arr3[1] = new String[4];//记住
  27.      String arr6[] = new String[4];//对比：一维数组也是正确的写法
  29.      //3.获取数组的长度
  30.      System.out.println(arr4.length);//3
  31.      System.out.println(arr4[0].length);//3
  32.      System.out.println(arr4[1].length);//4
  34.      //4.如何遍历二维数组
  35.      for(int i = 0;i < arr4.length;i++){
  36.          for(int j = 0; j < arr4[i].length;j++){
  37.              System.out.print(arr4[i][j] + " ");
  38.          }
  39.          System.out.println();
  40.      }     
  41. }

}

  2. **⑤数组元素的默认初始化值**```java
  3. package com.atguigu.java;
  4. /*
  5. 二维数组的使用
  6.     规定：二维数组分为外层数组的元素，内层数组的元素
  7.         int[][] arr = new int[4][3];
  8.         外层元素：arr[0],arr[1]等
  9.         内层元素：arr[0][0],arr[1][2]等
  11.     ⑤数组元素的默认初始化值:
  12.     针对于初始化方式一：比如：int[][] arr = new int[4][3];
  13.         外层元素的初始化值为：地址值
  14.         内层元素的初始化值为：与一维数组初始化情况相同
  16.     针对初始化方式二：比如：int[][] arr = new int[4][];
  17.         外层元素的初始化值为：null(数组为引用数据类型)
  18.         内层元素的初始化值为：不能调用，否则报错（不存在，报空指针）
  19.     ⑥数组的内存解析：见ArrayTest3.java
  20. */
  22. public class ArrayTest3 {
  23.     public static void main(String[] args){
  24.         int[][] arr = new int[4][3];
  25.         System.out.println(arr[0]);//[I@15db9742
  26.         System.out.println(arr[0][0]);//0
  28.         //System.out.println(arr);//[[I@6d06d69c
  30.         System.out.println("*************");
  31.         float[][] arr1 = new float[4][3];
  32.         System.out.println(arr1[0]);//地址值
  33.         System.out.println(arr1[0][0]);//0.0
  35.         System.out.println("*************");
  36.         String[][] arr2 = new String[4][3];
  37.         System.out.println(arr2[0]);//地址值
  38.         System.out.println(arr2[0][0]);//null
  40.         System.out.println("*************");
  41.         double[][] arr3 = new double[4][];
  42.         //数组是引用类型，二维数组里的第一维数组元素，即引用类型
  43.         //引用类型默认null
  44.         System.out.println(arr3[1]);//null
  45.         //System.out.println(arr3[1][0]);//报错
  46.     }
  47. }

⑥数组的内存解析

第一行代码：arr1[0]为null引用数据类型不赋值，默认为null

四、每日复习

  1. 写出一维数组的初始化的两种方式
    1. int[] arr = new int[5];//动态初始化
    2. String[] arr1 = new String[]{"Tom","Jerry"};


数组一旦初始化，其长度就是确定的。arr.length
数组长度一旦确定，就不可修改

  1. 写出二维数组初始化的两种方式 ```java int[][] arr = new int[4][3];//动态初始化1 int[][] arr1 = new int[4][];//动态初始化2

int[][] arr2 = new int[][]{{1,2,3},{4,5,6}};//静态初始化

  3. 3. 
  4. 如何遍历如下的二维数组
  5. ```java
  6. int[][] arr = new int[][]{{1,2,3},{4,5,6}};//静态初始化
  8. for(int i = 0;i < arr.length;i++){
  9.     for(int j = 0;j < arr[i].length;j++){
  10.         System.out.print(arr[i][j] + "\t");
  11.     }
  12.     System.out.println();
  13. }
  1. 不同类型的一维数组元素的默认初始化值各是多少
    1. 整型 :0
    2. 浮点型 :0.0
    3. char :0
    4. boolean:false
    5. 引用类型：null
  1. 内存解析

五 练习

  1. 练习1
  1. 声明：int[] x,y[]; 在给x,y变量赋值以后，以下选项允许通过编译的是：
  2. a ) x[0] = y; no
  3. b) y[0] = x; yes
  4. c) y[0][0] = x; no
  5. d) x[0][0] = y; no
  6. e) y[0][0] = x[0]; yes
  7. f) x = y; no
  8. 提示：
  9. 一维数组：int[] x 或者int x[] 
  10. 二维数组：int[][] y 或者 int[] y[] 或者 int y[][]
  1. 练习2
  1. package com.atguigu.exer;
  3. /*使用二维数组打印一个 10 行杨辉三角。 【提示】
  4. 1. 第一行有 1 个元素, 第 n 行有 n 个元素
  5. 2. 每一行的第一个元素和最后一个元素都是 1
  6. 3. 从第三行开始, 对于非第一个元素和最后一个元
  7. 素的元素。即：
  8. yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
  9. */
  10. public class YangHuiTest {
  12.     public static void main(String[] args) {
  13.         //1.声明并初始化二维数组
  14.         int[][] yangHui = new int[10][];
  16.         //2.给数组的元素赋值
  17.         for(int i = 0;i < yangHui.length;i++){
  18.             yangHui[i] = new int[i+1];
  20.             //给首末元素赋值
  21.             yangHui[i][0] = 1;
  22.             yangHui[i][i] = 1;
  23.             //给每行非首末元素赋值
  24.             if(i > 1){
  25.                 for(int j =1;j < yangHui[i].length - 1;j++){
  26.                     yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
  27.                 }
  28.             }
  29.         }    
  30.         //遍历二维数组
  31.         for(int i = 0;i < yangHui.length;i++){
  32.             for(int j = 0;j < yangHui[i].length;j++){
  33.                 System.out.print(yangHui[i][j] + " ");
  34.             }
  35.             System.out.println();
  36.         }                
  37.     }
  38. }