标签：arr int System 数组 public out

数组

数组介绍

数组：数组指的是一种容器，可以用来存储同种数据类型的多个值

数组容器在存储数据的时候，需要结合隐式转换考虑。
例如：int类型的数组容器（boolean×、byte√、short√、int√、double×）
例如：double类型的数组容器（byte√、short√、int√、long√、float√、double√）
建议：容器的类型，和存储的数据类型保持一致

数组的定义和静态初始化

数组的定义

格式一：数据类型 [] 数据名

范例：int [] array
格式二：数据类型数据名 []

范例：int array []

数组的初始化

初始化：就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程。

数组的静态初始化

完整格式：数据类型 [] 数组名 = new 数据类型[] {元素1,元素2,元素3...};
范例：int [] array = new int []{11,22,33};
范例：double [] array = new double [] {11.1,22.2,33.3};
简化格式：数据类型 [] 数组名 = {元素1,元素2,元素3...};
范例：int [] array = {11,22,33};
范例：double [] array = {11.1,22.2,33.3};

public class ArrayDemo1 {
    public static void main(String[] args) {
        //格式：
        //静态初始化
        //完整格式：
        //数据类型 [] 数组名 = new 数据类型[] {元素1,元素2,元素3...};
        //简化格式：
        //数据类型 [] 数组名 = {元素1,元素2,元素3...};

        //需求1：定义数组存储5个学生的年龄
        int[] arr1 = new int[]{11,12,13,14,15};
        int[] arr2 = {11,12,13,14,15};
        //需求2：定义数组存储3歌学生的姓名
        String[] arr3 = new String[]{"张三","李四","王五"};
        String[] arr4 = {"张三","李四","王五"};
        //需求3：定义数组存储4个学生的身高
        double[] arr5 = new double[]{1.93,1.75,1.73,1.81};
        double[] arr6 = {1.93,1.75,1.73,1.81};
    }
}

数组的地址值

int[] arr = {1,2,3,4,5};
System.out.println(arr);//[I@d03e736 地址值

double[] arr2 = {1.1,2.2,3.3};
System.out.println(arr2);//[D@568db2f2 地址值

数组的地址值表示数组在内存中的位置

扩展：

地址值的格式含义 [D@568db2f2

[：表示当前是一个数组

D：表示当前数组里面的元素都是double类型的

@：表示一个间隔符号。（固定格式）

568db2f2：数组真正的地址值（十六进制）

平时我们习惯性的会把这个整体叫做数组的地址值。

数组的元素访问

格式：

格式：数组名 [索引];

索引

索引：也叫做下标，角标。
索引的特点：从0开始，逐个+1增长，连续不间断

public class ArrayDemo2 {
    public static void main(String[] args) {
        //利用索引对数组中的元素进行访问
        //1.获取数组里面的元素
        // 格式：数组名[索引]
        int[] arr = {1,2,3,4,5};
        //获取数组中的第一个元素
        //其实就是0索引上定义的元素
        int number = arr[0];
        System.out.println(number);//1

        //获取数组中1索引上对应的数据，并直接打印出来
        System.out.println(arr[1]);//2

        //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.获取数组里面所有的元素
        //格式：数组名[索引]
        //利用循环改进代码
        //开始条件：0
        //结束条件：数组的长度 - 1（最大索引）
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        //在Java当中，关于数组的一个长度属性：length
        //调用方式：数组名.length
        System.out.println(arr.length);
        
        //扩展：
        //自动的快速生成数组的遍历方式
        //数组名.fori
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

练习

遍历数组并求和

定义一个数组，存储1,2,3,4,5

遍历数组得到每一个元素，求数组里面所有的数据和

public class ArrTest1 {
    public static void main(String[] args) {
        /*定义一个数组，存储1,2,3,4,5
        遍历数组得到每一个元素，求数组里面所有的数据和
         */

        //分析：
        //1.定义一个数组，并添加数据1,2,3,4,5
        int[] arr = {1,2,3,4,5};

        //求和变量
        int sum = 0;

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

统计个数

定义一个数组，存储1,2,3,4,5,6,7,8,9,10

遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字

public class ArrTest2 {
    public static void main(String[] args) {
        /*定义一个数组，存储1,2,3,4,5,6,7,8,9,10
        遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字
         */

        //分析：
        //1.定义一个数组，存储1,2,3,4,5,6,7,8,9,10
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        //定义一个变量，用来统计次数
        int count = 0;
        //2.遍历数组得到每一个元素
        for (int i = 0; i < arr.length; i++){
            //3.判断当前的元素是否为3的倍数，如果是那么统计变量就需要自增一次。
            if(arr[i] % 3 == 0){
                count++;
            }
        }
        System.out.println("数组中能被3整除的数字有" + count + "个");
    }
}

变化数据

定义一个数组，存储1,2,3,4,5,6,7,8,9,10

遍历数组得到每一个元素。

要求：

如果是奇数，则将当前数字扩大两倍
如果是偶数，则将当前数字变成二分之一

public class ArrTest3 {
    public static void main(String[] args) {
        /*定义一个数组，存储1,2,3,4,5,6,7,8,9,10
        遍历数组得到每一个元素。
        要求：
        1.如果是奇数，则将当前数字扩大两倍
        2.如果是偶数，则将当前数字变成二分之一*/

        //分析：
        //1.定义一个数组，存储1,2,3,4,5,6,7,8,9,10
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        //2.遍历数组得到每一个元素
        for (int i = 0; i < arr.length; i++) {
            //3.对每一个元素进行判断
            if(arr[i] % 2 == 0){
                //偶数 变成二分之一
                arr[i] /= 2;
            }else{
                //奇数 数字扩大两倍
                arr[i] *= 2;
            }
        }
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

数组动态初始化

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
格式：数据类型[] 数组名 = new 数据类型[数组长度];
范例：int[] arr = new int[3];

public class ArrayDemo4 {
    public static void main(String[] args) {
        /*定义一个数组，用来存班级中50个学生的姓名
        姓名未知，等学生报到之后，在进行添加。
         */

        //格式：数据类型[] 数组名 = new 数据类型[数组长度];
        //在创建的时候，由我们自己指定数组的长度，由虚拟机给出默认的初始化值

        String[] arr = new String[50];
        //添加学生
        arr[0] = "张三";
        arr[1] = "李四";
        //获取
        System.out.println(arr[0]);//张三
        System.out.println(arr[1]);//李四
        System.out.println(arr[2]);//打印出来的是默认初始化值null

        //数组默认初始化值的规律
        //整数类型：默认初始化值0
        //小数类型：默认初始化值0.0
        //字符类型：默认初始化值'/u000' 空格
        //布尔类型：默认初始化值 false
        //引用数据类型：默认初始化值 null
        int[] arr2 = new int[3];
        System.out.println(arr2[0]);//0
        System.out.println(arr2[1]);//0
        System.out.println(arr2[2]);;//0
    }
}

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

动态初始化：手动指定数组长度，由系统给出默认初始化值。
- 只明确元素个数，不明确具体数值，推荐使用动态初始化
  - 举例：使用数组容器来存储键盘录入的5个整数。
  - int[] arr = {? ? ? ? ? };
  - int[] arr = new int[5];
静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度。
- 需求中已经明确了要操作的具体数据，直接静态初始化即可。
  - 举例：将全班的学生成绩存入数组中11, 22, 33
  - int[] arr = {11, 22, 33};

数组常见问题

当访问了数组中不存在的索引，就会引发索引越界异常。

public class ArrayDemo5 {
    public static void main(String[] args) {
        //1.定义一个数组
        int[] = {1,2,3,4,5};
        //长度：5
        //最小索引：0
        //最大索引：4（数组的长度 - 1）
        System.out.println(arr[10]);//报错
        
        //小结：
        //索引越界异常
        //避免：了解索引的范围
    }
}

数组常见操作（练习）

1.求最值

需求：已知数组元素为

请找出数组中最大值并打印在控制台
①定义max变量准备记录擂台上的变化

int max = arr[0];

②遍历数组获取每一个元素

for (int i = 1;i < arr.length;i++);{
    arr[i];
}

③让每一个元素跟max比较

如果找到更大的，就让max记录该元素

for (int i = 1;i < arr.length;i++){
    if (arr[i] > max){
        max = arr[i];
    }
}

public class ArrTest4 {
    public static void main(String[] args) {
        //定义数组最大值：33,5,22,44,55

        //1.定义数组用来存储五个值
        int[] arr = {33,5,22,44,55};
        //2.定义一个变量max用来存储最大值
        //临时认为0索引的数据是最大的
        int max = arr[0];
        //3.循环获取数组中的每一个元素
        //用每一个元素跟max进行比较
        for (int i = 1; i < arr.length; i++) {
            if(arr[i] > max){
                max = arr[i];
            }
        }
        //4.当循环结束之后，max记录的就是数组中的最大值
        System.out.println(max);
        //max的初始化值一定要是数组中的值
        //循环的开始条件如果为0，那么第一次循环的时候是自己跟自己比了一下，对结果没有任何影响，但是效率偏低
        //为了提高效率，减少一次循环的次数，循环开始条件可以写1
    }
}

2.遍历数组求和

需求：生成10个1~100之间的随机数存入数组。

1）求出所有数据的和

2）求出所有数据的随机数

3）统计有多少个数据比平均值小

import java.util.Random;

public class ArrTest5 {
    public static void main(String[] args) {
        /*需求：生成10个1~100之间的随机数存入数组。
        1）求出所有数据的和
        2）求出所有数据的随机数
        3）统计有多少个数据比平均值小
         */
        //分析：
        //1.定义数组
        int[] arr = new int[10];
        //2.把随机数存入到数组当中
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            //每循环一次就会生成一个新的随机数
            int number = r.nextInt(1,101);
            //把生成的随机数添加到数组当中
            //数组名[索引] = 数据；
            arr[i] = number;
        }
        //1）求出所有数据的和
        //定义求和变量
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            //循环得到每一个元素
            //并把元素累加到sum当中
            sum += arr[i];
        }
        System.out.println("数组中所有数据的和为：" + sum);

        //2）求出所有数据的随机数
        int avg = sum / arr.length;
        System.out.println("数组中的平均数为：" + avg);

        //3）统计有多少个数据比平均值小
        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] + " ");//println去掉ln，是数据都打印在一行，加空格使数据间隔开
        }
    }
}

3.交换数组中的数据

需求：定义两个变量，交换两个变量记录的值

public class ArrTest6 {
    public static void main(String[] args) {
        /*需求：定义两个变量，交换两个变量记录的值*/
        
        int a = 10;
        int b = 20;

        //定义一个临时的第三方变量
        //把变量a的值，赋值给了temp
        int temp = a;
        //把变量b的值，赋值给了a，那么变量a原来记录的值就被覆盖了
        a = b;
        //把变量a原来的值，赋值给了变量b
        b = temp;
        System.out.println(a);//20
        System.out.println(b);//10
    }
}

需求：定义一个数组，将数组中0索引和最大索引的值进行交换

public class ArrTest7 {
    public static void main(String[] args) {
        /*需求：定义一个数组，将数组中0索引和最大索引的值进行交换*/

        //1.定义一个数组
        int[] arr = {1,2,3,4,5};
        //将数组中0索引和最大索引的值进行交换
        //可以利用第三方变量进行交换
        int temp = arr[0];
        arr[0] = arr[4];
        arr[4] = temp;

        //3.遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

需求：定义一个数组，存入1,2,3,4,5。按照要求交换索引对应的元素。

交换前：1,2,3,4,5

交换后：5,4,3,2,1

public class ArrTest8 {
    public static void main(String[] args) {
        /*需求：定义一个数组，存入1,2,3,4,5。按照要求交换索引对应的元素。
        交换前：1,2,3,4,5
        交换后：5,4,3,2,1
         */

        //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.打乱数组中的数据

需求：定义一个数组，存入1-5。要求打乱数组中所有数据的顺序。

import java.util.Random;

public class ArrTest9 {
    public static void main(String[] args) {
        //需求：定义一个数组，存入1-5。要求打乱数组中所有数据的顺序。

        //1.定义数组存储1-5
        int[] arr = {1,2,3,4,5};
        //2.循环遍历数组
        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.print(arr[i] + " ");
        }
    }
}

Java内存分配

栈：方法运行时使用的内存，比如main方法运行，进入方法栈中执行
堆：存储对象或者数组，new来创建的，都存储在堆内存
方法区：存储可以运行的class文件
本地方法栈：JVM在使用操作系统功能的时候使用，和我们开发无关
寄存器：给CPU使用，和我们开发无关

总结：

只要是new处理的一定是在堆里面开辟了一个小空间
如果new了多次，那么在堆里面有多歌小空间，没歌小空间中都有各自的数据
当两个数组指向同一个小空间是，那么其他数组再次访问的时候都时修改之后的结果了

标签：arr,int,System,数组,public,out
From： https://www.cnblogs.com/Y423x/p/18053232

数组

数组