数组

85 阅读7分钟

1. 数组的基本概念

数组是最简单的一种数据结构

组织一组相同类型数据的集合（连续的内存）

编号从零开始

1.1 数组的创建和初始化

int[] array = {1,2,3,4,5};
char[] chars = {'a','b','c'};
int[] array2 = new int[]{1,2,3,4,5};
int[] array3 = new int[5];          //这里面是0

1.2 数组的使用

1.2.1 数组中元素的访问

int[] array = {1,2,3,4,5};

//获取数组的值
System.out.println(array[0]);

//给数组赋值
array[0] = 99;
System.out.println(array[0]);

//数组的长度
System.out.println("数组的长度：" + array.length);

image.png

1.2.2 遍历数组（三种遍历方法）

int[] array = {1,2,3,4,5};
for(int i = 0;i < array.length; i++){
    System.out.print(array[i]+" ");
}
System.out.println();

//增强for循环 （for-each）--- 拿不到数组的下标，优势只有可以遍历程序
for(int x : array){
    System.out.print(x+" ");
}
System.out.println();

//Arrays ---> 操作数组的一个工具类
// toString ---> 一个方法 ---> 将数组转化为字符串进行输出
String ret = Arrays.toString(array);
System.out.println(ret);

2.数组是引用类型

2.1 初始JVM的内存分布

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

image.png

  1. 程序计数器 (PC Register): 只是一个很小的空间, 保存下一条执行的指令的地址
  2. 虚拟机栈(JVM Stack): 与方法调用相关的一些信息，每个方法在执行时，都会先创建一个栈帧，栈帧中包含有：局部变量表、操作数栈、动态链接、返回地址以及其他的一些信息，保存的都是与方法执行时相关的一些信息。比如：局部变量。当方法运行结束后，栈帧就被销毁了，即栈帧中保存的数据也被销毁了。
  3. 本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的
  4. 堆: JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2,3} )，堆是随着程序开始运行时而创建，随着程序的退出而销毁，堆中的数据只要还有在使用，就不会被销毁。
  5. 方法区: 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据. 方法编译出的的字节码就是保存在这个区域

2.2 基本类型变量与引用类型变量

  1. 基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值
  2. 引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址。
public static void func() {
    //基本类型变量
    int a = 10;
    int b = 20;
    //引用类型变量
    int[] arr = new int[]{1,2,3};
}


public static void func() {
    int[] array1 = new int[3];
    array1[0] = 10;
    array1[1] = 20;
    array1[2] = 30;
    int[] array2 = new int[]{1,2,3,4,5};
    array2[0] = 100;
    array2[1] = 200;
    array1 = array2;
    array1[2] = 300;
    array1[3] = 400;
    array2[4] = 500;
    for (int i = 0; i < array2.length; i++) {
        System.out.println(array2[i]);
    }
}

2.3 认识 null

null 在 Java 中表示 "空引用" , 也就是一个不指向对象的引用

int[] arr = null;
System.out.println(arr[0]);
// 执行结果
Exception in thread "main" java.lang.NullPointerException
    at Test.main(Test.java:6)
    
//注意: Java 中并没有约定 null 和 0 号地址的内存有任何关联

3. 数组的应用场景

3.1 保存数据

public static void main(String[] args) {
    int[] array = {1, 2, 3};
    for(int i = 0; i < array.length; ++i){
        System.out.println(array[i] + " ");
    }
}

3.2 作为函数的参数

3.2.1 参数传基本数据类型

public static void main(String[] args) {
    int num = 0;
    func(num);
    System.out.println("num = " + num);
}
public static void func(int x) {
    x = 10;
    System.out.println("x = " + x);
}
// 执行结果
x = 10
num = 0

3.2.2 参数传数组类型 (引用数据类型)

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    func(arr);
    System.out.println("arr[0] = " + arr[0]);
}
public static void func(int[] a) {
    a[0] = 10;
    System.out.println("a[0] = " + a[0]);
}
// 执行结果
a[0] = 10
arr[0] = 10

3.3 作为函数的返回值

//获取斐波那契数列的前N项
public class Main{
    public static void main(String[] args) {
        int[] array = fib(10);
        for (int i = 0; i < array.length; i++) {
        	System.out.println(array[i]);
        }
    }
    public static int[] fib(int n){
        if(n <= 0){
            return null;
        }
        int[] array = new int[n];
        array[0] = array[1] = 1;
        for(int i = 2; i < n; ++i){
            array[i] = array[i-1] + array[i-2];
        }
        return array;
    }
}

4. 数组练习

4.1 数组转字符串

toString

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        String arr1 = Arrays.toString(arr);
        System.out.println(arr1);
    }
}

//结果
//[1, 2, 3, 4, 5]

4.2 数组拷贝

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        /**
         * 使用Arrays中copyOf方法完成数组的拷贝：
         * copyOf方法在进行数组拷贝时，创建了一个新的数组
         * arr和newArr引用的不是同一个数组
         */
        int[] arr = {1,2,3,4,5};
        int[] arr1 = Arrays.copyOf(arr,arr.length);
        System.out.println("arr1:"+ Arrays.toString(arr1));

        /**
         * 拷贝某个范围
         * Arrays.copyOfRange ---> 为左闭右开 所为 [0,2)
         */
        int[] arr2 = Arrays.copyOfRange(arr,0,2);
        System.out.println("arr2:"+ Arrays.toString(arr2));
    }
}
/**
* arr1:[1, 2, 3, 4, 5]
* arr2:[1, 2]
*/

copyOf

copyOfRange

实现自己版本的拷贝数组

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] arr3 = myCopy(arr);
        System.out.println("arr3:"+ Arrays.toString(arr3));
    }
    public static int[] myCopy(int[] arr){
        int[] ret = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ret[i] = arr[i];
        }
        return ret;
    }
}

4.3 数组求平均值

public class Main {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        double ret = avg(arr);
        System.out.println(ret);
    }
    public static double avg(int arr[]){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        double ret = sum/arr.length;
        return ret;
    }
}

4.4 查找数组中指定元素 (顺序查找)

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int[] arr = {2,1,1,9,8,5,6,6,6};
        Scanner scanner = new Scanner(System.in);
        int x = scanner.nextInt();
        int ret = find(arr,x);
        System.out.println(ret);
    }
    public static int find(int[] arr,int x){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == x){
                return i;
            }
        }
       return -1;
    }
}

4.5 二分查找

二分查找的前提是数组有序 Arrays.sort(arr);

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int[] arr = {9,8,5,2,1,1,6,6,6};
        //给数组排序
        Arrays.sort(arr);
        System.out.println("arr:"+ Arrays.toString(arr));
        Scanner scanner = new Scanner(System.in);
        int x = scanner.nextInt();
        int ret = binarySearch(arr,x);
        System.out.println(ret);
    }
    public static int binarySearch(int[] arr,int x){
        int left = 0;
        int right = arr.length - 1;
        while (left <= right){
            int mid = (left + right)/2;
            if (x < arr[mid]){
                right = mid - 1;
            } else if (x > arr[mid]) {
                left = mid + 1;
            }else {
                return mid;
            }
        }
        return -1;
    }
}

4.6 冒泡排序

给定一个数组, 让数组升序 (降序) 排序

  1. 将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素就在数组的末尾

  2. 依次从上上述过程，直到数组中所有的元素都排列好

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = {5,8,4,1,6,7,2};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static int[] bubbleSort(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length-i-1; j++) {
                if(arr[j] > arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
        return arr;
    }
}

4.7 数组逆序

设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素.

然后让前一个下标自增, 后一个下标自减, 循环继续即可

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static int[] 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++;
            right--;
        }
        return arr;
    }
}

5. 二维数组

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

public class Main {
    public static void main(String[] args) {
        //二维数组的初始化
        int[][] arr = {{1,2,3},{4,5,6}};
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
        
        //另外两种初始化
        int[][] arr1 = new int[][]{{1,2,3},{4,5,6}};
        int[][] arr2 = new int[2][3]; //默认初始化为0
    }
}
1 2 3 
4 5 6

数组的打印

public class Main {
    public static void main(String[] args) {
        //二维数组的初始化
        int[][] arr = {{1,2,33,4,5,9},{54,8,1}};
        System.out.println(arr.length);//行数
        System.out.println(arr[0].length);//第一行的列数
        System.out.println(arr[1].length);//第二行的列数
        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();
        }
        String ret = Arrays.deepToString(arr);
        System.out.println(ret);
    }
}
1 2 33 4 5 9 
54 8 1 
[[1, 2, 33, 4, 5, 9], [54, 8, 1]]

不规则数组的初始化，打印

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        //Java 当中 二维数组 在定义的时候 是可以省略掉列的
        int[][] arr = new int[2][];//不规则数组 ---> 此刻为空，若打印会有空指针异常
        //进行赋值初始化，使其为0
        arr[0] = new int[3];
        arr[1] = new int[2];
        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();
        }
    }
}
0 0 0 
0 0
avatar
文章
阅读
粉丝