JAVA-数组

数组

定义

用来存储一批同种类型的数据的容器

例子

int [ ] arr = {2,3,6,7,3,2};

String[] names = {"一","二","三"}

作用

批量数据的存储--简洁代码

数组变量名中存储的是数组在内存中的地址，数组是一种引用数据类型

数组的定义和访问

静态初始化数组

数据类型[] 数组名 = new 数据类型[]{元素1，元素2};

数据类型[] 数组名 = {元素1，元素2};

定义数组时直接给数组赋值

数据类型[] 数组名 也可以写成 数据类型 数组名[]

什么类型的数组只能存放什么类型的数据

public class jingtaidefine {
    public static void main(String[] args) {
        //数组的定义方式-静态初始化数组
        //完整格式
        //1、数据类型[] 数组名 = new 数据类型【】{元素1，元素2};
        int[] ages = new int[]{18,22,24};
        double[] scores = new double[]{89.9,88.5,76,69.5};
        //简化格式
        //1、数据类型[] 数组名 = {元素1，元素2};
        int[] ages2 = {18,22,24};
        double[] scores2 = {89.9,88.5,76,69.5};
        System.out.println(ages);
        System.out.println(scores);
    }
}

数组的访问

访问

public class jingtaifangwen {
    public static void main(String[] args) {
        int[] arr = {12,24,36};
        //1、访问数组的全部数据
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        //System.out.println(arr[3]);//报错

    }
}

修改

        //2、数组中数据的修改
        arr[0] = 66;
        arr[2] = 100;
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println("---------");

长度

 //3、访问数组中元素个数：数组名.length
        System.out.println(arr.length);

获取最大索引值

arr.length - 1,前提是数组中存在着数据

  //4、数组的最大索引值
        System.out.println(arr.length - 1);

数组的遍历

一个一个数据的访问

public class jingtaibianli {
    public static void main(String[] args) {
        int[] ages = {12,24,36,48};
        //ages.fori
        for (int i = 0; i < ages.length; i++) {
            //ages[i].sout
            System.out.println(ages[i]);
        }
    }
}

【案例】求和

某部门5名员工的销售额分别是16，26，36，6，100，计算出总销售额

public class jingtaiTest {
    public static void main(String[] args) {
        //某部门5名员工的销售额分别是16，26，36，6，100，计算出总销售额
        //定义数组存储销售额
        int[] money = {16,26,36,6,100};
        //定义变量表示总额
        int sum = 0;
        //循环遍历累加
        for (int i = 0; i < money.length; i++) {
            sum += money[i];
        }
        System.out.println("员工销售总额为"+sum);
    }
}

动态初始化数组

定义时不存入具体的元素值，只确定数组存储的数据类型和数组的长度

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

int[] arr = new int [3];

定义

默认规则

public class dongtaidefine {
    public static void main(String[] args) {
        int[] ages = new int[3];
        System.out.println(ages[0]);
        System.out.println(ages[1]);
        System.out.println(ages[2]);
        System.out.println("-----------");

        ages[0] = 12;
        ages[1] = 24;
        ages[2] = 36;
        System.out.println(ages[0]);
        System.out.println(ages[1]);
        System.out.println(ages[2]);
    }
}

【案例】

录入歌唱比赛六位评委的打分，录入完毕后立即输出平均分为得分

import java.util.Scanner;

public class dongtaiTest {
    public static void main(String[] args) {
//        定义动态初始化数组 double
        double[] scores = new double[6];
//        定义一个扫描器
        Scanner sc = new Scanner(System.in);
//        遍历数组中的每个位置，录入评委的分数存入数组中去
        for (int i = 0; i < scores.length; i++) {
            System.out.println("请输入第"+ ( i + 1 ) +"个评委的打分");
            double score = sc.nextDouble();
            scores[i] = score;
        }
//        遍历数组中的元素求和，得到平均值
        double sum = 0;
        for (int i = 0; i < scores.length; i++) {
            sum += scores[i];
        }
        System.out.println("选手的最终得分为："+ sum / scores.length);
    }
}

常见案例

数组的反转

使用for循环，控制让数组前后位置的元素依次交换

public class 数组反转 {
    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 temp = arr[j];
            //赋值
            arr[j] = arr[i];
            //赋值
            arr[i]=temp;
        }
        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

如何实现前后交换

1. 定义一个临时变量记住后一个位置处的元素值
2. 再把前一个位置处的元素值赋值给后一个位置处
3. 最后把临时变量记住的后一个位置的值赋值给前一个位置处

随机排名

import java.util.Random;
import java.util.Scanner;

public class 随机排名 {
    public static void main(String[] args) {
        //定义动态化数组
        int [] codes = new int[5];
        //录入工号
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < codes.length; i++) {
            System.out.println("请输入第"+ (i+1) +"位员工的工号：");
            int code = sc.nextInt();
            codes[i] = code;
        }
        //打乱数组中元素顺序
        Random r = new Random();
        for (int i = 0; i < codes.length; i++) {
            //每遍历到一个数据，都随机一个数组索引范围内的值，然后让当前遍历的数据与该索引位置处数据交换
            int index = r.nextInt(codes.length);
            //临时变量记住index值
            int temp = codes[index];
            //i处的值赋给index
            codes[index] = codes[i];
            //index原来的值赋给i
            codes[i] = temp;
        }
        //遍历数组中工号输出
        for (int i = 0; i < codes.length; i++) {
            System.out.print(codes[i] + " ");
        }
    }
}

​​​​​​​

1. 定义一个动态初始化的数组用于录入员工的工号
2. 遍历数组中的每个元素
3. 每遍历到一个数据，都随机一个索引值出来，让当前数据与该索引位置处的数据进行交换
4. 输出数组中的内容即可

debug

IDEA自带的断点调试工具，可以控制代码从断点开始一行一行的执行，然后详细观看程序执行的情况

使用步骤

在需要控制的代码行左侧，点击一下，形成断点

选择使用Debug方式启动程序，启动后程序会在断点暂停

控制代码一点一点的执行