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];
     }
  }