【Java初阶（四）】数组的定义和使用

❣博主主页: 33的博客❣
▶文章专栏分类: Java从入门到精通◀
🚚我的代码仓库: 33的代码仓库🚚

1.前言
2.数组的概念
- 2.1数组的初始化
- 2.2数组的使用
- - 2.2.1数组元素访问
  - 2.2.2遍历数组
3.数组是引用类型
- 3.1实例
- 3.2 认识null
4.数组的应用
- 4.1 二分查找
- 4.2 冒泡查找
- 4.3 Arrays.sort()
- 4.4数组的拷贝
- 4.5copyOf拷贝
5.二维数组
6.总结

1.前言

本章重点：

1.理解数组基本概念
2. 掌握数组的基本用法
3. 数组与方法互操作
4. 熟练掌握数组相关的常见问题和代码

2.数组的概念

数组：相同类型元素的一个集合，在内存中是一段连续的空间。

2.1数组的初始化

数组的创建：

T[] 数组名=new T[N];

**T：**表示数组中存放元素的类型
T[]：表示数组的类型
**N：**表示数组的长度
例：

int[] array1 = new int[10];       // 创建一个可以容纳10个int类型元素的数组
double[] array2 = new double[5];  // 创建一个可以容纳5个double类型元素的数组

数组的初始化：

int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
int[] array1 = {0,1,2,3,4,5,6,7,8,9};//省略了new int[]

2.2数组的使用

2.2.1数组元素访问

数组在内存中是一段连续的空间，空间的编号都是从0开始的，依次递增，该编号称为数组的下标，数组可以通过下标访问其任意位置的元素。

int[]array = new int[]{10, 20, 30, 40, 50};
 System.out.println(array[0]);
 System.out.println(array[1]);
 System.out.println(array[2]);
 System.out.println(array[3]);
 System.out.println(array[4]); 
  System.out.println(array[5]); //有5个元素，下标最大只能为4，array[5]则越界了
// 也可以通过[]对数组中的元素进行修改
 array[0] = 100;
 System.out.println(array[0])

2.2.2遍历数组

int[]array ={10, 20, 30, 40, 50};
//用for循环遍历
 for(int i = 0; i < 5; i++){
    System.out.println(array[i]);
 }
//用 for-each遍历
 for (int x : array) {
    System.out.println(x);
 }
//toString遍历
System.out.println(Arrays.toString(array));//需要导入java.util.Arrays包

3.数组是引用类型

内存是一段连续的存储空间，主要用来存储程序运行时数据的。比如：

程序运行时代码需要加载到内存
程序运行产生的中间数据要存放在内存
程序中的常量也要保存
有些数据可能需要长时间存储，而有些数据当方法运行结束后就要被销毁

3.1实例

int[]array  = {10, 20};

在这里插入图片描述

3.2 认识null

 int[] arr = null;
 System.out.println(arr[0]);

null 在 Java 中表示 “空引用” , 也就是一个不指向对象的引用。一旦尝试读写, 就会抛出 NullPointerException，空指针异常。

4.数组的应用

4.1 二分查找

二分查找只针对有序数组，查找的思路是先取中间位置的元素, 然后使用待查找元素与数组中间元素进行比较：
如果相等，即找到了返回该元素在数组中的下标
如果小于，以类似方式到数组左半侧查找
如果大于，以类似方式到数组右半侧查找

public class Tsest {
    public static int find(int[] arr,int a){
        int l=0;
        int mid=-1;
        int r= arr.length-1;
        while(l<=r){
             mid=(l+r)/2;
            if(arr[mid]==a){
                System.out.println("找到了");
                return mid;
            }
            if(arr[mid]<a){
                l=mid+1;
            }
            if(arr[mid]>a){
                r=mid-1;
            }
        }
        if(l>r){
        System.out.println("没有找到");
        }
        return-1;

    }
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};
        int x=find(arr,6);
        System.out.println(x);
    }
}

4.2 冒泡查找

给定一个数组, 让数组升序 (降序) 排序，将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素就在数组的末尾2. 依次从上上述过程，直到所有元素都排好。

 
        int mid = (left + right) / 2;
        if (toFind < arr[mid]) {
            // 去左侧区间找
            right = mid - 1;
        } else if (toFind > arr[mid]) {
            // 去右侧区间找
            left = mid + 1;
        } else {
            // 相等, 说明找到了
            return mid;
        }
    }
    // 循环结束, 说明没找到
    return -1;
 }
 
// 执行结果
5
 public static void main(String[] args) {
    int[] arr = {9, 5, 2, 7};
    bubbleSort(arr);
    System.out.println(Arrays.toString(arr));
 }
 public static void bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = 1; j < arr.length-i; j++) {
            if (arr[j-1] > arr[j]) {
                int tmp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = tmp;
            }
        }
    } 
 }

冒泡排序性能较低. Java 中内置了更高效的排序算法Arrays.sort()

4.3 Arrays.sort()

public static void main(String[] args) {
    int[] arr={8,5,3,1,9};
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));
}

4.4数组的拷贝

//错误的做法，依然执行同一个对象
int[] arr = {1,2,3,4,5,6};
 int[] newArr = arr
//正确的做法
public static int[] coppy(int[] arr){
    int[] arr1=new int[arr.length];
    for(int i=0;i< arr.length;i++){
        arr1[i]=arr[i];
    }
    return arr1;
}

public static void main(String[] args) {
    int[] arr={8,5,3,1,9};
    int[] arr2=coppy(arr);
    System.out.println(Arrays.toString(arr));
    System.out.println(Arrays.toString(arr2));
}

也使用Arrays中copyOf方法完成数组的拷贝

4.5copyOf拷贝

int[] arr= {1,2,3,4};
int[] newArr = Arrays.copyOf(arr, arr.length);
 System.out.println("newArr: " + Arrays.toString(newArr))
 //拷贝某一个范围
 int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);//范围为[2,4)
 System.out.println("newArr2: " + Arrays.toString(newArr2));
 }

5.二维数组

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组
基本语法：

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

二维数组遍历：

 int[][] arr = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
 };
 
for (int row = 0; row < arr.length; row++) {
    for (int col = 0; col < arr[row].length; col++) {
        System.out.printf("%d\t", arr[row][col]);
    }
    System.out.println("");
 }
 
// 执行结果
1       2       3       4
 5       6       7       8
 9       10      11      1