开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第6天，点击查看活动详情

前言

一、数组定义和访问

1.1 数组的概述

数组:是引用数据类型的一种,是一个容器,可以存储同种数据类型的多个数据
数组可以存储的数据类型有基本数据类型(4类8种),也可以存储引用数据类型(字符串String,自定义类型Person)
数组的长度是固定的,不能改变

1.2 数组的定义格式

动态初始化创建数组: 指定数组的长度,数组中有默认的初始化值，数据类型变量名 = 对象;定义了一个变量:int[] arr1 = new int[5];
静态初始化创建数组: 创建一个包含指定元素的数组，数组中存储几个元素,数组的长度就是几。创建一个double类型的数组,里边包含默认值1.1,2.2,3.3 double[] arr2 = new double[]{1.1,2.2,3.3};
静态初始化简化模式创建一个double类型的数组,里边包含默认值1.1,2.2,3.3。 double[] arr4 = {1.1,2.2,3.3};省略了new double[],JVM会默认给我们加上

/*
    需求:
    1.定义一个byte类型,长度为20的数组(动态)
    2.定义一个float类型,里边包含默认值2.2,3.3,8.8的数组(静态)
    3.定义一个char类型,里边包含默认值'a','b','c','d','e'的数组(静态)
    4.定义一个String类型,里边包含默认值"张三","李四","王五","赵六","田七"的数组(静态)
 */
public class Demo02Array {
    public static void main(String[] args) {
        //1.定义一个byte类型,长度为20的数组(动态)
        byte[] arr1 = new byte[20];
        //byte arr1[] = new byte[20];
        //2.定义一个float类型,里边包含默认值2.2,3.3,8.8的数组(静态)
        float[] arr2 = {2.2F,3.3F,8.8F};
        //3.定义一个char类型,里边包含默认值'a','b','c','d','e'的数组(静态)
        char[] arr3 = {'a','b','c','d','e'};
        //4.定义一个String类型,里边包含默认值"张三","李四","王五","赵六","田七"的数组(静态)
        String[] arr4 = {"张三","李四","王五","赵六","田七"};
    }
}

1.3 数组的使用格式

数组的使用主要通过数组名和索引(下标,角标,房间号)来访问数组中的元素

格式: 数组名[索引]

索引的范围:0 到数组长度-1 数组的长度是20: 索引[0-19]

int[] arr = new int[10];{0,0,0,0,0,0,0,0,0,0}

1.取出指定索引处的元素\

直接输出 System.out.println(数组名[索引]);
System.out.println(arr[1]);
b.把取出的元素,赋值给一个变量数组的数据类型变量名 = 数组名[索引];
int a = arr[1];

2.给指定索引处的元素赋值
数组名[索引] = 数据值;
arr[1] = 88; {0,88,0,0,0,0,0,0,0,0}

public class Demo03Array {
    public static void main(String[] args) {
        //定义一个长度为10的int类型的数组
        int[] arr = new int[10];//{0,0,0,0,0,0,0,0,0,0}
        //1.取出指定索引处的元素
        // a.直接输出 System.out.println(数组名[索引]);
        System.out.println(arr[1]);//0
        System.out.println(arr[3]);//0
        //b.把取出的元素,赋值给一个变量  数组的数据类型 变量名 =  数组名[索引];
        int a = arr[5];
        System.out.println("a:"+a);//a:0
        //2.给指定索引处的元素赋值
        arr[1] = 88;//{0,88,0,0,0,0,0,0,0,0}
        arr[2] = 99;//{0,88,99,0,0,0,0,0,0,0}
        System.out.println(arr[0]);//0
        System.out.println(arr[1]);//88
        System.out.println(arr[2]);//99
    }
}

/*
    需求:
        定义一个String类型,里边包含默认值"张三","李四","王五","赵六","田七"的数组(静态)
        1.直接打印数组中的第二个元素
        2.给数中的第二个元素赋值为:"尼古拉斯赵四"
        3.把数组中的第二个元素取出来,赋值给一个String类型的变量
        4.打印变量的值
 */
public class Demo04Array {
    public static void main(String[] args) {
        String[] arr = {"张三","李四","王五","赵六","田七"};
        //1.直接打印数组中的第二个元素
        System.out.println(arr[1]);//李四
        //2.给数中的第二个元素赋值为:"尼古拉斯赵四"
        arr[1] = "尼古拉斯赵四";//{"张三","尼古拉斯赵四","王五","赵六","田七"};
        //3.把数组中的第二个元素取出来,赋值给一个String类型的变量
        String s = arr[1];
        //4.打印变量的值
        System.out.println("s:"+s);//s:尼古拉斯赵四
    }
}

1.4数组的遍历

/*
    遍历数组(遍历数组):依次打印数组中的元素
 */
public class Demo05Array {
    public static void main(String[] args) {
        String[] arr = {"张三","李四","王五","赵六","田七","张三","李四","王五","赵六","田七","张三","李四","王五","赵六","田七"};
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
        System.out.println("-----------------------");
        for (int i = 0; i < 5; i++) {
            System.out.println(i);
        }
        System.out.println("-----------------------");
        for (int i = 0; i < 5; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("-----------------------");
        //数组中有一个属性,叫length,可以获取数组的长度(元素个数)
        int len = arr.length;
        System.out.println(len);//15
        System.out.println("-----------------------");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

1.5.数组操作的常见问题

/*
    数组操作的常见问题：
 */
public class Demo07Array {
    public static void main(String[] args) {
        //1.定义错误
        //int[] arr = new int[];//错误，动态初始化没有指定长度
        //int[] arr = new int[3]{10,20,30};//错误，静态初始化，不能指定长度
        //2.索引越界异常:访问了数组的不存在的索引,就会抛出异常
        int[] arr = {10,20,30};//索引:0,1,2
        System.out.println(arr[1]);//20
        //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
        //3.空指针异常:把数组的值赋值为null,就相当于把数组的房子拆了,就没有了,就不能在使用了
        arr = null;
        System.out.println(arr[1]);//NullPointerException
    }
}

6.数组练习

/*
    请定义类,并添加main()方法,按以下要求定义数组：
    1. 请定义5个长度的数组,可以存储并打印以下5名学员的姓名：
            "杨幂","刘恺威","古力娜扎","柳岩","郭德纲"
    2. 请定义5个长度的数组,可以存储并打印5名学员的性别：
                '女',  '男',  '女',  '女',  '男'
    3. 请定义5个长度的数组,可以存储并打印5名学员的身高：
             1.65,   1.85,   1.70,   1.68,   1.85
    4. 请将以上三个数组"反向遍历",并打印每个元素！！
 */
public class Demo06Test {
    public static void main(String[] args) {
        String[] arr1 = {"杨幂","刘恺威","古力娜扎","柳岩","郭德纲" };
        //遍历数组的快捷键: 数组名.fori 回车
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i]+" ");
        }
        System.out.println();//换行
        System.out.println("----------------------------------------");
        char[] arr2 = {'女',  '男',  '女',  '女',  '男'};
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i]+ " ");
        }
        System.out.println();
        System.out.println("----------------------------------------");
        double[] arr3 = {1.65,   1.85,   1.70,   1.68,   1.85};
        for (int i = 0; i < arr3.length; i++) {
            System.out.print(arr3[i]+" ");
        }
        System.out.println();
        System.out.println("----------------------------------------");
        // 4. 请将以上三个数组"反向遍历",并打印每个元素！！
        for (int i = arr1.length-1; i >=0 ; i--) {
            System.out.println(arr1[i]);
        }
    }
}

二、数组的常见操作

2.1 选数组中符合条件的元素

需求:有以下数组，存储了6名学员的体重： int[] arr = {120,130,110,125,128,164};请编程计算并打印：大于等于130斤以上的体重值。

/*
    常见操作一：挑选
        有以下数组，存储了6名学员的体重：
        int[] arr = {120,130,110,125,128,164};
        请编程计算并打印：大于等于130斤以上的体重值。
    分析:
        1.定义数组
        2.遍历数组,获取数组中的每一个元素
        3.判断元素>=130
        4.则打印元素
 */
public class Demo01ArrayTest {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {120,130,110,125,128,164};
        //2.遍历数组,获取数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
            //3.判断元素>=130
            if(arr[i]>=130){
                //4.则打印元素
                System.out.println(arr[i]);
            }
        }
    }
}

2.2 数组中元素求和

需求:有以下数组，存储了6名学员的体重：int[] arr = {120,130,110,125,128,164}; 请编程计算并打印这6名学员的总体重。

/*
    常见操作二：求和
        有以下数组，存储了6名学员的体重：
        int[] arr = {120,130,110,125,128,164};
        请编程计算并打印这6名学员的总体重。
    分析:
        1.定义一个数组
        2.定义一个int类型的变量,初始值为0,记录累加求和
        3.遍历数组,获取每一个元素
        4.累加求和
        5.遍历结束,打印求和结果
 */
public class Demo02ArrayTest {
    public static void main(String[] args) {
        //1.定义一个数组
        int[] arr = {120,130,110,125,128,164};
        //2.定义一个int类型的变量,初始值为0,记录累加求和
        int sum = 0;
        //3.遍历数组,获取每一个元素
        for (int i = 0; i < arr.length; i++) {
            //4.累加求和
            sum+=arr[i];
        }
        //5.遍历结束,打印求和结果
        System.out.println("sum:"+sum);
    }
}

2.3 数组中元素求平均值

需求:有以下数组，存储了6名学员的体重： int[] arr = {120,130,110,125,128,164}; 请编程计算并打印这6名学员的平均体重。

/*
    常见操作三：求平均值
        有以下数组，存储了6名学员的体重：
        int[] arr = {120,130,110,125,128,164};
        请编程计算并打印这6名学员的平均体重。
    分析:
        1.定义一个数组
        2.定义一个int类型的变量,初始值为0,记录累加求和
        3.遍历数组,获取每一个元素
        4.累加求和
        5.遍历结束,使用和/数组的长度,计算平均值
        6.打印平均值
 */
public class Demo03ArrayTest {
    public static void main(String[] args) {
        //1.定义一个数组
        int[] arr = {120,130,110,125,128,164};
        //2.定义一个int类型的变量,初始值为0,记录累加求和
        int sum = 0;
        //3.遍历数组,获取每一个元素
        for (int i = 0; i < arr.length; i++) {
            //4.累加求和
            sum+=arr[i];
        }
        //5.遍历结束,使用和/数组的长度,计算平均值
        int avg = sum/arr.length;
        //6.打印平均值
        System.out.println("平均体重为:"+avg);
    }
}

2.4 求数组中元素的最大值

需求:有以下数组，存储了6名学员的体重：int[] arr = {120,130,110,125,128,164}; 请编程计算并打印这6名学员的最大体重。

/*
    常见操作四：求最大值
        有以下数组，存储了6名学员的体重：
        int[] arr = {120,130,110,125,128,164};
        请编程计算并打印这6名学员的最大体重。
    分析:
        1.定义一个数组
        2.定义一个变量max,把数组的第一个元素赋值给max,最为最大值
        3.遍历数组,获取数组中的其他元素
        4.使用遍历得到的元素和最大值比较
        5.元素>最大值,则把元素赋值给最大值max
        6.遍历结束,打印最大值
 */
public class Demo04ArrayTest {
    public static void main(String[] args) {
        //1.定义一个数组
        int[] arr = {120,130,110,125,128,164};
        //2.定义一个变量max,把数组的第一个元素赋值给max,最为最大值
        int max = arr[0];
        //3.遍历数组,获取数组中的其他元素
        for (int i = 1; i < arr.length; i++) {
            //4.使用遍历得到的元素和最大值比较
            if(arr[i]>max){
                //5.元素>最大值,则把元素赋值给最大值max
                max = arr[i];
            }
        }
        //6.遍历结束,打印最大值
        System.out.println("max:"+max);
        /*
            常见操作四：求最小值
            有以下数组，存储了6名学员的体重：
            int[] arr = {120,130,110,125,128,164};
            请编程计算并打印这6名学员的最小体重。
         */
        //2.定义一个变量min,把数组的第一个元素赋值给min,最为最小值
        int min = arr[0];
        //3.遍历数组,获取数组中的其他元素
        for (int i = 1; i < arr.length; i++) {
            //4.使用遍历得到的元素和最小值比较
            if(arr[i]<min){
                //5.元素<最小值,则把元素赋值给最小值min
                min = arr[i];
            }
        }
        //6.遍历结束,打印最小值
        System.out.println("min:"+min);
    }
}

2.5统计符合条件元素的个数

需求:有以下数组，存储了6名学员的体重：int[] arr = {120,130,110,125,128,164}; 请编程计算并打印：大于、等于130的元素的个数。

/*
    常见操作五：统计
        有以下数组，存储了6名学员的体重：
        int[] arr = {120,130,110,125,128,164};
        请编程计算并打印：大于、等于130的元素的个数。
   分析:
    1.定义一个数组
    2.定义一个统计变量,初始值为0
    3.遍历数组,获取数组中的每一个元素
    4.判断元素是否大于等于130
    5.是则统计变量++
    6.循环结束,打印统计的个数
 */
public class Demo05ArrayTest {
    public static void main(String[] args) {
        //1.定义一个数组
        int[] arr = {120,130,110,125,128,164};
        //2.定义一个统计变量,初始值为0
        int count = 0;
        //3.遍历数组,获取数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
            //4.判断元素是否大于等于130
            if(arr[i]>=130){
                //5.是则统计变量++
                count++;
            }
        }
        //6.循环结束,打印统计的个数
        System.out.println("count:"+count);
    }
}

2.6 从控制台接收数据

需求:有以下数组：int[] arr = new int[5];请编程从控制台接收5名学员的年龄，并存储到数组中。遍历数组，打印每个年龄值。

import java.util.Scanner;
/*
    常见操作六：从控制台接收数据
        有以下数组：int[] arr = new int[5];
        请编程从控制台接收5名学员的年龄，并存储到数组中。
        遍历数组，打印每个年龄值。
    分析:
        1.定义一个int类型长度为5的数组
        2.创建Scanner对象,为Scanner变量赋值
        3.遍历数组,获取数组中的每一个元素
        4.使用Scanner类中的方法nextInt,获取用户键盘输入年龄
        5.把年龄赋值给元素
        6.再一次遍历数组,打印年龄
 */
public class Demo06ArrayTest {
    public static void main(String[] args) {
        //1.定义一个int类型长度为5的数组
        int[] arr = new int[5];
        //2.创建Scanner对象,为Scanner变量赋值
        Scanner sc = new Scanner(System.in);
        //3.遍历数组,获取数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
            //4.使用Scanner类中的方法nextInt,获取用户键盘输入年龄
            System.out.println("请输入第"+(i+1)+"学生的年龄:");
            int age = sc.nextInt();
            //5.把年龄赋值给元素
            arr[i] = age;
        }
        //6.再一次遍历数组,打印年龄
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

2.7 随机数填充数组

需求:有以下数组：int[] arr = new int[5];请编程随机生成5个1—100的整数，并存储到数组中。遍历数组，打印每个值。

import java.util.Random;
/*
    常见操作七：随机数填充数组
        有以下数组：int[] arr = new int[5];
        请编程随机生成5个1—100的整数，并存储到数组中。
        遍历数组，打印每个值。
    分析:
        1.定义一个int类型长度为5的数组
        2.创建Random对象,为Random类型的变量赋值
        3.遍历数组,获取每一个元素
        4.使用Random对象中的方法nextInt,随机获取5个1-100之间的数,给元素赋值
        5.再次遍历数组,获取每一个元素
 */
public class Demo07ArrayTest {
    public static void main(String[] args) {
        //1.定义一个int类型长度为5的数组
        int[] arr = new int[5];
        //2.创建Random对象,为Random类型的变量赋值
        Random r = new Random();
        //3.遍历数组,获取每一个元素
        for (int i = 0; i < arr.length; i++) {
            //4.使用Random对象中的方法nextInt,随机获取5个1-100之间的数,给元素赋值
            arr[i] = r.nextInt(100)+1;
        }
        //5.再次遍历数组,获取每一个元素
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

三、数组综合案例

3.1 综合案例1-成绩分析系统

需求: 分析学员的成绩，计算：平均分、最高分、最低分，现以一个班级10个同学的数学成绩为例，进行统计。求这个班级的数学平均成绩，最高分，最低分。

/*
    综合案例1-成绩分析系统
        分析学员的成绩，计算：平均分、最高分、最低分
        现以一个班级10个同学的数学成绩为例，进行统计。求这个班级的数学平均成绩，最高分，最低分。
    分析:
        1.定义一个数组,存储10个同学的数学成绩
        2.定义一个变量sum,初始值为0,记录累加求和
        3.定义一个变量max,把数组的第一个元素赋值给max,最为最高分
        4.定义一个变量min,把数组的第一个元素赋值给min,最为最低分
        5.遍历数组,获取数组中的每一个元素
        6.使用sum和元素进行累加求和
        7.元素>max,max=元素
        8.元素<min,min=元素
        9.循环结束之后,根据求和sum,计算平均值
        10.打印平均分、最高分、最低分
 */
public class Demo01Test {
    public static void main(String[] args) {
        //1.定义一个数组,存储10个同学的数学成绩
        int[] arr = {100,99,88,98,76,59,100,95,98,2};
        //2.定义一个变量sum,初始值为0,记录累加求和
        int sum = 0;
        //3.定义一个变量max,把数组的第一个元素赋值给max,最为最高分
        int max = arr[0];
        //4.定义一个变量min,把数组的第一个元素赋值给min,最为最低分
        int min = arr[0];
        //5.遍历数组,获取数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
            //6.使用sum和元素进行累加求和
            sum+=arr[i];
            //7.元素>max,max=元素
            if(arr[i]>max){
                max = arr[i];
            }
            //8.元素<min,min=元素
            if(arr[i]<min){
                min = arr[i];
            }
        }
        //9.循环结束之后,根据求和sum,计算平均值
        double avg = sum/(double)arr.length;
        //10.打印平均分、最高分、最低分
        System.out.println("平均分为:"+avg);
        System.out.println("最高分为:"+max);
        System.out.println("最低分为:"+min);
    }
}

3.2 综合案例2-双色球开奖核心算法

1、出奖号码由6个红球 + 1蓝球组成

2、每个红球是1—33之间的一个数字

3、蓝球是1—16之间的一个数字

4、本题目咱时不考虑：重复、红球排序的问题

import java.util.Random;
/*
    综合案例2-双色球开奖核心算法
        1、出奖号码由6个红球 + 1蓝球组成
        2、每个红球是1—33之间的一个数字
        3、蓝球是1—16之间的一个数字
        4、本题目咱时不考虑：重复、红球排序的问题
    分析:
        1.定义一个长度为6的int类型数组,用来存储红球
        2.创建Random对象
        3.遍历数组,获取数组中每一个元素
        4.使用Random获取6个1-33之间的随机数,依次赋值给数组中的元素
        6.定义一个变量,使用Random获取1个1-16之间的随机数,给变量赋值
        7.遍历数组,打印红球,打印篮球
 */
public class Demo02Test {
    public static void main(String[] args) {
        //1.定义一个长度为6的int类型数组,用来存储红球
        int[] arr = new int[6];
        //2.创建Random对象
        Random r = new Random();
        //3.遍历数组,获取数组中每一个元素
        for (int i = 0; i < arr.length; i++) {
            //4.使用Random获取6个1-33之间的随机数,依次赋值给数组中的元素
            arr[i] = r.nextInt(33)+1;
        }
        //6.定义一个变量,使用Random获取1个1-16之间的随机数,给变量赋值
        int blue = r.nextInt(16)+1;
        //7.遍历数组,打印红球,打印篮球
        System.out.print("红球:");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println("蓝球:"+blue);
    }
}

3.3综合案例3-盗墓解密程序

有一个古老的国王墓地，谁能找到解密程序就将能打开墓室大门；两个小偷在找到墓地后于是就开始研究规则

规则为：一串数字无论正着读还是反着读都是一样的。如：1234321 是有效的；345643 是无效的。请你编程实现该程序的判断。

/*
    综合案例3-盗墓解密程序
        有一个古老的国王墓地，谁能找到解密程序就将能打开墓室大门；
        两个小偷在找到墓地后于是就开始研究规则
        规则为：一串数字无论正着读还是反着读都是一样的。
            如：1234321 是有效的；345643  是无效的。
        请你编程实现该程序的判断。
    分析:
        1.定义一个数组,存储小偷输入的密码
        2.定义一个布尔类型的变量,初始值为true,作为一个标记,用于判断是否解密成功
        3.遍历数组,获取每一个元素
        4.在循环中依次比较首尾元素是否相同
        5.首尾元素不相同,修改为false,结束循环
        6.循环结束了,对布尔值进行判断
            true:解密成功
            false:解密失败
 */
public class Demo03Test {
    public static void main(String[] args) {
        //1.定义一个数组,存储小偷输入的密码
        int[] arr = {5,4,3,2,1,2,3,4,5};
        //2.定义一个布尔类型的变量,初始值为true,作为一个标记,用于判断是否解密成功
        boolean flag = true;
        //3.遍历数组,获取每一个元素
        for (int i = 0; i < arr.length/2; i++) {
            //4.在循环中依次比较首尾元素是否相同
            if(arr[i]!=arr[arr.length-1-i]){
                //5.首尾元素不相同,修改为false,结束循环
                flag = false;
                break;
            }
        }
        //6.循环结束了,对布尔值进行判断
        if(flag==true){
            //true:解密成功
            System.out.println("恭喜您,解密成功,可以打开墓门了!");
        }else{
            //false:解密失败
            System.out.println("恭喜您,解密失败,陵墓马上就要销毁!");
        }
    }
}

后记

喜欢我的文章的朋友点点喜欢、收藏，也欢迎朋友们评论区留下你的意见和建议，恕毅在此拜谢！

Java基础篇 - 数组

前言