JAVA数组（知识点+实例）

1. 数组的定义

是Java中有序的元素序列

2. 数组的静态初始化

初始化时由程序员显示指定每个数组元素的初始值，由系统决定数组的长度

3. 数组的元素访问

索引是从0开始访问，以下列代码为例。获取的元素为9

int[4] arr1 = {1,3,4,8,9};

4. 数组的两种格式

完整格式：数据类型 [ ]  数组名 = new 数据类型 [ ]  {，，，}；

int []arr1 = new int{1,2,3,4,5};

简写模式：数据类型 [ ]  数组名 = {，，，}；

double []arr2 = {1.2,1.3,1.4,1.5};

5. 数组知识扩展

int[] arr1 = new int[] {1,2,3,4,6};

1. 输出int类型地址值：

   [I@4554617c

2. [   表示数组
3. I   表示数据类型
4. @   表示间隔符号（固定格式）
5. 4554617c   数组真正的地址值

 6. 获取数组的第一个元素

public class ArrayTest01 {
    public static void main(String[] args) {


        //获取数组的第一个元素
        //格式：数组名[索引]
        int[] arr3 = {3,5,7,8,9,};
        int number = arr3[0];


        //把获取的数据存储到变量当中
        //格式：数组名[索引] =具体的数据或变量
        //细节：一旦覆盖之后，之前的数据就不存在了
        arr3[2] = 80;
        System.out.println(arr3[2]);
    }
}

7. 实例

1. 定义一个数组，遍历数组中的每一个元素。将数组中的每一个元素求和

public class ArrayTest02 {
    public static void main(String[] args) {

        int sum = 0;

        //定义一个数组
        int[] arr = {1,2,3,4,5};

        //遍历数组中的每一个元素
        //i依次表示数组里面的每一个索引
        //arr[i]依次表示数组里面的每一个元素
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);

            sum= sum + arr[i];
        }
        System.out.println(sum);
    }
}

2. 定义一个数组，控制台输出3的倍数，并统计3的倍数的个数

public class ArrayTest03 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {1,2,3,4,5,6,7,8,9,10};

        //定义一个变量，负责统计
        int count = 0;

        //遍历数组里面的每一个元素
        for (int i = 0; i < arr.length; i++) {
            //System.out.println(arr[i]);
            if (arr[i] % 3 == 0){

                //i依次表示数组里面的每一个索引
                //arr[i]依次表示数组的每一个元素
                System.out.println(arr[i]);
                count++;
            }
        }
        System.out.println(count);
    }
}

3. 定义一个数组，由程序判断出这个数组中的最大元素

public class ArrayTest06 {
    public static void main(String[] args) {

        //定义一个数组
        int[] arr = {45,89,49,12,46,25};

        //max的初始化值一定是数组中的值arr[0]
        //暂时规定 0 索引对应的元素为数组最大值
        int max = arr[0];

        //循环的开始条件为0的话，那么第一次循环的时候 0 索引对应的数会和自己比较一下，但是结果不受影响，可以从1开始
        //利用for循环遍历每个数组
        for (int i = 0; i < arr.length; i++) {

            //如果当前遍历得到的元素大于暂时规定 0 索引对应的元素
            if (arr[i] > max){

                //记录当前值
                //那么将这个遍历得到的元素赋值给max
                //在拿着这个元素和其他数比较，直到整个数组中的最大值出现
                max = arr[i];
            }
        }
        System.out.println(max);
    }
}

 4. 从1~100之间随机生成10个数字存到数组中，分别求出数据的和，平均数，小于平均数的个数

import java.util.Random;

public class ArrayTest07 {
    public static void main(String[] args) {

        //定义一个数组，动态初始化，长度为10
        int[] arr = new int[10];

        //创建随机数对象
        Random r = new Random();

        //遍历，得到10个随机数据
        for (int i = 0; i < arr.length; i++) {
            int number = r.nextInt(100) + 1;

            //将得到的随机数据存到数组中
            arr[i] = number;
        }

        //定义一个和变量
        int sum = 0;

        //遍历数组
        for (int i = 0; i < arr.length; i++) {

            //得到的每一个元素进行相加，赋值给sum
            sum = sum + arr[i];
        }
        System.out.println("和为" + sum);

        //平均数 = 和 / 个数(长度)
        int avg = sum / arr.length;

        System.out.println("平均数为" + avg);

        //定义一个统计变量
        int count = 0;

        //循环遍历，拿得到的每一个随机数和平均数比较
        for (int i = 0; i < arr.length; i++) {

            //判断语句：如果为真累加一次
            if (arr[i] < avg) {
                count++;
            }
        }
        System.out.println("小于平均数的个数有" + count + "个");

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

5. 定义一个数组，将其中的元素元素顺序打乱

import java.util.Random;

public class ArrayTest09 {
    public static void main(String[] args) {

        //定义一个数组
        int[] arr = {1, 2, 3, 4, 5};

        //循环遍历数组，从 0 索引开始遍历数组
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {

            //生成一个随机索引
            int randomIndex = r.nextInt(arr.length);

            //拿着随即索引指向的元素，跟i索引指向的元素进行交换
            int temp = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = temp;
        }

        //当循环结束之后，那么数组中的所有数据已经打乱
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

恭喜努力的你有掌握一部分知识！

生命的多少用时间计算，生命的价值用贡献计算。

——许愿 . 共勉