Java基础--数组

1.什么是数组

• 存储一组相同类型的数据

• 变量：在内存中开辟一块空间

• 数组：在内存中开辟一片连续的空间

• 数组的构成

  • 标识符（数组名）

  • 数组元素

  • 元素下标

    • 元素下标从0开始

  • 元素类型

• 注意

  • 一个数组虽然存储了很多值，但是只有一个名称

  • 元素下标标明了元素在数组中的位置，从0开始，每个元素都可以通过“数组名[下标]”来访问

  • ArrayIndexOutOfBoundsException 数组长度是固定不变的，如果访问数组元素时，下标超出了数组的范围，就会出现异常——数组下标越界。

    • int[] a = new int[3];
      a[3] = 0;

2.如何使用数组

• 1.声明数组

  • 数据类型[] 数组名

• 2.开辟空间

  • 数组名 = new 类型[长度]

• 3.赋值

  • 数组名[下标] = 值

• 4.使用

  • 数组名[下标]

• //声明变量—— 数据类型 变量名
  //声明数组—— 数据类型[] 数组名
  int[] scores;
  //定义数组长度||开辟空间    数组名 = new 类型[长度]
  scores = new int[3];
  //赋值变量—— 变量名 = 值
  //赋值数组—— 数组名[下标] = 值
  //下标从0开始
  scores[0] = 100;
  scores[1] = 95;
  scores[2] = 80;
  System.out.println(scores[0]);

• 简化写法

  • //声明并开辟空间 类型 [] 数组名 = new 类型[长度]
    String[] names = new String[5];
    //1.声明、开辟空间并赋值 ——数组长度由{}中值的数量决定
    //类型[] 数组名 = new 类型[]{值1， 值2...}；
    String[] hobbys = new String[]{"打球", "游泳", "吃饭"};//可以拆开
    //2.声明、开辟空间并赋值  类型[] 数组名 = {值1，值2...};
    String[] address = {"济南", "北京", "泰安"};//不可以拆开

  • 两种声明并赋值的方式的区别

  • //1.声明、开辟空间并赋值 ——数组长度由{}中值的数量决定
    //类型[] 数组名 = new 类型[]{值1， 值2...}；
    String[] hobbys; 
    hobbys = new String[]{"打球", "游泳", "吃饭"};//√
    //2.声明、开辟空间并赋值  类型[] 数组名 = {值1，值2...};
    String[] address; 
    address= {"济南", "北京", "泰安"};//x

3.数组的应用

• 遍历数组时，循环条件为i < 数组长度，我们可以使用”数组名.length“获取数组的长度

• 循环遍历并打印数组元素

  • int[] scores = {100, 95, 88};
    for (int i = 0; i < scores.length; i++) {
        System.out.println(scores[i]);
    }

  • java为我们提供了一个方法，可以获取数组元素的字符串形式

  • System.out.println(Arrays.toString(scores));

• 求数组元素的和

  • int[] arr = {10, 11, 21, 4, 5};
            int sum = 0;//和，初始值为0
            for (int i = 0; i < arr.length; i++) {
                sum += arr[i];
            }
            System.out.println("和为：" + sum);
            double avg = 1.0 * sum / arr.length;
            //double avg = (double)sum / arr.length;
            
            System.out.println("平均分为：" + avg);

• 求数组元素的平均分

• 求数组元素最大值、最小值

  • package homework_day04;
    ​
    import java.util.Scanner;
    ​
    /**
     * @author Ming WanBao
     */
    public class Homework01 {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            int num[];
            int amount = 0;
            int max = 0;
            int min = 0;
            System.out.println("你要输入多少个整数？");
            if (scanner.hasNextInt()){
                amount = scanner.nextInt();
                if (amount > 0){
                    num = new int[amount];
                    System.out.println("请输入" + amount + "个整数：");
                    num[0] = scanner.nextInt();
                    max = num[0];
                    min = num[0];
                    for (int i = 1; i < amount; i++) {
                        num[i] = scanner.nextInt();
                        if (num[i] > max){
                            max = num[i];
                        }
                        if (num[i] < min){
                            min = num[i];
                        }
                    }
                    System.out.println("min:" + min + ",max:" + max);
                } else {
                    System.out.println("输入错误！");
                }
    ​
            } else {
                System.out.println("输入类型错误！");
            }
        }
    }

• 求符合条件的数组元素有几个

  • int[] scores = {100, 29, 80 , 77, 95};
    //考试成绩为60及以上者为合格，求有多少个合格的同学，以及这些同学的平均分
    int count = 0;
    int sum = 0;
    double avgScore = 0;
    for (int i = 0; i < scores.length; i++) {
        if (scores[i] >= 60) {
            sum += scores[i];
            count ++;
        }
    }
    System.out.println("有" + count + "个合格的同学");
    avgScore = 1.0 * sum / count;
    System.out.println("这些同学平均分为：" + avgScore);

4.注意事项

• 数组元素未赋值时可以使用，根据不同的数组类型，会有不同的默认值。

  • 未赋值，但是要开辟空间

• 默认值

  • 整型：0

  • 浮点型：0.0

  • 布尔类型：false

  • 字符char："\u0000"

  • 字符串 String：null

5.数组在内存中的存储方式

• 数组是引用数据类型，引用数据类型值存在堆中，值的地址存在栈中

• 使用==比较数组是否相等(X)

  • // == 可以比较栈中存储的值是否相等，基本数据类型的值直接存储在栈中，所以可以使用== 比较相等
    //引用数据类型的值，存储在堆中，栈中只存储了堆中数据的地址，所以用== 比较数组相等不可行
            int[] arr = new int[5];
            int[] arr2 = new int[5];
            System.out.println(arr == arr2);// false

• 使用=给数组赋值

  • //赋值运算符可以把栈中的值取出赋给变量，基本数据类型值存在栈中，所以可以直接使用=赋值
    //引用数据类型在栈中只存储了一个地址，所以如果使用=赋值，那么两个引用数据类型就会共享地址
    int[] arr = {1, 2, 3};
    int[] arr2 = arr;
    arr[0]++;
    System.out.println(arr[0] + " " + arr2[0]);// 2 2

• 复制数组

  • 循环遍历并复制数组元素

  • int[] arr = {1, 2, 3};
    //数组名.length 获取数组长度
    //创建一个长度相等的数组
    int[] a2 = new int[arr.length];
    //循环遍历，使a2的每一个元素都与arr相同
    for (int i = 0; i < arr.length; i++) {
        a2[i] = arr[i];
    }
    System.out.println("arr" + Arrays.toString(arr));
    System.out.println("a2" + Arrays.toString(a2));
    arr[0] = 10;
    System.out.println("arr" + Arrays.toString(arr));
    System.out.println("a2" + Arrays.toString(a2));

  • 使用Arrays.copyOf()

  • int[] arr = {1, 2, 3};
    //Arrays.copyOf(数组名，新数组的长度) 可以复制数组
    int[] a2 = Arrays.copyOf(arr, 4);
    System.out.println(Arrays.toString(arr));//[1, 2, 3]
    System.out.println(Arrays.toString(a2));//[1, 2, 3, 0]

• 比较数组

  • System.out.println(Arrays.equals(arr, a2));