【java基础系列】11- java的数组

• 如何存储100名学生的成绩？
  • 办法：使用变量存储，重复声明100个double类型变量即可
  • 缺点：麻烦，重复操作过多
• 如何让100名学生成绩全部+1？
  • 办法：100个变量重复相同操作，直至全部完毕
  • 缺点：无法进行统一的操作

• 概念：一组连续的存储空间，存储多个相同数据类型的值。
• 特点
  • 类型相同
  • 长度固定

public class TestCreateArray {
    public static void main(String[] args){
        // 在内存中创建长度为5的整数数组
        int[] a = new int[5]; // new 代表创造/创建含义
    } 
}

int[] a：声明int数组类型变量定义变量名为a
new int[5]：创建一个长度为5的int类型的数组（分配长度为5的连续空间）

• 数组中的每个数据格被称为“数组元素”
• 对每个元素进行赋值或取值的操作被称为“元素的访问”
• 访问元素时，需要使用“下标”（从0开始，依次+1，自动生成）。
• 访问的语法：数组名[下标];
  • 例如 ：a[0]=10; -> a[0];

public class TestCreateArray {
    public static void main(String[] args){
        // 创建数组
        int[] a = new int[5];
        // 依次赋值
        a[0]=5;
        a[1]=3;
        a[2]=4;
        a[3]=7;
        a[4]=10;
        // 依次取值
        System.out.println(a[0]);
        System.out.println(a[1]);
        System.out.println(a[2]);
        System.out.println(a[3]);
        System.out.println(a[4]);
    } 
}

打开 cmd 编译并运行，如下图：

• 有效下标范围： 0 ~ 数组长度-1
• 访问无效下标，会导致数组下标越界
  • Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5

• 遍历：从头至尾，逐一对数组的每个元素进行访问

public class TestCreateArray {
    public static void main(String[] args){
        // 创建数组
        int[] a = new int[5];
        // 依次赋值
        a[0]=11;
        a[1]=22;
        a[2]=33;
        a[3]=44;
        a[4]=55;

        // 这里注意i的取值，只要满足0<=i<5 即可
        for(int i = 0;i < 5;i++){
                System.out.println(a[i]);
        }
    } 
}

这里需要注意的是，就是每个数组发生更改，都要手动修改循环次数的值。

我们可以使用 动态获取数组长度a.length 来解决：

数组名.length ：可动态获取数组长度

public class TestCreateArray {
    public static void main(String[] args){
        // 创建数组
        int[] a = new int[5];
        // 依次赋值
        a[0]=11;
        a[1]=22;
        a[2]=33;
        a[3]=44;
        a[4]=55;

        // 这里注意i的取值，只要满足0<=i<5 即可
        for(int i = 0;i < a.length;i++){
                // 使用循环遍历 i 充当下标，注意访问数组中的每个元素
                System.out.println(a[i]);
        }
    } 
}

public class TestDefaultValue {
    public static void main(String[] args){
        int[] a = new int[5];
        
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
        
        double[] b = new double[5];
        for (int i = 0; i < b.length; i++) {
            System.out.println(b[i]);
        }
    }
}

在没有为数组元素赋值的情况下，依旧可以正确访问；
数组默认值：

• 整数：0
• 小数：0.0
• 字符： u0000
• 布尔：false
• 其他：null

• 先声明，再分配空间

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

• 声明并分配空间

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

• 声明并赋值（繁）

数据类型[] 数组名 = new 数据类型[]{value1,value2,value3,...};

// 可换行
数据类型[] 数组名;
数组名 = new 数据类型[]{value1,value2,value3,...};

• 声明并赋值（简）

数据类型[] 数组名 = {value1,value2,value3,...} // 显示初始化，注意：不可换行书写

举个例子

public class TestCreates{
    public static void main(String[] args){
    // 先声明，再分配空间
    int[] array1;
    
    array1 = new int[4];
    
    // System.out.println(array1[0]);
    
    // 声明并分配空间
    int[] array2 = new int[4];
    
    // 声明并赋值（繁）
    int[] array3 = new int[]{11,22,33};
    
    for (int i = 0; i < array3.length; i++){
        System.out.println(array3[i]);
        }
        
    // 声明并赋值（简）
    int[] array4 = {44,55,66};
    
    for (int i = 0; i < array4.length; i++){
        System.out.println(array4[i]);
        }
    
    }
}

举个例子：
给定一个整数数组，统计数组中所有元素的平均值

public class TestGetAvg{
    public static void main(String[] args){
    int[] numbers = new int[]{55,66,77,88,99};
    
    int sum = 0;
    
    for (int i = 0;i < numbres.length; i++){
        sum += numbers[i];
    }
    
    double avg = sum / numbers.length;
    
    System.out.println(avg);
    }
}

举个例子
给定一个整数数组，读入一个整数 n，如果n在数组中存在，输出下标，不存在则输出-1。

import java.util.Scanner;

public class TestSearch{
    public static void main(String[] args){
    
    Scanner input = new Scanner(System.in);
    
    System.out.println("请输入一个整数： ");
    
    int n = input.nextInt();
    
    int[] numbers = new int[]{1,2,3,4,5,6,7};
    
    int index = -1; // 代表n从未出现在数组中
    
    // 循环查找的过程
    for(int i = 0;i < numbers.length;i++){
     if(numbers[i] == n){
         // 存在
         index = i; // 改变index，代表n所出现的下标
         break;
         }
        
     }
     System.out.println(index);
    }
}

• JDK排序：java.util.Arrays.sort(数组名); // jdk提供（升序）

import java.util.Arrays;

public class TestSort{
        public static void main(String[] args){
                
                int[] nums = new int[]{4,3,1,5,2};
                
                // 借助JDK提供的数组工具，进行排序
                Arrays.sort(nums);
                
                // 第一次遍历（升序）
                for (int i = 0; i < nums.length; i++){
                        System.out.println(nums[i]);
                }
                
                // 降序：需要手工的方式完成元素的倒置
                for (int i = 0; i < nums.length / 2; i++){
                        int temp = nums[i];
                        
                        nums[i] = nums[nums.length - 1 - i];
                        
                        nums[nums.length - 1 - i] = temp;
                        
                        
                        // System.out.println(nums[i]);
                }
                
                // 第二次遍历（降序）
                for (int i = 0; i < nums.length; i++){
                        System.out.println(nums[i]);
                }
        }
}

打开cmd 编译并执行，如下图：

• 数组的概念
  • 一组连续的存储空间，存储多个相同数据类型的值
• 数组的声明
  • 数据类型[] 数组名 = new 数据类型[长度]
• 数组的访问
  • 赋值：数组名[下标] = 值;
  • 取值：数组名[下标];
• 数组的遍历
  • 从头至尾，注意对数组的每个元素进行访问
• 数组的应用
  • 统计数组元素、查找数组元素，JDK排序、元素倒置