Java数组重点知识和常见应用

1、数组的基本概念

• 数组的概念：是存储同一种类型多个元素的集合，可以看成是一种容器，它既可以存储基本类型也可以存储引用类型。
• 初始化：为数组中的数据元素分配内存，并为每个元素赋值。

int[] arr1 = {1,2,3}    //静态初始化(赋值后系统据此决定长度)
int[] arr2 = new int [] {1,2,3} //动态初始化
int[] arr3 = new int[2] 没有初始化数值，动态开辟了3个空间，int类型的数组，是基本的内置类型，初始值是0

//空指针异常
	int[] arr =null;
	    System.out.println(arr.length);
	
	String str2 = null；
	    System.out.println(str2.length()) //空指针异常在这之前一定要初始化

• 内存分配：
  A 栈：存储局部变量(在方法定义或者方法声明上的变量都成为局部变量)
  栈上的数据用完就释放掉 int a = 10；
  B 堆：存储new出来的东西
  特点：每一个new出来的东西都有地址值(一般为16进制)，每个变量都有默认值。使用完毕就变成了垃圾，但是并没有立即回收，会在垃圾回收器空连的时候回收
  

• 数组作为方法的参数,注意引用类型和基本类型的区别。
  一定关注好传出去的是什么就用什么类型的来接受，注意好要传的是什么
  

2、数组的使用

• arr.length 获取数组长度，注意.是一个成员操作符，要注意不要把这个length当成方法了。
• 下标操作符不能超出[0,length-1],否则会越界哦(这里给自己先挖个坑)
• 遍历数组

int[] arr = {1,2,3};
    for(int i =0;i<arr.length;i++) {
    System.ot.println(arr[i])
}

• 使用for-each遍历数组

int[] arr = {1,2,3};
    for(int x : arr){
        System.out.println(x);
}

• 二分查找

//用循环
public static int binarySearch(int[] arr,int key) {
    int left =0;
    int right = arr.length-1;
    while(left<=right){
        int mid = (left+right)/2;
        if(key<=arr[mid]){
            right=mid-1;
        } else if(key>arr[i]) {
            left=mid-1;
        } else {
            return mid;
        }
    }
    return -1;
}

//递归实现
public static int binarySearch(int[] array,int key,int left,int right){
        if(left>right) {
            return -1;
        }
        int mid=(left+right)/2;
       if(key==array[mid]) {
           return mid;
       } else if(key<array[mid]) {
           return binarySearch(array,mid,left,mid-1);
        } else(key>array[mid]) {
          return binarySearch(array,mid,right,mid+1);
       }
   }

• 数组逆置

public static void reverase(int[] arr) {
    int left = 0;
    int right = arr.length-1;
    while(left<right) {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = tem;
        left++;
        right--;
    }
}

• 数组拷贝(关于深浅拷贝先挖个坑)

//方法1：通过for循环
	    int[] array1={1,2,3}
	    int[] array2= new int[array.length];
	for(int i =0;i<array1.length;i++){
		array2[i]=array1[i];
	}

//方法2：通过System.arraycopy()这是系统提供的拷贝方式，底层用c/c++写的，速度很快的
	int[] array1 = new int[5];
	    System.out.println(array1,0,array3,0,5);
	/*arraycopy()的参数说明：
	arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
	Object src:表示原数组，也就是被拷贝的数组
	srcPos：原数组的起始位置
	Object dest：目标数组，也就是拷贝存放的数据
	destPos：目标数组的起始长度
	length：要copy数组的长度*/
	

//方法三：通过Arrays.copyOf(被复制的数组，数组的长度)实际上也是调用的 
    System.arraycopy()
	int[] array2 = new int[5];
	array2 = Arrays.copyOf(array1,5);

//方法四：通过Object.clone()
	int[] array2 = new int[5];
	array2 = array1.clone();

* 数组转字符串

```java
import java.util.Arrays;
	int[] arr = {1,2,3}
	String str = Arrays.toString(str)	//注意字符串类型也是一个引用类型，同样是在堆上创建对象的
System.out.println(str);

// 执行结果 [1,2,3]

3、二维数组

• 基本语法

数据类型 [] [] 数组名称 = new 数据类型 [行数] [列数] {初始化数据}

• 遍历

int[][] arr = {1,2,3,4,5,6};
for(int row = 0;row<arr.length;row++) {
	for(int col = 0;col<arr[row].length;col--) {
		System.out.print(arr[row][col]+",");
	}
	System.out.println("")
}