Java数组

数组

定义

• 数组是一组相同数据类型元素的集合
• 在Java中数组属于引用类型，即数组是一个对象
• 数组的数据类型不仅含八大基本数据类型，还包含引用数据类型，如数组里面可以存数组,数组里面 可以存放字符串

一维数组

申明

int[] a;  //推荐使用
int b [];

**注意：**a、b两个数组均为在堆中分配空间，默认值为null

初始化

静态初始化

int[] a = {1,2,3,4,5};  //简化格式
int[] a = new int[]{1,2,3,4,5};//完整格式

动态初始化

int[] b=new int[10];//申明并分配可以存储10个int类型数据的空间

赋值

通过下标赋值，下标从0开始，0代表的是数组中的第一个元素

public class ArrayDemo02 {
    public static void main(String[] args) {
        int[] num=new int[10];
        num[0]=1;//赋值
        num[1]=2;
        num[2]=3;
        System.out.println(num[0]);  //1
        System.out.println(num[3]);  //0,若数组未赋值，则默认为0
    }
}

一维数组的遍历

for循环

public class Test {
    public static void main(String[] args) {

        int[] num = new int[10];
        num[0]=1;
        num[1]=2;
        num[2]=3;
        num[3]=4;
        num[4]=5;
        num[5]=6;
        num[6]=7;
        num[7]=8;
        num[8]=9;
        num[9]=10;
        
        for (int i = 0; i <num.length ; i++) {
            System.out.print(i); //0123456789
        }
    }

增强for循环

public class Test {
    public static void main(String[] args) {

        int[] num = {1,2,3,4,5,6,7,8,9,10};

        for (int arr: num) {
            System.out.print(arr); //12345678910
        }
    }
}

二维数组

概念

概念：数组里的每一个元素都是是一个一维数组的数组被称为二维数组

初始化

静态初始化

int[][]array = {{1,2},{3,4},{5,6}};

动态初始化

int[][]array = new int[2][5]; //定义二维数组，二行五列

赋值

public class Test {
    public static void main(String[] args) {

        int [][] num = new int[2][5];
        num[0][0] = 10;
        num[0][1] = 20;
        num[0][2] = 30;
        num[1][0] = 40;
        num[1][1] = 50;
        num[1][2] = 60;
        System.out.println(num[0][2]); //30
        System.out.println(num[1][2]); //60
        System.out.println(num[1][4]); //0  未被赋值，默认初始值为0
        }
    }

二维数组长度

• 代码表示：

  public class Test {
      public static void main(String[] args) {
          int[][] a = {{0,1,10,20,30},{2,3,11},{4,5,12},{6,7,13},{8,9,14}};
          System.out.println(a.length);    //5
          System.out.println(a[0].length); //5
          System.out.println(a[1].length); //3
      }
  }
  

二维数组的遍历

for

public class Test {
    public static void main(String[] args) {

        int [][] num = {{1,2},{3,4},{5,6}};
        System.out.println(num.length);  //输出数组的长度

        for (int i = 0; i < num.length; i++) {
            for (int j = 0; j <num[i].length ; j++) {
                System.out.print(num[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

增强型for

public class Test {
    public static void main(String[] args) {

        int [][] num = {{1,2},{3,4},{5,6}};

        for (int [] arr:num) {
            for (int i:arr) {
                System.out.print(i); //123456
            }
        }
        System.out.println();
    }
}

数组内存分析

数组的引用传递

1. 首先执行new int[] {1,2,3}，在堆上开辟12个字节的空间，每四个分别用来存放arr[0],arr[1],arr[2],并对它们进行初始化

2. 然后在栈上为局部变量arr分配空间，并将堆空间的地址（首地址）存到栈空间的arr里面，此时栈上的arr的值就是堆上的数组空间的地址，因此二者建立了一定联系，这里用指向来表示

3. 再接着在栈上定义了一个局部变量x，并把arr的值赋给x

4. 最后x里面也存的是堆空间的首地址，此时x也指向那块堆空间，利用x也可对堆空间的值进行操作，这便称为引用传递

   本质：

   ​ *多个栈空间同时指向同一块堆内存。没有栈内存指向的堆内存也被称为垃圾空间。

   • 代码实现：

     public class Test {
         public static void main(String[] args) {
     
             int[] a = {1, 2, 3, 4, 5};
             System.out.println(a[0]); //1
     
             int[] b=a;  //a和b指向堆上同一内存
             a[0]=10;
             b[0]=100;
             System.out.println(a[0]); //100
             System.out.println(b[0]);  //100
         }
     }
     

数组的特点

1.长度是确定的，一旦被创建，长度无法改变
2.元素是相同类型，不允许出现混合类型
3.数组中的元素可以是任何数据类型，包括基本类型和引用类型
4.数组变量属于引用类型，数组也可以看成对象，数组中的每个元素相当于该对象的成员变量
5.数组本身就是对象，Java对象在堆中，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中

普通for循环 与 for增强型区别？

1. 增强for循环必须有被遍历的目标（如集合或数组）
2. 普通for循环遍历数组的时候需要索引
3. 增强for循环不能获取下标，所以遍历数组时最好使用普通for循环

数组常见异常

• NullPointerException 空指针异常

  原因： 引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法

• ArrayIndexOutOfBoundsException 索引值越界

  原因：访问了不存在的索引值

练习题

• 找出数组中元素最大值

  public class Test {
      public static void main(String[] args) {
          int[] a={1,2,6,4,5};
  
          //找出元素最大值
          int max = a[0];
          for (int i = 1; i <a.length ; i++) {
              if (a.length > max){
                  max = a[i];
              }
          }
          System.out.println(max);
      }
  }
  

• 反转数组元素

  public class Test {
      public static void main(String[] args) {
          int[] a={1,2,3,4,5};
  
          int[] b = reverse(a);  //b数组存储反转回来的数组
          PrintArray(b);
      }
      //打印数组
      public static void PrintArray(int[] a){
          for (int i = 0; i < a.length; i++) {
              System.out.print(a[i]);
          }
      }
      //反转数组
      public static int[] reverse(int[] a){
          int[] result = new int[a.length];
          for (int i = 0,j = result.length-1; i <a.length ; i++,j--) {
              result[j] = a[i];
          }
          return result;  //有返回值，不能void
      }
  }
  

• 冒泡排序（重点）

  public class ArrayDemo06 {
      public static void main(String[] args) {
          int[] a ={5,14,4,2,456,23,56,23,556};
  
          int[] sort = sort(a);  //调用完排序方法后，返回一个排序后的数组
  
          System.out.println(Arrays.toString(sort));
  
      }
      //冒泡排序，比较数组中两个相邻的元素，若第一个比第二个大，则交换位置
      public static int[] sort(int[] array){
          int temp=0;
          for (int i = 0; i < array.length-1; i++) {
              for (int j = 0; j < array.length-1-i ; j++) {
                  if (array[j+1]>array[j]){
                      temp = array[j];
                      array[j]= array[j+1];
                      array[j+1]=temp;
                  }
              }
  

参考

• 二维数组
• 二维数组