05 Java数组详细介绍

Java基础语法之数组

一、数组的概念

1. 数组的概念

• 是一种容器，可以同时存放多个数据值。

2. 数组的特点

• 数组是一种引用数据类型。
• 数组当中的多个数据，类型必须统一。
• 数组的长度在程序运行期间不可改变。

二、数组的定义格式

1. 动态初始化

• 指定长度:在创建数组的时候，直接指定数组当中的数据元素个数。

• 格式：数据类型[] 数组名称 = new 数据类型[数组长度];

  public class Demo01Array {
      public static void main(String[] args) {
          //创建一个大小为100的整形数组
          int[] arrayA = new int[100];
  
          //创建一个大小为200的double类型数组
          double[] arrayB = new double[200];
  
          //创建一个大小为10的String类型数组
          String[] arrayC = new String[10];
      }
  }
  

2. 静态初始化

• 指定内容:在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。

• 标准格式：数据类型[] 数组名称 = new 数据类型[]{元素1，元素2，...};

  public class Demo02Array {
      public static void main(String[] args) {
          //创建数组，内容为1,2,3
          int[] arrayA = new int[] {1, 2, 3};
  
          //创建数组，内容为"Hello", "World", "Java"
          String[] arrayB = new String[] {"Hello", "World", "Java"};
      }
  }
  

3. 省略的静态初始化

• 省略格式：数据类型[] 数组名称 = {元素1，元素2，...}；

4. 注意事项

• 静态初始化没有直接指定长度，但是仍然会自动推算得到长度。

• 静态初始化标准格式可以拆分成为两个步骤。

  int[] array = new int[]{1,2,3};
  
  //拆分
  int[] array;
  array = new int[]{1,2,3};
  

• 动态初始化也可以拆分成为两个步骤。

  int[] array = new int[3];
  
  //拆分
  int[] array;
  array = new int[3];
  

• 静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。

  int[] array = {1,2,3};
  
  //错误！
  int[] array;
  array = {1,2,3};
  

5. 使用建议

• 如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。

三、访问数组元素进行获取

• 直接打印数组名称，得到的是数组对应的：内存地址哈希值。

• 访问数组元素的格式：数组名称[索引值];

• 索引值：就是一个int数字，代表数组当中元素的编号。

• 索引值从0开始，一直到数组的长度 - 1为止。

  public class Demo03ArrayUse {
      public static void main(String[] args) {
          int[] array = {1, 2, 3};
          System.out.println(array);    // [I@50cbc42f
          System.out.println(array[0]); // 1
          System.out.println(array[1]); // 2
          System.out.println(array[2]); // 3
  
          int num = array[0];
          System.out.println(num); // 1
      }
  }
  

四、访问数组元素进行赋值

• 使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值。规则如下:

  • 如果是整数类型，那么默认为0;

  • 如果是浮点类型，那么默认为0.0;

  • 如果是字符类型，那么默认为'\u000'；

  • 如果是布尔类型，那么默认为false；

  • 如果是引用类型，那么默认为null。

    public class Demo04ArrayUse {
        public static void main(String[] args) {
            int[] array = new int[3];
            System.out.println(array);      // [I@50cbc42f
            System.out.println(array[0]);   // 0
            System.out.println(array[1]);   // 0
            System.out.println(array[2]);   // 0
        }
    }
    

• 注意事项：静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成为了大括号当中的具体数值。

五、Java中的内存划分

六、一个数组的内存图

七、两个数组的内存图

八、两个引用指向同一个数组的内存图

九、数组常见问题

1.数组索引越界异常

• 数组的索引编号从0开始，一直到数组的长度 - 1为止。
• 如果访问数组元素的时候，索引编号并不存在，那么将会发生数组索引越界异常。

2.空指针异常

• 数组必须进行new初始化才能使用其中的元素。
• 如果只是赋值了一个null，没有进行new创建，那么将会发生：空指针异常。
• 所有的引用类型变量，都可以赋值为一个null值。但是代表其中什么都没有。

十、数组的若干操作

1. 获取数组的长度

• 格式：数组名称.Length;这将会得到一个int数字，代表数组的长度。

  public class ArrayLength {
      public static void main(String[] args) {
          int[] arrayA = new int[5];
          int lenA = arrayA.length;
          System.out.println(lenA);  // 5
  
          int[] arrayB = {1, 3, 5, 9, 8, 7, 4, 1, 3, 5, 9, 8, 7, 4};
          int lenB = arrayB.length;
          System.out.println(lenB);  //14
      }
  }
  

• 数组一旦创建，程序运行期间，长度不可改变。

  

2. 数组的遍历输出

• 遍历数组：就是对数组当中的每一个元素进行逐一处理。

  public class ArrayPrint {
      public static void main(String[] args) {
          int[] array = {10,20,30,40,50,60};
          for (int i = 0; i < array.length; i++) {
              System.out.println(array[i]);
          }
      }
  }
  

3. 求出数组中的最值

public class ArrayMax {
    public static void main(String[] args) {
        int[] array = { 5, 15, 3000, 20, 1000};
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            max = max > array[i] ? max : array[i];
        }
        System.out.println(max); // 3000
    }
}

4. 数组元素反转

public class ArrayReverse {
    public static void main(String[] args) {
        int[] array = new int[] {0,1,2,3,4,5,6,7,8,9};
        //输出原数组
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

        //反转
        for (int min = 0, max = array.length-1; min < max; ++min, --max){
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }
        //输出反转后的数组
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

十一、数组作为方法参数传递地址

• 数组可以作为方法的参数。
• 当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值。

public class ArrayPara {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9};
        arrayPrint(array);
        System.out.println("*************************");
        arrayPrint(array);
        System.out.println("*************************");
    }

    public static void arrayPrint(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

十二、数组作为方法返回值返回地址

• 一个方法可以有0、1、多个参数；但是只能有0或者1个返回值，不能有多个返回值。
• 如果希望一个方法当中产生了多个结果数据进行返回，可以使用一个数组作为返回值类型。

public class ArrayReturn {
    public static void main(String[] args) {
        int[] result = calculate(10,20,30);
        System.out.println("总和：" + result[0]);
        System.out.println("平均数：" + result[1]);
    }

    public static int[] calculate(int a, int b, int c){
        int sum = a + b + c;
        int avg = sum / 3;
        int[] array = {sum, avg};
        return array;
    }
}