数组

数组

数组先容

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

• 数组容器在存储数据的时间，需要结合隐式转换考虑。
  
• 例如：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};
  

1. public class ArrayDemo1 {
2.     public static void main(String[] args) {
3.         //格式：
4.         //静态初始化
5.         //完整格式：
6.         //数据类型 [] 数组名 = new 数据类型[] {元素1,元素2,元素3...};
7.         //简化格式：
8.         //数据类型 [] 数组名 = {元素1,元素2,元素3...};
10.         //需求1：定义数组存储5个学生的年龄
11.         int[] arr1 = new int[]{11,12,13,14,15};
12.         int[] arr2 = {11,12,13,14,15};
13.         //需求2：定义数组存储3歌学生的姓名
14.         String[] arr3 = new String[]{"张三","李四","王五"};
15.         String[] arr4 = {"张三","李四","王五"};
16.         //需求3：定义数组存储4个学生的身高
17.         double[] arr5 = new double[]{1.93,1.75,1.73,1.81};
18.         double[] arr6 = {1.93,1.75,1.73,1.81};
19.     }
20. }

复制代码

数组的地址值

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

复制代码

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

复制代码

数组的地址值表示数组在内存中的位置
扩展：
地址值的格式寄义   [D@568db2f2
[：表示当前是一个数组
D：表示当前数组内里的元素都是double类型的
@：表示一个间隔符号。（固定格式）
568db2f2：数组真正的地址值（十六进制）
寻常我们习惯性的会把这个团体叫做数组的地址值。
数组的元素访问

格式：

• 格式：数组名 [索引];
  

索引

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

1. public class ArrayDemo2 {
2.     public static void main(String[] args) {
3.         //利用索引对数组中的元素进行访问
4.         //1.获取数组里面的元素
5.         // 格式：数组名[索引]
6.         int[] arr = {1,2,3,4,5};
7.         //获取数组中的第一个元素
8.         //其实就是0索引上定义的元素
9.         int number = arr[0];
10.         System.out.println(number);//1
12.         //获取数组中1索引上对应的数据，并直接打印出来
13.         System.out.println(arr[1]);//2
15.         //2.把数据存储到数组当中
16.         //  格式：数组名[索引] = 具体数据或变量
17.         //细节：一旦覆盖之后，原来的数据就不存在了。
19.         arr[0] = 100;
20.         System.out.println(arr[0]);//100
21.     }
22. }

复制代码

数组遍历

• 数组遍历：将数组中所有的内容取出来，取出来之后可以（打印，求和，判断...）
  
• 注意：遍历指的是取出数据的过程，不要局限的明白为，遍历就是打印！
  

1. public class ArrayDemo3 {
2.     public static void main(String[] args) {
3.         //1.定义数组
4.         int[] arr = {1,2,3,4,5};
5.         //2.获取数组里面所有的元素
6.         //格式：数组名[索引]
7.         //利用循环改进代码
8.         //开始条件：0
9.         //结束条件：数组的长度 - 1（最大索引）
10.         for (int i = 0; i < arr.length; i++) {
11.             System.out.println(arr[i]);
12.         }
14.         //在Java当中，关于数组的一个长度属性：length
15.         //调用方式：数组名.length
16.         System.out.println(arr.length);
17.         
18.         //扩展：
19.         //自动的快速生成数组的遍历方式
20.         //数组名.fori
21.         for (int i = 0; i < arr.length; i++) {
22.             System.out.println(arr[i]);
23.         }
24.     }
25. }

复制代码

练习

遍历数组并求和
定义一个数组，存储1,2,3,4,5
遍历数组得到每一个元素，求数组内里所有的数据和

1. public class ArrTest1 {
2.     public static void main(String[] args) {
3.         /*定义一个数组，存储1,2,3,4,5
4.         遍历数组得到每一个元素，求数组里面所有的数据和
5.          */
7.         //分析：
8.         //1.定义一个数组，并添加数据1,2,3,4,5
9.         int[] arr = {1,2,3,4,5};
11.         //求和变量
12.         int sum = 0;
14.         //2.遍历数组得到每一个数据，累加求和
15.         for (int i = 0; i < arr.length; i++) {
16.             //i 依次表示数组里面的每一个索引
17.             //arr[i] 依次表示数组里面的每一个元素
18.             sum += arr[i];
19.         }
20.         //当循环结束之后，sum的值就是累加之后的结果
21.         System.out.println(sum);
22.     }
23. }

复制代码

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

1. public class ArrTest2 {
2.     public static void main(String[] args) {
3.         /*定义一个数组，存储1,2,3,4,5,6,7,8,9,10
4.         遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字
5.          */
7.         //分析：
8.         //1.定义一个数组，存储1,2,3,4,5,6,7,8,9,10
9.         int[] arr = {1,2,3,4,5,6,7,8,9,10};
10.         //定义一个变量，用来统计次数
11.         int count = 0;
12.         //2.遍历数组得到每一个元素
13.         for (int i = 0; i < arr.length; i++){
14.             //3.判断当前的元素是否为3的倍数，如果是那么统计变量就需要自增一次。
15.             if(arr[i] % 3 == 0){
16.                 count++;
17.             }
18.         }
19.         System.out.println("数组中能被3整除的数字有" + count + "个");
20.     }
21. }

复制代码

变化数据
定义一个数组，存储1,2,3,4,5,6,7,8,9,10
遍历数组得到每一个元素。
要求：

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

1. public class ArrTest3 {
2.     public static void main(String[] args) {
3.         /*定义一个数组，存储1,2,3,4,5,6,7,8,9,10
4.         遍历数组得到每一个元素。
5.         要求：
6.         1.如果是奇数，则将当前数字扩大两倍
7.         2.如果是偶数，则将当前数字变成二分之一*/
9.         //分析：
10.         //1.定义一个数组，存储1,2,3,4,5,6,7,8,9,10
11.         int[] arr = {1,2,3,4,5,6,7,8,9,10};
12.         //2.遍历数组得到每一个元素
13.         for (int i = 0; i < arr.length; i++) {
14.             //3.对每一个元素进行判断
15.             if(arr[i] % 2 == 0){
16.                 //偶数 变成二分之一
17.                 arr[i] /= 2;
18.             }else{
19.                 //奇数 数字扩大两倍
20.                 arr[i] *= 2;
21.             }
22.         }
23.         //遍历数组
24.         for (int i = 0; i < arr.length; i++) {
25.             System.out.println(arr[i]);
26.         }
27.     }
28. }

复制代码

数组动态初始化

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

1. public class ArrayDemo4 {
2.     public static void main(String[] args) {
3.         /*定义一个数组，用来存班级中50个学生的姓名
4.         姓名未知，等学生报到之后，在进行添加。
5.          */
7.         //格式：数据类型[] 数组名 = new 数据类型[数组长度];
8.         //在创建的时候，由我们自己指定数组的长度，由虚拟机给出默认的初始化值
10.         String[] arr = new String[50];
11.         //添加学生
12.         arr[0] = "张三";
13.         arr[1] = "李四";
14.         //获取
15.         System.out.println(arr[0]);//张三
16.         System.out.println(arr[1]);//李四
17.         System.out.println(arr[2]);//打印出来的是默认初始化值null
19.         //数组默认初始化值的规律
20.         //整数类型：默认初始化值0
21.         //小数类型：默认初始化值0.0
22.         //字符类型：默认初始化值'/u000' 空格
23.         //布尔类型：默认初始化值 false
24.         //引用数据类型：默认初始化值 null
25.         int[] arr2 = new int[3];
26.         System.out.println(arr2[0]);//0
27.         System.out.println(arr2[1]);//0
28.         System.out.println(arr2[2]);;//0
29.     }
30. }

复制代码

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

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

数组常见标题

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

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

复制代码

数组常见操作（练习）

1.求最值

• 需求：已知数组元素为
  请找出数组中最大值并打印在控制台
  
• ①定义max变量预备记录擂台上的变化
  int max = arr[0];
  
• ②遍历数组获取每一个元素
  1. for (int i = 1;i < arr.length;i++);{
  2.     arr[i];
  3. }

  复制代码
• ③让每一个元素跟max比较
  如果找到更大的，就让max记录该元素
  1. for (int i = 1;i < arr.length;i++){
  2.     if (arr[i] > max){
  3.         max = arr[i];
  4.     }
  5. }

  复制代码

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

复制代码

2.遍历数组求和

需求：生成10个1~100之间的随机数存入数组。
1）求出所有数据的和
2）求出所有数据的随机数
3）统计有多少个数据比平均值小

1. import java.util.Random;
3. public class ArrTest5 {
4.     public static void main(String[] args) {
5.         /*需求：生成10个1~100之间的随机数存入数组。
6.         1）求出所有数据的和
7.         2）求出所有数据的随机数
8.         3）统计有多少个数据比平均值小
9.          */
10.         //分析：
11.         //1.定义数组
12.         int[] arr = new int[10];
13.         //2.把随机数存入到数组当中
14.         Random r = new Random();
15.         for (int i = 0; i < arr.length; i++) {
16.             //每循环一次就会生成一个新的随机数
17.             int number = r.nextInt(1,101);
18.             //把生成的随机数添加到数组当中
19.             //数组名[索引] = 数据；
20.             arr[i] = number;
21.         }
22.         //1）求出所有数据的和
23.         //定义求和变量
24.         int sum = 0;
25.         for (int i = 0; i < arr.length; i++) {
26.             //循环得到每一个元素
27.             //并把元素累加到sum当中
28.             sum += arr[i];
29.         }
30.         System.out.println("数组中所有数据的和为：" + sum);
32.         //2）求出所有数据的随机数
33.         int avg = sum / arr.length;
34.         System.out.println("数组中的平均数为：" + avg);
36.         //3）统计有多少个数据比平均值小
37.         int count = 0;
38.         for (int i = 0; i < arr.length; i++) {
39.             if(arr[i] < avg){
40.                 count++;
41.             }
42.         }
43.         System.out.println("在数组中，一共有" + count + "个数据，比平均数小");
45.         //遍历数组，验证答案
46.         for (int i = 0; i < arr.length; i++) {
47.             System.out.print(arr[i] + " ");//println去掉ln，是数据都打印在一行，加空格使数据间隔开
48.         }
49.     }
50. }

复制代码

3.互换数组中的数据

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

1. public class ArrTest6 {
2.     public static void main(String[] args) {
3.         /*需求：定义两个变量，交换两个变量记录的值*/
4.         
5.         int a = 10;
6.         int b = 20;
8.         //定义一个临时的第三方变量
9.         //把变量a的值，赋值给了temp
10.         int temp = a;
11.         //把变量b的值，赋值给了a，那么变量a原来记录的值就被覆盖了
12.         a = b;
13.         //把变量a原来的值，赋值给了变量b
14.         b = temp;
15.         System.out.println(a);//20
16.         System.out.println(b);//10
17.     }
18. }

复制代码

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

1. public class ArrTest7 {
2.     public static void main(String[] args) {
3.         /*需求：定义一个数组，将数组中0索引和最大索引的值进行交换*/
5.         //1.定义一个数组
6.         int[] arr = {1,2,3,4,5};
7.         //将数组中0索引和最大索引的值进行交换
8.         //可以利用第三方变量进行交换
9.         int temp = arr[0];
10.         arr[0] = arr[4];
11.         arr[4] = temp;
13.         //3.遍历数组
14.         for (int i = 0; i < arr.length; i++) {
15.             System.out.print(arr[i] + " ");
16.         }
17.     }
18. }

复制代码

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

1. public class ArrTest8 {
2.     public static void main(String[] args) {
3.         /*需求：定义一个数组，存入1,2,3,4,5。按照要求交换索引对应的元素。
4.         交换前：1,2,3,4,5
5.         交换后：5,4,3,2,1
6.          */
8.         //1.定义数组存储数据
9.         int[] arr = {1,2,3,4,5};
10.         //2.利用循环交换数据
11.         for(int i = 0,j = arr.length - 1 ; i < j ; i++,j--){
12.             //交换变量i和变量j指向的元素
13.             int temp = arr[i];
14.             arr[i] = arr[j];
15.             arr[j] = temp;
16.         }
17.         //当循环结束之后，那么数组中的数据与实现了头尾交换
18.         for (int i = 0; i < arr.length; i++) {
19.             System.out.print(arr[i] + " ");
20.         }
21.     }
22. }

复制代码

4.打乱数组中的数据

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

1. import java.util.Random;
3. public class ArrTest9 {
4.     public static void main(String[] args) {
5.         //需求：定义一个数组，存入1-5。要求打乱数组中所有数据的顺序。
7.         //1.定义数组存储1-5
8.         int[] arr = {1,2,3,4,5};
9.         //2.循环遍历数组
10.         Random r = new Random();
11.         for (int i = 0; i < arr.length; i++) {
12.             //生成一个随机索引
13.             int randomIndex = r.nextInt(arr.length);
14.             //拿着随机索引指向的元素，跟 i 指向的元素进行交换
15.             int temp = arr[i];
16.             arr[i] = arr[randomIndex];
17.             arr[randomIndex] = temp;
18.         }
19.         //当循环结束之后，那么数组中所有的数据已经打乱顺序
20.         for (int i = 0; i < arr.length; i++) {
21.             System.out.print(arr[i] + " ");
22.         }
23.     }
24. }

复制代码

Java内存分配

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

总结：

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

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。