Java数组

数组的基本概念

• 一组相关变量的集合
• Java中将数组定义为引用数据类型，所以数组的使用牵扯到了内存分配
• 数组定义格式：
  • 数组的动态初始化：数据类型 数组名称 [] = new 数据类型 [长度]，初始化之后每一个元素的保存内容为其对应数据类型的默认值
  • 数组的静态初始化：在数组定义的时候就设置好了里面的内容，1. 简化格式：数据类型 数组名称 [] = {数据1, 数据2, 数据3, ...}；2. 完整格式：数据类型 数组名称 [] = new 数据类型 [] {数据1, 数据2, 数据3, ...}

使用数组

• 数组里面可以通过脚标进行每一个元素的访问，脚标从0开始定义，可使用脚标范围： 0～数组长度-1，如果使用脚标超过数组长度，则会出现“ArrayIndexOutOfBoundsException”（数组越界）异常
• 使用数组是为了可以进行方便的变量管理，所以在进行数组操作的时候会利用for循环来完成
• 对于数组长度，可通过：数组名称.length 来获得

public class ArrayDemo {
  public static void main (String args []) {
    int data [] = new int [3];  //使用数组的动态初始化实现了数组的定义
    //  int data [] = new int [] {10, 20, 30};  静态初始化
    data [0] = 10;
    data [1] = 20;
    data [2] = 30;
    for(int x = 0; x < data.length; x++) {
      System.out.println(data[x]);
    }
    // System.out.println(data[3]);  ArrayIndexOutOfBoundsException
  }
}

数组的引用传递

• 通过数组的定义发现，在数组使用过程中，需要用关键字new进行内存空间开辟，所以存在内存关系匹配
• 数组本身属于引用数据类型，引用数据类型就会发生引用传递，一个堆内存可以被多个栈内存指向

• 数组属于引用类型，所以一定为其开辟堆内存空间之后才可以使用，如果使用了未开辟堆内存空间的数组，会出现“NullPointerException”异常

  
  此图源于李兴华老师

public class ArrayDemo {
  public static void main (String args []) {
    int data [] = new int [] {10, 20, 30};
    int temp [] = data;
    temp [0] = 99;
    for(int x = 0; x < data.length; x++) {
      System.out.println(data[x]);
    }
  }
}

此图源于李兴华老师

foreach迭代输出

• for(数据类型 变量 : 数组 ｜ 集合) {}

public class ArrayDemo {
  public static void main (String args []) {
    int data [] = new int [] {11, 22, 33};
    for(int temp : data) {
      System.out.println(temp);
    }
  }
}

二维数组

• 数组动态初始化：数据类型 数组名称 [][] = new 数据类型 [行个数][列个数]
• 数组静态初始化：数据类型 数组名称 [][] = new 数据类型 [][] {{1, 2, 3}, {4, 5, 6}...}

public class ArrayDemo {
  public static void main (String args []) {
    int data [][] = new int [][] {{1, 2, 3, 4, 5}, {6, 7, 8}, {9, 10 ,11, 12,}};
    for(int temp [] : data) {
      for(int i : temp) {
        System.out.println(i);
      }
      System.out.println();
    }
  }
}

数组和方法

• 对于引用数据类型而言，主要的特点是可以与方法进行引用传递，而数组也属于引用数据类型，所以可以通过方法实现引用传递

public class ArrayDemo {
  public static void main (String args []) {
    int data [] = new int [] {1, 2, 3, 4, 5};
    printlnArray(data);
  }
  public static void printlnArray(int temp []) {
    for(int x : temp) {
      System.out.println(x);
    }
  }
}

此图源于李兴华老师

• 可以通过方法接收一个数组，那么也可以通过方法返回一个数组对象，需在方法的返回值类型上进行控制

public class ArrayDemo {
  public static void main (String args []) {
    int data [] = initArray();
    printlnArray(data);
  }
  public static int [] initArray() {
    int arr [] = new int [] {1, 2, 3, 4, 5};
    return arr;
  }
  public static void printlnArray(int temp []) {
    for(int x : temp) {
      System.out.println(x);
    }
  }
}

此图源于李兴华老师

• 通过方法修改数组内容

public class ArrayDemo {
  public static void main (String args []) {
    int data [] = new int [] {1, 2, 3, 4, 5};
    changeArray(data);
    printlnArray(data);
  }
  public static void changeArray(int arr []) {
    for(int x = 0; x < arr.length; x++) {
      arr[x] *= 2;
    }
  }
  public static void printlnArray(int temp []) {
    for(int x : temp) {
      System.out.println(x);
    }
  }
}

此图源于李兴华老师

数组相关操作方法

java.util.Arrays.sort(数组名称);    //排序
System.arraycopy(源数组, 源数组开始点, 目标数组, 目标数组开始点, 拷贝长度);    //数组拷贝

方法可变参数

• 定义一个方法，这个方法可以实现任意多个整型数据的相加处理

class ArrayUtil {
  public static int sum(int ...data) {
    int sum = 0;
    for(int x : data) {
      sum += x;
    }
    return sum;
  }
}
public class ArrayDemo {
  public static void main (String args []) {
    System.out.println(ArrayUtil.sum(1, 2, 3));
    System.out.println(ArrayUtil.sum(new int [] {1, 2, 3}));
  }
}

对象数组

• 动态初始化：类 对象数组名称 [] = new 类 [长度]，每一个元素的内容都是null；
• 静态初始化：类 对象数组名称 [] = new 类 [] {实例化对象, ... , 实例化对象}；

 //动态创建 
class Person {
  private String name;
  private int age;
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  public String getInfo() {
    return "姓名：" + this.name + "、年龄：" + this.age;
  }
}
public class ArrayDemo {
  public static void main (String args []) {
    Person per [] = new Person [3];
    per[0] = new Person("张三", 20);
    per[1] = new Person("李四", 20);
    per[2] = new Person("王五", 20);
    for(int x = 0; x < per.length; x++) {
      System.out.println(per[x].getInfo());
    }
  }
}
//静态初始化
class Person {
  private String name;
  private int age;
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  public String getInfo() {
    return "姓名：" + this.name + "、年龄：" + this.age;
  }
}
public class ArrayDemo {
  public static void main (String args []) {
    Person per [] = new Person [] {
      new Person("张三", 20),
      new Person("李四", 20),
      new Person("王五", 20)
    };
    for(int x = 0; x < per.length; x++) {
      System.out.println(per[x].getInfo());
    }
  }
}

此图源于李兴华老师