Java中的数组详解笔记(2022.4.18)

数组

1、数组的定义

• 数组是相同类型数据的有序结合。
• 数组存储的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
• 其中，每一个数据称做一个数组元素，每个数组元素可以通过一个下标来访问它们。

2、数组的声明与创建

• 首先必须声明数组变量，才能在程序中使用数组。声明数组变量的语法：

      int[] i;   // 首选的方法  Java中使用这种
      
      int i[];  // 效果相同，但不是首选方法

• Java中语言使用new关键字来创建数组，语法如下：

      int[] i = new int[arraySize];   // 就是说定义什么类型的数组，就要new什么类型的数组并且给予值
      
      int[] i = new int[5];  // 意思就是这个int中可以存储5个数字

• 数组的元素是通过索引访问的，数组索引从0开始

      package com.zhai.array;
      
      public class Array {
          public static void main(String[] args) {
      //        int[] i;   // 第一种方法：定义一个数组
      //        i = new int[3];  // 创建一个数组
              int [] i = new int[2];   // 第二种方法：一次性创建数组
              i[0]=3;
              i[1]=12;
              System.out.println("我是数组中第一个数据："+i[0]);
              System.out.println("我是数组中第二个数据："+i[1]);
          }
      }
      输出：
      	我是数组中第一个数据：3
      	我是数组中第二个数据：12

- 获取数组长度时候array.length

    package com.zhai.array;
    public class ArrayDemo2 {
        public static void main(String[] args) {
            int[] i = new int[10];
            i[0]=1;
            i[1]=2;
            i[2]=3;
            i[3]=4;
            i[4]=5;
            i[5]=6;
            i[6]=7;
            i[7]=8;
            i[8]=9;
            i[9]=10;
            int sum = 0;
            for (int j = 0; j <i.length ; j++) {
               sum = sum + i[j];   // i:就表示数组的长度，j：就是循环的次数最后把和赋给sum
            }
            System.out.println(sum);  // 进行输出
        }
    }
    输出：
    	55

3、数组中的内存分析

01、堆内存

• 就是存放new对象和数组
• 可以被所有线程共享，不会存放别的对象引用。

    如：int[] i = new int[2];

解析：=左边的就是栈内存，在计算机中有块内存名为 i 没有数据的时候并无意义；相反当=右边有关键字new出现的时候，在计算机中会开辟一块内存里面并且可以存储2个数据都是相同类型的数据，这些数据的编号(也就是所谓的下标)是从0开始的，就是取出数据的时候会用到也就是堆内存（存储行同类型的数据）。

02、栈内存

• 存放基本变量类型（包含这个进本类型的具体数值）
• 引用对象的变量（会存放这个引用在堆里面的具体地址）

03、方法区

• 可以被所有线程共享
• 包含了所有class和static变量

4、数组的三种初始化

• 静态初始化

    int[] a = {1,2,3}    // 这个创建数组的含义就是直接赋值为1，2，3 不灵活
    Man[] mas = {new Man(1,1),new Man(2,2);   // 引用类型，把自定义类通过new进行初始化

• 动态初始化

    int[] i = new int[2];  // 这个数组就是在堆内存中开辟一块大小为2的内存，只能存储两个数据类型统一是int
    i[0]=3;     // 给开辟好的内存进行赋值  0就是第一个数据为3
    i[1]=12;    // 第二个数据为12

• 数组的默认初始化
  • 数组是引用类型，它的元素相当于类的实例变量，一次数组经分配空间，其中的每个元素也被按照实力变量同样的方式被隐式初始化。

    package com.zhai.array;
    
    public class ArrayDemo3 {
        public static void main(String[] args) {
            // 静态数组
            int[] i = {2,3,4,5,6,7,8,9};
            System.out.println("我是静态数组："+i[5]);
            // 动态数组
            int[] i1 = new int[8];
            i1[0]=312;    // 赋值为第一个数据为312
            System.out.println("我是动态数组："+i1[0]);
            // 默认初始化值
            System.out.println("我是动态数组的默认初始化值："+i1[1]);
        }
    }
    输出：
    	我是静态数组：7
    	我是动态数组：312
    	我是动态数组的默认初始化值：0

01、数组的四个基本特点

• 长度是确定的，数组一旦被创建，它的大小就是不可改变的；
• 其元素必须是相同类型，不能出现混合类型；
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
• 数组变量是属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量；数组本身就是对象，Java中对象是存储在堆内存中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

02、数组边界

• 下标的合法区间：[0,length-1],如果越界就会报错；

    package com.zhai.array;
    
    public class ArrayDemo3 {
        public static void main(String[] args) {
    		// 数组越界异常
            int[] i2 = new int[2];
            i2[1]=2;
            System.out.println("我是正常的边界："+i2[1]);   // 这个是可以正常输出的
            System.out.println(i2[2]);   
      // 因为下标是从0开始所以这个已经越界了，因为在初始化数组时已经给过容量大小，所以不能超过最大数值
        }
    }
    输出：
    	我是正常的边界：2
    	java.lang.ArrayIndexOutOfBoundsException    // 数组越界异常

• 小结：
  • 数组是相同的数据类型（数据类型可以为任意类型）的有序集合
  • 数组也是对象，数组元素与对象的成员变量
  • 数组长度是确定的，不可变的；如果越界，则报：java.lang.ArrayIndexOutOfBoundsException

03、数组使用

• For-Each 循环
• 数组作为方法传入参数
• 数组作为返回值

小练习：

    package com.zhai.array;
    public class ArrayDemo4 {
        public static void main(String[] args) {
            // 输出所有的数组数据
            int[] a = {12,23,34,56,67,78,89};
            for (int i = 0; i <a.length ; i++) {
                System.out.println(a[i]);
            }
            System.out.println("======================================");
            // 输出所有数据的和
            int b = 0;
            for (int i = 0; i <a.length ; i++) {
                b+=a[i];
            }
            System.out.println("总和为："+b);
            System.out.println("======================================");
            // 抽取这些数字中最大的数字 
            int c = a[0];   // 这个就是把那些数字的第一个数字赋值给c
            for (int i = 0; i <a.length ; i++) {
                if (c<a[i]){      // 然后拿c跟后面的数字进行比较，谁比第一个数字大
                    c = a[i];    // 就把谁赋值给c
                }
            }
            System.out.println("最大数为："+c);  // 然后进行输出
        }
    }
    输出：
        12
        23
        34
        56
        67
        78
        89
        ======================================
        总和为：359
        ======================================
        最大数为：89

数组的使用：

    package com.zhai.array;
    
    public class ArrayDemo5 {
        public static void main(String[] args) {
            // 定义静态数组
            int[] a = {1,2,3,4,5};
    
            // 调用普通for循环的输出方法
            printArrays(a);
            // 调用forEach循环的输出方法
            Each(a);
            // 比较大小
            int b = a[0];
            for (int i = 0; i <a.length ; i++) {
                if (b<a[i]){
                    b = a[i];
                }
            }
            System.out.println("最大的数为："+b);
            // 调用反转的方法
            int[] res = fanZhuan(a);
            printArrays(res);
        }
    
        // 普通的输出数组中的所有数据
        public static void printArrays(int[] b){
            for (int i = 0; i < b.length; i++) {
                System.out.println(b[i]);
            }
        }
        // 使用foreach进行输出所有的数据
        public static void Each(int[] c){
            for (int x:c) {   // forEach 有个弊端就是没有下标
                System.out.println("使用ForEach进行输出的结果："+x);
            }
        }
        // 反转数组
        public static int[] fanZhuan(int[] arrays){
            int[] ints = new int[arrays.length];
            // 反转操作
            for (int i = 0, j=ints.length-1; i <arrays.length; i++,j--) {
                 ints[j] = arrays[i];
            }
            return ints;
        }
    }

以上就是Java中数组使用的方式！