认识Java中的数组

数组

数组介绍

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

数组容器在存储数据的时候，需要结合隐式转换考虑。

数组的定义与静态初始化

定义：

格式一：
数据类型 []数组名;
格式二：
数据类型 数组名[];

初始化

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

方式：

静态初始化

格式：

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

数组的地址值

表示数组在内存中的位置。

地址值的格式含义[D@776ec8df：[：表示当前是一个数组。D：表示数据类型。776ec8df:数组真正的地址值。

动态初始化

初始化时只指定数组长度，有系统为数组分配初始值。

格式：

数据类型[] 数组名 = new 数据类型[数组长度];
范例：int[] arr = new int[3];

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

动态初始化：手动指定数组长度，由系统给出默认初始化值。

• 只明确元素个数，不明确具体数值，推荐使用动态初始化

静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度。

• 需求中已经明确了要操作的具体数据，直接静态初始化即可。

数组元素访问

格式：数组名[索引];

索引：也叫下标，角标。从0开始，逐个+1，连续不间断

数组遍历

将数组中的所有内容取出来，取出来之后可以（打印，求和，判断）。

idea快捷键快速生成数组遍历的方式：数组名.fori

练习

1.遍历数组求和

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

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

package com.example.demo;

public class Test {
    public static void main(String[] args) {
        //定义数组并赋值
      int [] array = {1,2,3,4,5};
        //求和变量
      int sum = 0;
        //累加
        for (int i = 0; i < array.length; i++) {
           sum += array[i];
        }
        System.out.println(sum);
    }
}

2.统计个数

定义一个数组，存储1,2,3,4,5,6,7,8,9,10遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字。

package com.example.demo;

public class Test {
    public static void main(String[] args) {
        //定义数组并赋值
      int [] array = {1,2,3,4,5,6,7,8,9,10};
        //定义一个统计变量
      int count = 0;
        //遍历数组
        for (int i = 0; i < array.length; i++) {
            //能被3整除的
            if (array[i] % 3==0){
                count++;
            }
        }
        System.out.println(count);
    }
}

3.变化数据

定义一个数组，存储1,2,3,4,5,6,7,8,9,10遍历数组得到每一个元素。要求：1，如果是奇数，则将当前数字扩大两倍。2，如果是偶数，则将当前数字变成二分之一。

package com.example.demo;

public class Test {
    public static void main(String[] args) {
        //定义数组并赋值
      int [] array = {1,2,3,4,5,6,7,8,9,10};
        //变化数据
        for (int i = 0; i < array.length; i++) {
            if (array[i] % 2 !=0){
                array[i] =array[i] * 2;
            }else {
                array[i] = array[i]/2;
            }
        }
        //打印数组里面的每一个元素
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

数组内存图

两个数组指向同一个空间的内存图

1.当两个数组指向同一个小空间是，其中一个数组堆小空间的值发生了改变，那么其他数组再次访问的时候都是修改之后的结果了。

两个数组内存图

1.只要是new出来的一定是在堆里面开辟了一个小空间。而且堆里面开辟出来的空间是有地址值的。

2.如果new了多次，那么在堆里面有多个小空间，每个小空间中都有各自的数据。

Java内存分配

注意：从JDK8开始，取消方法区，新增元空间。把原来方法区的多种功能进行拆分，有的功能放到了堆中，有的功能放到了元空间中。

栈

方法运行时使用的内存，比如main方法运行，进入方法栈中执行。main方法开始执行是会进栈，代码执行完毕会出栈。

堆

存储对象或数组，new来创建的，都存在在堆内存。new出来的东西会在这块内存中开辟空间并产生地址。

方法区

存储可以运行的class文件

本地方法栈

JVM在使用操作系统功能的时候使用，和我们开发无关

寄存器

给CPU使用，和我们开发无关。

数组常见问题

索引越界：

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

数组常见操作

1.求最值

需求：已知数组元素为{33,5,22,44,55}请找出数组中最大值并打印在控制台。

package com.example.demo;

public class Test {
    public static void main(String[] args) {
//        定义一个数组
      int [] array = {33,5,22,44,55};
//        定义一个临时最大值
      int max = array[0];
//      循环遍历数组
//        循环的开始条件一定是0吗？
//如果循环的开始是0，那么第一次循环的时候是自己跟自己比了一下，对结果没有任何影响，但是效率偏低
//        为了提高效率，减少一次循环次数，循环开始条件可以写1
        for (int i = 0; i < array.length; i++) {
            if (array[i]>max){
                max = array[i];
            }
        }
//        打印
        System.out.println(max);
    }
}

2.遍历数组求和

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

• 求出所有数据的和
• 求所有数据的平均数
• 统计有多少个数据比平均值小

package com.example.demo;

import java.util.Random;

public class Test {
    public static void main(String[] args) {
//        定义一个动态初始化数组
        int array[] = new int[10];
        Random rd = new Random();
//        在数组中添加元素
        for (int i = 0; i < array.length; i++) {
            array[i]= rd.nextInt(100)+1;
        }
//        定义一个累加变量
        int sum = 0;
//        累加
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        System.out.println(sum);
//        计算平均数
        int avg = sum / array.length;
        System.out.println(avg);
//        定义一个统计变量
        int count = 0;
//        遍历
        for (int i = 0; i < array.length; i++) {
            if (array[i]< avg){
                count++;
            }
        }
        System.out.println(count);
    }
}

3.交换数组中的数据

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

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

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

package com.example.demo;

public class Test {
    public static void main(String[] args) {
//        定义一个数组
        int [] array= {1,2,3,4,5};
        int a = array[0];
//        定义一个临时变量
        int temp = 0;
        int b = array[4];
        temp = a;
        a = b;
        b = temp;
        System.out.println(a);
        System.out.println(b);
    }
}

package com.example.demo;

public class Test {
    public static void main(String[] args) {
//        定义一个数组
        int [] array= {1,2,3,4,5};
//        利用循环去交换数据
        for (int i = 0,j = array.length-1; i < j; i++,j--) {
//            交换变量i和变量j只向的元素
            int temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
//        当循环结束后，数组的数据就实现了头尾交换
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]);
        }
    }
}

4.打乱数组中的数据

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

package com.example.demo;

import java.util.Random;

public class Test {
    public static void main(String[] args) {
//        需求：定义一个数组，存入1~5.要求打乱数组中所有数据的顺序。
//        定义一个数组
        int [] array= {1,2,3,4,5};
//        利用循环去交换数据
        Random random = new Random();
//        循环遍历数组
        for (int i = 0; i < array.length; i++) {
            int randomIndex = random.nextInt(array.length);
            int temp = array[i];
            array[i] = array[randomIndex];
            array[randomIndex] = temp;
        }
//        当循环结束后，数组的数据就实现了头尾交换
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
    }
}