public class ArrayDemo1 {
    public static void main(String[] args) {
        //格式
        //静态初始化

        //需求1: 定义数组存储5个学生的年龄
        int[] arr1 = new int[]{12,23,32,45};
        int[] arr2 = {12,23,32,45};
        //需求2: 定义数组存储3个学生的姓名
        String[] arr3 = new String[]{"张三","李四","万五"};
        String[] arr4 = {"张三","李四","万五"};
        //需求3: 定义数组存储4个学生的身高
        double[] arr5 = new double[]{1.90,1.76,1.56};
        double[] arr6 ={1.90,1.76,1.56};
    }
}

打印

索引

利用索引对数组中的元素进行访问
1. 获取数组里面的元素
 格式 : 数组名[索引]

public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        //获取数组中的第一个元素
        //其实就是0索引上对应的元素
        int number = arr[0];
        System.out.println(number);//1

    }
}

2. 把 数据存储到数组中
格式 :  数组名[索引] = 具体数据/ 变量
细节 : 一旦覆盖之后,原来的数据就不存在了

public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        //2. 把 数据存储到数组中
        //格式 :  数组名[索引] = 具体数据/ 变量
        //细节 : 一旦覆盖之后,原来的数据就不存在了
        arr[0] = 100;
        System.out.println(arr[0]);//100
    }
}

数组遍历

代码练习:

public class ArrayDemo3 {
    public static void main(String[] args) {
        //1. 定义数组
        int[] arr = {1,2,3,4,5};
        //2. 获取数组里面所有的元素
        //格式: 数组名[索引]
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

练习1:遍历数组并求和

分析:

1. 定义数组,添加数据

2. 遍历数组得到每一个数据,累积求和

i 依次表示数组里面的每一个索引

arr[i] 依次表示数组里面的每一个元素

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

        //1. 定义数组,添加数据
        int[] arr = {1,2,3,4};

        //定义求和变量
        int sum =0;
        //2. 遍历数组得到每一个数据,累积求和
        for (int i = 0; i < arr.length; i++) {
            //i  依次表示数组里面的每一个索引
            //arr[i] 依次表示数组里面的每一个元素
            sum = sum + arr[i];
        }
        //当循环结束之后,sum 的值是累加之后的每一个结果
        System.out.println(sum);
    }
}

练习2:统计个数

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

        //1. 定义数组,存储数据
        int[] arr = {1,2,3,4,5,6,7,8,9,10};

        //定义一个变量,用来统计个数
        int count =0;

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

            //3. 判断当前的元素是否为3的倍数,如果是那么统计变量就需要自增一次
            if(arr[i] % 3 ==0){
                 count++;
            }
        }
        //当循环结束之后,sum 的值是累加之后的每一个结果
        System.out.println("数组中能被3整除的数字有"+ count);
    }
}

练习3:变化数据

public class ArrTest3 {
    public static void main(String[] args) {
        //1. 分析
        //定义一个数组,存 1,2,4,5,6,7
        int[] arr = {1, 2, 4, 5, 6, 7};
        //2. 遍历数组得到每一个元素
        for (int i = 0; i < arr.length; i++) {
            //3. 对每一个元素进行判断
            //奇数
            //偶数
            if (arr[i] % 2 == 0) {
                //偶数  二分之一
                arr[i] = arr[i] / 2;
            } else {
                //奇数  扩大两倍
                arr[i] = arr[i] * 2;
            }
        }
        //遍历数组
        //一个循环尽量只做一个件事
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

数组的动态初始化

数组的动态初始化和静态初始化的区别

数组的常见问题

public class ArrayDemo4 {
    public static void main(String[] args) {
        //1. 定义数组
        int[] arr = {1,2,3,4,5};
        //2. 长度 :5
        //最小索引: 0
        //最大索引: 4(数组的长度)
        System.out.println(arr[10]);
    }
}

异常

小结:

索引越界异常

原因: 访问了不存在的索引

避免: 索引的范围

最小索引: 0

最大索引: 4 (数组的长度 - 1)

数组常见操作

练习1:求最值

public class ArrTest4 {
    public static void main(String[] args) {
        //1.定义数组用来存储5个值
        int[] arr = {33,4,22,44,55};
        //2. 定义一个变量max用来存储最大值
        //临时认为0索引的数据是最大的
        int max = arr[0];
        //3. 循环获取数组中的每一个元素
        //拿着每一个元素跟max进行比较
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max){
                max = arr[i];
            }
        }
        //当循环结束之后,max记录的就是数组中的最大值
        System.out.println(max);
    }
}

扩展问题:

为什么max 要记录为 arr[0] ,默认值不能为 0 吗? 不能

max 的初始值一定要是数组中的值.

循环中开始条件一定是 0 吗 ?

循环中开始条件如果为 0 ,那么第一次循环的时候就是自己跟自己比较,对结果没有任何影响,但是效率低,为了提高效率,减少一次循环的次数,循环开始的条件可以写 1 .

练习2 : 遍历数组求和

生成1~100之间的随机数

public class ArrTest5 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = new int[10];
        //2. 把随机数存入到数组当中
        Random r = new Random();

        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]+"  ");
        }
    }
}

练习3:

public class ArrTest7 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {1, 2, 3, 4, 5};
        //2. 利用循环交换数据
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            //交换变量i 和 变量j 指向的元素
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        //当循环结束之后,那么数据中的数据就实现了头为交换
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"  ");
        }
    }
}

练习4:

import java.util.Random;

public class ArrTest8 {
    public static void main(String[] args) {
 /*     //难点
        //如何获取数组中的随机索引
        int[] arr = {1, 2, 3, 4, 5};
        //2. 索引范围 1, 2, 3, 4, 5
        Random r = new Random();
        int randomIndex = r.nextInt(arr.length);
        System.out.println(randomIndex);*/

        int[] arr = {1, 2, 3, 4, 5};
        //循环遍历数组,从 - 索引开始打乱数据的顺序
        Random r = new Random();
        //2, 循环遍历数组
        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.print(arr[i]+ "  ");
        }
    }
}