数组定义与使用

---

一、数组

1.数组初始化

数组的初始化操作：
静态初始化：声明数组同时赋值
数据类型[ ] 数组名称 = {元素的内容}

int[] arr = {1,3,5};

动态初始化：声明时可选赋值
数据类型 [] 数组名称 = new 数据类型 [3];

int [] arr =new int[3];
int [] arr = new int [] {1,3,5};

2.数组长度的取得和访问元素

数组的长度通过数组名.length获得

根据数组的索引来取得数组元素
下标从0开始，索引：0-length-1
数组索引：相对于第一个元素的长度（偏移量）
x地址 = （x-1）*数据类型的大小+数组的首地址

3.引用与对象的关系

内存区域划分：JVM(Java内存模型)-6块区域
栈：方法的局部变量（形参，方法中定义的若干变量）-作用域仅限于方法内部
堆：只要new出来的对象全在堆中存储

引用:只是给对象起了个别名，保存的是对象的地址
对象：new出来的都是对象-实实在在存在的东西


假设现在有两个数组引用，引用b对于数组内容的修改是否影响引用a指向的数组内容：
取决于引用a和b是否保存在同一个地址

二、数组使用

1.数据类型为null的情况

null:引用数据类型的特殊值-引用的默认值
看到new就在堆上开辟新空间

2.将数组转为字符串：序列化json

将任何数据类型->String
使用JDK内置的工具类：java.util.Arrays

自己实现一个仿照Arrays.toString()

public static String arr2Str(int[] arr){
  String ret = "[";
  for (int i = 0;i<arr.length; i++){
    ret += arr[i];
    if(i!=arr.length-1){
      ret +=", ";
    }
  }
  ret +="]";
  return ret;
}

3.数组拷贝

1.使用Arrays.copyOf(原数组名称，拷贝后的新数组长度或想要拷贝的长度)；
注意：从数组的第一个元素开始拷贝-复制，并且为深拷贝
（深拷贝：拷贝后数组对象确实是个新的对象，只是将原数组的内容赋值给新数组
浅拷贝：实际并没有创建新数组，只是有了一个新的数组引用而已）

2.使用Arrays.copyOfRange(原数组名称,原数组起始位置，原数组结束位置)-[from,to)-前闭后开

自己实现一个全拷贝

public static int[] arrCopy(int[] arr){
  int[] ret =new int[arr.length];
  for(int i = li<arr.length;i++){
    ret[i]=arr[i];
  }
  return ret;
}

4.数组递归求和

public static int sumRercursion(int[] arr int left,int right){
  if(right<left){ return -1;}
  if(right==left){return arr[left];}
  return arr[right]+sumRercursion(arr,left,right-1);
}

5.数组查找

1.二分查找：数组必须有序（先使用Arrays.sort(arr)快使用排序：默认升序）
查找次数：logN

public static int binarySearch(int[] arr, int tofind){
  int left =0;
  int right =arr.length-1;
  while(left<=right){
    int mid=(left+right)>>1;
    if(arr[mid]==toFind){return mid;}
    else if(toFind<arr[mid]){right=mid-1;}
    else{left=mid+1;}
  }
  return -1;
}

2.递归查找

public static int binarySearch1(int[] arr , int toFind){
  return binarySearchInternal(arr , toFind, 0, arr .length - 1);
}
public staticiint binarySearchInternal(int[] arr,int toFind,int left,int right) {
  if (left > right) ( // 空区间
    return -1；
  }
  int mid = (left + right) / 2;
  if (arr[mid] == toFind) return mid;
  else if (toFind < arr[mid]){
    return binarySearchInternal(arr , toFind,left, right:mid - 1);
  }else {
  return binarySearchInternal(arr , toFind, left:mid + 1,right);
  }
}

6.数组的顺序

1.判断一数组的有序（升序）

public static boolean isSorted(int[] arr){
  for(int i=0;i<arr.length-1;i++){
    if(arr[i]>arr[i+1]){
      return false;
    }
  }
  return true;
}

2.数组排序：使用Arrays.sort(arr)排序
自己编写一个冒泡排序

public static void bubbleSort(int[] arr){
  //判断某一趟排序后元素是否已经有序
  boolean isSwaped = false;
  //一共需要走多少趟
  for(int i=0;i<arr.length-1;i++){//-1表示前面n-1个已经排序所以剩下最后一个不用排序
  //内层循环进行元素的比较交换
    for(int j=0;j<arr.length-i-1;j++){
      if(arr[j]>arr[j+1]){
      //swap
      int tmp =arr[j];
      arr[j]=arr[j+1];
      arr[j+1]=tmp;
      isSwaped=true;
      }
    }
    if(!=isSwaped){
      break;
    }
  }
}

3.数组逆序操作
[1,2,3,4]->[4,3,2,1]
双引用 left right

public static void reverse(int[] arr){
  int left = 0;
  int right = arr.length-1;
  while(left<right){
    int tmp =arr[left];
    arr[left]=arr[right];
    arr[right]=tmp;
    left++;
    reght--;
  }
}

4.将一个数组的偶数放在前半部分，奇数放在后半部分
eg:[1,2,3,4]->[2,4,1,3]

public static void transFrorm(int[] arr){
  int left=0;
  int right=arr.length-1;
  while(left<right){
    //left指向第一个奇数
    while（left<right&&arr[left]%2!=0){
      left++;
    }
    //right指向第一个偶数
    while(left<right&&arr[right]%2!=0){
      right--;
    }
    //swap
    int tmp==arr[left];
    arr[left]==arr[right];
    arr[right]=tmp;
  }
}

三、二维数组

int[] [] arr 数组名称 = new int [行数][列数]

二维数组的使用及输出

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