Java 数组详解：一维数组+二维数组+数组拷贝

一.一维数组

(1)数组是什么

数组可以装一组相同数据类型数据的容器(变量)数组是一个可以装其它数据(基本类型数据或者引用类型数据即对象)的容器它也是一个对象的,也是在堆空间里分配数组类型本身是一个引用类型(由其它类型加上[])int a = 9; - 基本数据类型int[] ages = new int[20] - 引用类型

(2)声明

1 int[] arr ;//声明数组变量arr = new int[3];//给数组分配内存空间，而且默认值是0

2 int[] arr = new int[3];//定义一个数组变量，并分配内存空间，默认值为0

(3)初始化

1 声明和初始化分开 int[] arr = new int[3];//给数组变量分配内存空间，赋以相应数据类型的默认值。 arr[0] =3; arr[1] =7; arr[2] =9;

java.lang.ArrayIndexOutOfBoundsException数组下标越界异常。

2 声明和初化合在一起 int[] arr = new int[]{3,7,9}; int[] arr = {3,7,9};

数组的每个元素都有一个下标，从0开始，最后一个下标长度-1

(4)内存情况

基本类型的数组int[] arr = new int[3];arr[0] = 6;

引用数据类型的数组Dog[] dogs = new Dog[3];dogs[0] = new Dog();

 

(5)length属性

数组有下标，从零开，每个数组内部都有一个属性：length，用于获取数组长度

数组下标和属性length的关系最大的下标 =length-1

java.lang.ArrayIndexOutOfBoundsException - 数组下标越界异常访问了超过最大下标的元素

面试：是非题：字符串(String)有一个length属性，数组有一个length()方法

(6)遍历

1 含义： 也称迭代，就是循环访问数组中的每个元素

2 如何遍历 for()

3 下标越界异常 java.lang.ArrayIndexOutOfBoundsException 当下标超过数组的最大下标时(length-1),就报出上面的错误

(7)获取最大最小元素

int[] arr = {2,3,9,9,2,3,5,1,3,4,7};
     int max =arr[0];
     for(int i=1;i<arr.length;i++){
       if(arr[i]>max){
          max = arr[i];
       }
     }
     System.out.println("最大的元素是:"+max);
     
     int min =arr[0];
     for(int i=1;i<arr.length;i++){
       if(arr[i]<min){
          min = arr[i];
       }
     }
     
     System.out.println("最小的元素是:"+min);

(8)冒泡排序

int[] ages = {3,2,4,1,3,7,89,4,3,5,6,43,21,2,35};
     for (int i = 0; i < ages.length-1; i++) {
       for (int j = 0; j < ages.length-1-i; j++) {
          if (ages[j]>ages[j+1]) {
            int temp = ages[j];
            ages[j] = ages[j+1];
            ages[j+1] = temp;
          }
       }
     }

二.二维数组

(1)声明，初始化

//1 单独声明
  int[][] arr = new int[2][3];
  int[][] arr = new int[2][];//允许第二维没有长度

//2 与初始化一起
  数组里面装数组
  int[][] arr = new int[][]{{1,2,3},{4,5,6}};
  int[][] arr = new int[][]{{1,2,3},{4,5}};
  int[][] arr = {{1,2,3},{4,5}};

//3 单独初始化
  int[][] arr1 = new int[2][3];
  arr1[1][1] = 8;

(2)内存情况

第1种内存情况 int[][] arr = new int[2][3];

第2种内存情况 int[][] arr = new int[2][];//允许第二维没有长度 //arr[1][1]=8;//NullPointException arr[1] = new int[2]; arr[1][1]=8;

 

第3种内存情况 int[][] arr2 = new int[][]{{1,2,3},{4,5}};

第4种内存情况(引用类型) Dog[][] dogs = new Dog[2][]; dogs[1] = new Dog[3]; dogs[1][1] = new Dog(); dogs[0][1]= new Dog();//NullPointException dogs[1][0].bark();//NullPointException

 

(3)遍历

int[][] arr = new int[][]{{2,6,3},{5,8}};
     
     for(int i=0;i<arr.length;i++){
       for(int j=0;j<arr[i].length;j++){
          System.out.print(arr[i][j]+", ");
       }
       System.out.println();
     }

三.数组拷贝

 (1)System.arraycopy()

System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)从一个源数组复制指定length个数到目标数组的指定位置

src - 源数组。srcPos - 源数组中的起始位置。dest - 目标数组。destPos - 目标数据中的起始位置。length - 要复制的数组元素的数量

int[] src = {8,2,5,4,9,1,6};
     int[] dest = new int[5];
     System.out.println("拷贝前:"+Arrays.toString(dest));
     System.arraycopy(src,2,dest,1,3);
     
     System.out.println("拷贝后:"+Arrays.toString(dest));

(2)自己封装API

public static void copyarray(int[] src,int srcPos,int[] dest,int destPos,int len){
     for(int i=0;i<len;i++){
       dest[destPos+i] = src[srcPos+i];
     }
  }
public static void copyarray2(int[] src,int srcPos,int[] dest,int destPos,int len){
     for(int i=srcPos;i<srcPos+len;i++){
       dest[destPos++] = src[i];
     }
  }