Java学习五—数组

qq_17153885

于 2024-03-19 00:27:22 发布

阅读量746

点赞数 26

分类专栏： java 文章标签： java 学习 python

本文链接：https://blog.csdn.net/qq_17153885/article/details/136826221

版权

java 专栏收录该内容

32 篇文章 2 订阅

订阅专栏

本文详细介绍了Java中数组的概念、声明与初始化、数组元素的访问、数组长度获取、遍历方法（for和foreach）、常见操作如添加、删除和查找元素，以及Arrays工具类的使用，包括sort、binarySearch和equals等方法。

摘要由CSDN通过智能技术生成

一、关于数组

1.1简介

在Java中，数组是一种特殊的对象，用于存储固定大小的相同类型的元素。数组可以存储基本数据类型（如int、char、boolean等）或对象引用。

1.2背景

我们可以想一个问题，如果现在让你存储100个学生的数学成绩，你该怎么存储呢？难道要定义100个变量，每个变量代表一个学生的成绩吗？如果是存储1000个、10000个、乃至更多学生的成绩怎么办？

如果是定义一个个变量进行存储，就太麻烦了，而且这也不符合项目开发时对复用性、可读性等方面的要求。所以我们肯定不能这么编程。那么现在解决的办法，就是可以使用”数组“来进行实现。

‍

给大家举个栗子，下图的这个东西你见过吗？

8d6da651-c6cf-4ddb-b63f-8ba62b6fc55f

这是存储这些鸡蛋的”容器“–鸡蛋托！一个鸡蛋托有多个存储格子，每个格子只能存储一个鸡蛋，并且这些格子只能用来存储鸡蛋，不能存储其他的东西。一个鸡蛋托可以存储的鸡蛋数量是有限的，不能无限存储。

其实Java里的数组就类似于是”鸡蛋托“，数组中存储的数据元素就是一个个的”鸡蛋“。一个数组占据了内存中的一片连续空间，只能存储相同类型的数据，数组有一定的存储空间。我们在创建数组时，需要先声明数组的类型，之后该数组中只能存储指定类型的数据。

我们把存储在数组中的每一个数据，称为”数据元素“。这些数据元素会按着一定的顺序排列存储，并赋予每个数据元素对应的编号。我们可以直接通过编号(索引、下标)的方式来调用指定位置上的数据元素，查找速度会很快。
数组本身是引用类型，但数组中的数据元素可以是任何数据类型，包括基本数据类型和引用数据类型。
数组创建时需要指定一个名称，并会在内存中开辟一整块连续的内存空间，数组名引用的就是这块连续空间的首地址(第一个地址)。
数组创建后，长度一旦确定，就不能再被修改。

‍

二、数组的声明和初始化

在 Java 中，要使用数组，首先需要声明和初始化它。声明一个数组只是告诉编译器你将要使用一个数组，但并不分配内存空间。初始化数组是为数组分配实际的内存，并为数组的元素赋初值。

2.1数组的声明

要声明一个数组，你需要指定数组的类型，后面跟着数组名字和一对方括号 []，例如：

int[] numbers; // 声明一个整数数组

以上代码声明了一个名为“numbers”的整数数组

‍

可以在声明时为数组分配内存，例如：

int[] numbers = new int[5]; // 声明并分配一个包含 5 个整数的数组

‍

2.2数组的初始化

初始化数组是为数组分配内存并赋予初始值。Java 中有几种初始化数组的方式。

‍

直接初始化

你可以在声明数组的同时为数组分配内存并赋值，例如：

int[] numbers = {1, 2, 3, 4, 5}; // 直接初始化一个整数数组

‍

示例：

‍

使用循环初始化

你也可以使用循环来初始化数组，例如：

int[] numbers = new int[5]; // 声明一个包含 5 个整数的数组
for (int i = 0; i < 5; i++) {
    numbers[i] = i + 1;
}

‍

2.3访问数组元素

访问数组元素是指通过数组的索引来获取数组中的值。在 Java 中，数组的索引从 0 开始，因此第一个元素的索引是 0，第二个元素的索引是 1，以此类推。

例如，要访问上面示例中的 numbers 数组的第一个元素，可以使用以下代码：

int firstNumber = numbers[0]; // 获取第一个元素的值，即 1

‍

2.4数组的长度

要获取数组的长度（即数组中元素的个数），可以使用数组的 length 属性，例如：

int length = numbers.length; // 获取数组 numbers 的长度，即 5

‍

三、遍历数组

遍历数组是指逐个访问数组中的所有元素，通常使用循环来实现。在 Java 中，常用的循环有 for 循环和 foreach 循环

3.1使用 for 循环遍历数组

使用 for 循环可以遍历数组的所有元素，例如：

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

for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]); // 输出数组元素
}

‍

3.2使用 foreach 循环遍历数组

Java 5 引入了 foreach 循环，可以更简洁地遍历数组，例如：

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

for (int number : numbers) {
    System.out.println(number); // 输出数组元素
}

foreach 循环适用于遍历整个数组，但不能改变数组元素的值。

‍

四、数组的常见操作

除了声明、初始化和遍历数组，数组还支持许多常见的操作，如添加元素、删除元素、查找元素等。以下是一些常见的数组操作：

4.1添加元素

要向数组添加元素，需要先创建一个新的数组，然后将原数组的元素复制到新数组中，并在新数组中添加新元素。Java 中的数组大小是固定的，所以添加元素通常需要创建一个新数组。

// 原始数组
int[] originalArray = {1, 2, 3, 4, 5};

// 新增元素后的长度
int newLength = originalArray.length + 1;

// 创建新数组
int[] newArray = new int[newLength];

// 将原始数组中的元素复制到新数组中
for (int i = 0; i < originalArray.length; i++) {
    newArray[i] = originalArray[i];
}

// 添加新元素到新数组的末尾
int newElement = 6;
newArray[newLength - 1] = newElement;

// 新数组现在包含了原始数组的所有元素，并且增加了一个新元素

‍

4.2删除元素

删除数组中的元素通常也需要创建一个新数组，将原数组中不需要删除的元素复制到新数组中。要删除元素，通过找到要删除的元素的索引，然后将其跳过。以下是一个删除数组元素的示例：

// 原始数组
int[] originalArray = {1, 2, 3, 4, 5};

// 要删除的元素的索引
int indexToRemove = 2; // 假设要删除索引为2的元素（即值为3的元素）

// 新数组的长度
int newLength = originalArray.length - 1;

// 创建新数组
int[] newArray = new int[newLength];

// 复制原数组中不需要删除的元素到新数组中
for (int i = 0, j = 0; i < originalArray.length; i++) {
    if (i != indexToRemove) {
        newArray[j] = originalArray[i];
        j++;
    }
}

// 新数组现在包含了原始数组中除了要删除元素之外的所有元素

‍

4.3查找元素

要在数组中查找元素，可以使用循环遍历数组，逐个比较每个元素的值，找到匹配的元素后返回索引或值。以下是一个查找元素的示例：

// 给定数组
int[] myArray = {10, 20, 30, 40, 50};

// 要查找的元素
int elementToFind = 30;

// 使用循环遍历数组，查找元素
boolean found = false;
for (int i = 0; i < myArray.length; i++) {
    if (myArray[i] == elementToFind) {
        found = true;
        System.out.println("元素 " + elementToFind + " 在数组中的索引为：" + i);
        break;
    }
}

if (!found) {
    System.out.println("元素 " + elementToFind + " 不在数组中");
}

‍

4.4排序

‍

冒泡排序

冒泡排序是一种简单的排序算法，它重复地遍历要排序的数组，依次比较相邻的两个元素，并将它们按照要求交换位置，直到整个数组有序为止。这个过程就像气泡在水中逐渐上升一样，故称为冒泡排序。

冒泡排序的基本思路是，每一轮比较相邻的两个元素，如果它们的顺序不符合要求，则交换它们的位置，直到所有元素都排好序为止。

‍

示例

public class BubbleSortExample {
    public static void main(String[] args) {
        int[] arr = {4, 2, 7, 1, 5};
  
        bubbleSort(arr);
  
        System.out.println("排序后的数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
  
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换位置
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

‍

五、数组工具类：Arrays

在Java中，java.util.Arrays是一个工具类，提供了各种用于操作数组的静态方法。这个工具类包含了许多有用的方法，例如对数组进行排序、搜索、比较以及填充等操作。下面简要介绍一些java.util.Arrays类中常用的方法：

sort(T[] a): 对指定数组进行排序。根据元素的自然顺序进行升序排序。
binarySearch(T[] a, T key): 使用二分查找算法在指定数组中搜索指定的元素。数组必须是有序的。
copyOf(T[] original, int newLength): 复制指定数组的指定长度。
equals(T[] a, T[] a2): 比较两个数组是否相等。
fill(T[] a, T val): 将指定值填充到数组中的每一个元素。
asList(T... a): 返回一个固定大小的列表，支持更改（add/remove）操作。
toString(T[] a): 返回一个包含数组元素的字符串表示形式。
deepEquals(Object[] a1, Object[] a2): 深度比较两个对象数组是否相等。
stream(T[] array): 将数组转换为Stream对象。

这些方法提供了方便且高效的方式来操作数组，避免了手动编写很多重复的代码。使用java.util.Arrays类可以简化对数组的处理，提高代码的可读性和可维护性。不过需要注意的是，java.util.Arrays类中的方法都是针对对象数组的，对于基本数据类型的数组，需要使用对应的装箱类型（如Integer[]代替int[]）来调用这些方法。

‍

5.1Arrays.toString()

返回一个包含数组元素的字符串表示形式。

package com.song.array;

import java.util.Arrays;

public class ArrayDemo10 {
    public static void main(String[] args) {

        int[] a = {10,20,30,40,50};
        //System.out.println(a);
        //这样输出结果为 [I@1b6d3586
        //不能直接这样输出，直接打印数组元素可以用Arrays.toString

        //打印数组元素Array.toString
        System.out.println(Arrays.toString(a));
    }
}

运行后显示

‍

5.2Arrays.fill()

将指定值填充到数组中的每一个元素

package com.song.array;

import java.util.Arrays;

public class ArrayDemo11 {
    public static void main(String[] args) {
        int[] a = new int[10];
        //填充数组元素 Arrays.fill
        Arrays.fill(a,5);
        //打印数组元素 Arrays.toString
        System.out.print(Arrays.toString(a));
    }
}

运行后显示：

‍

5.3Arrays.sort( )

package com.song.array;

import java.util.Arrays;

public class ArrayDemo12 {
    public static void main(String[] args) {
        int[] a = {10,153,12,45,156,16,41,19};
        //给数组进行排序：升序
        Arrays.sort(a);
        //打印数组元素
        System.out.print(Arrays.toString(a));
    }
}

运行后显示：

‍

5.4Arrays.equals(a , b )

通过equals方法比较数组中元素值是否相等。

package com.song.array;

import java.util.Arrays;

public class ArrayDemo14 {
    public static void main(String[] args) {
        //定义几个数组
        int[] a = {1,2,3};
        int[] b = {1,2,3};
        int[] c = {4,5,6};

        if (Arrays.equals(a,b)){
            System.out.println("a等于b");
        } else {
            System.out.println("a不等于b");
        }
        if (Arrays.equals(a,c)){
            System.out.println("a等于c");
        } else {
            System.out.println("a不等于c");
        }
    }
}

运行后显示：

‍

5.5Arrays.binarySearch(a , 12 )

通过binarySearch方法能对排序好的数组进行二分查找法操作。

package com.song.array;

import java.util.Arrays;

public class ArrayDemo13 {
    public static void main(String[] args) {
        int[] a = {10,153,12,45,156,10,41,19};
  
        Arrays.sort(a);//将数组a进行排序：升序
        //操作Arrays.binarySearch前必须先将数组进行升序
        //升序后的数组 a: [10, 10 ,12 ,19 ,41 ,45 ,153 ,156]
  
        int i = Arrays.binarySearch(a,12);//查找数组a中12的下标
  
        System.out.print("12的下标为"+i);//输出12的下标
    }
}