Java 数组的基本用法

港控/mmm° 2024-03-26 17:58 88阅读 0赞

#### Java 数组的基本用法 ####

*   *  1 数组的基本理论
     *  2 数组的创建
     *   *  2.1 一维数组的创建
         *   *   *  2.1.1数组的声明：
                 *  2.1.2 数组的初始化
                 *   *  静态初始化：
                     *  动态初始化：
                 *  2.1.3 数组的访问
         *  2.2 二维数组的创建
     *  2 数组的内存分析
     *  3 数组的操作(Arrays的使用)
     *   *  3.1 填充替换数组元素
         *  3.2 数组排序
         *  3.3 将数组的元素以字符串的形式返回
         *  3.4 查询数组

### 1 数组的基本理论 ###

数组是最为常见的一种数据结构，是相同类型的用一个标识符封装到一起的基本类型数据序列或对象序列。实质上，数组是一个简单的线性序列，因此访问速度很快。

**数组是具有相同数据类型的一组数据的集合。** 例如，水果的集合：苹果、梨、桃、葡萄等；编程语言的集合：Java、Python、C/C++、C\#、PHP等。在程序设计中，可以将这些集合称为数组。数组中的每个元素具有相同的数据类型。

### 2 数组的创建 ###

#### 2.1 一维数组的创建 ####

###### 2.1.1数组的声明： ######

数组元素类型 数组名字[ ];
    数组元素类型[ ] 数组名字;

符号“\[ \]”指明该变量是一个数组类型变量。单个“\[ \]”表示要创建的数组是一个一维数组。

例：

int arr[];
     int[] arr;  //声明int型数组，数组中的每个元素都是int型数值

###### 2.1.2 数组的初始化 ######

初始化：就是在内存中为数组分配内存空间，并将数据存入。

###### 静态初始化： ######

格式：

数据类型[] 数组名=new 数据类型[]{
        元素1，元素2，元素3......};

例：

int[] arr=new int[]{
        1,2,3};
    double[] arr2=new double[]{
        1,2,3};

由于上述表述比较复杂，因此在Java中还有一种简化表示。

简化格式：

数据类型[] 数组名={
        元素1，元素2，元素3......};

例：

int[] arr={
        1,2,3};
     double[] arr2={
        1,2,3};

###### 动态初始化： ######

格式：

数据类型[] 数组名=new 数据类型[数组的长度];

例：

int[] arr=new int[10];
    double[] arr2=new double[10]; //定义数组长度为10的数组

###### 2.1.3 数组的访问 ######

`for`语句：

public class test {
        
        public static void main(String[] args) {
        
            int[] arr={
        1,1,2,3,5,8,13,21,34};
            for (int i = 0; i < arr.length; i++) {
        
                System.out.print(arr[i]+" ");
            }
        }
    }

`foreach`语句：

public class test {
        
        public static void main(String[] args) {
        
            int[] arr={
        1,1,2,3,5,8,13,21,34};
            for (int i:arr) {
        
                System.out.print(i+" ");
            }
        }
    }

1 1 2 3 5 8 13 21 34

#### 2.2 二维数组的创建 ####

二维数组可以看作是特殊的一维数组，因此二维数组的创建与一维数组很相似。

int arr[][] = {
        {
        1,2},{
        3,4}};//静态初始化
    int arr2 = new int[2][4]    //动态初始化

`for`语句：

public class test {
        
        public static void main(String[] args) {
        
            int arr[][] = {
        {
        1,2},{
        3,4}};
    
            for (int i = 0; i < arr.length; i++) {
        
                for (int j = 0; j < arr[i].length; j++) {
        
                    System.out.print(arr[i][j] + " ");
                }
            }
        }
    }

`foreach`语句：

public class test {
        
        public static void main(String[] args) {
        
            int arr[][] = {
        {
        1,2},{
        3,4}};
    
            for (int[] x : arr) {
        
                for (int y : x) {
        
                    System.out.print(anInt + " ");
                }
            }
        }
    }

1 2 3 4

### 2 数组的内存分析 ###

数组是一个引用数据类型，他的元素可以是任何数据类型包括基本数据类型，引用数据类型。数组长度确定后是不可以修改的。数组里的数据是有序的排列，创建一个数组时会在内存中开辟连续的空间，数组名是数组的首地址，就是指向数组中第一个元素的地址。

public class test {
        
        public static void main(String[] args) {
        
            int[] arr={
        1,1,2,3,5,8,13,21,34};
            double[] arr1={
        3.14,0.681,37.78,0.0255};
            System.out.println(arr); //访问数组的地址值
            System.out.println(arr1);
        }
    }

[I@119d7047
    [D@776ec8df

这串地址值作为int类型数组在内存中存放的地址。其中有几个`[`就表示几维数组，此处一个`[`就表示一维数组，`I`就表示是一个`int`类型，后面的数字就表示一个16进制的数字，中间的`@`符号起到分隔作用。

**JVM体系结构:**  
![在这里插入图片描述][430a99940eb84cf4831a9a33a9ae33b5.png]  
栈：方法运行时使用的内存，比如`main`方法运行，进入方法栈中执行。  
堆：存储对象或数组，`new`来创建，都存储在堆内存  
方法区：存储可以运行的`class`文件。  
本地方法栈：管理本地方法的调用，JVM在使用操作系统功能时使用。  
程序计数器：存放下一条指令所在单元的地址的地方。  
例如：  
![在这里插入图片描述][49cd6dfbc9b94a649d637d2ea3ed0ea7.png]

### 3 数组的操作(Arrays的使用) ###

#### 3.1 填充替换数组元素 ####

数组中的元素定义完成后，可通过`Arrays`类的静态方法`fill()`来对数组中的元素进行替换。该方法通过各种重载形式可完成对任意类型的数组元素的替换。  
格式：

fill(int[] a,int fromIndex,int toIndex,int value)
    
    1.a:要进行填充的数组。
    2.fromIndex：要使用指定值填充的第一个元素的索引（包括）。
    3.toIndex：要使用指定值填充的最后一个元素的索引（不包括）。
    4.value：要分配给数组指定范围中的每个元素的值。

例：

import static java.util.Arrays.fill;
    public class test {
        
        public static void main(String[] args) {
        
            int[] arr={
        1,1,2,3,5,8,13,21,34};
            fill(arr,2,5,1000);  //索引为2~5（不含）的数替换为1000
            for (int i = 0; i < arr.length; i++) {
        
                System.out.print(arr[i]+" ");
            }
        }
    }

1 1 1000 1000 1000 8 13 21 34

#### 3.2 数组排序 ####

通过Arrays类的静态方法`sort()`可以实现对数组的排序。  
格式：

Arrays.sort(object)
    
    object是指进行排序的数组名称

例：

import java.util.ArrayList;
    import java.util.List;
    import java.util.Random;
    import static java.util.Collections.sort;
    
    public class a {
        
        public static void main(String[] args) {
        
            List<Integer> list=new ArrayList<Integer>();  //可以改变大小的ArrayList数组
            Random b=new Random();
            System.out.print("排序前的数列："+"[");
            for (int i = 0; i < 10; i++) {
        
                int number=b.nextInt(100);
                list.add(number);
                sort(list);
                System.out.print(number+",");
            }
           System.out.println("]");
           System.out.println("排序后的数列："+list);
        }
    }

排序前的数列：[8,26,42,70,37,34,19,67,97,57] 
    排序后的数列：[8, 19, 26, 34, 37, 42, 57, 67, 70, 97]

#### 3.3 将数组的元素以字符串的形式返回 ####

`toString()` 将数组的元素以字符串的形式返回。

import java.util.Arrays;
    public class 实验 {
        
        public static void main(String[] args) {
        
            int[] arr={
        1,1,2,3,5,8,13,21,34};
            System.out.println(Arrays.toString(arr));
        }
    }

[1, 1, 2, 3, 5, 8, 13, 21, 34]

#### 3.4 查询数组 ####

`Arrays`类的`binarySearch()`方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。  
格式：

binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
    
    1.a：要搜索的数组。
    2.fromIndex：要搜索的第一个元素的索引（包含fromIndex）。
    3.toIndex：要搜索的最后一个元素的索引（不包含toIndex）。
    4.key：要搜索的值。

如果`key`包含在数组中，则返回搜索值的索引；否则返回-1或“-”（插入点）。插入点是搜索键将要插入数组的那一点，即第一个大于此键的元素索引。  
例：

import java.util.Arrays;
    public class 实验 {
        
        public static void main(String[] args) {
        
            int[] arr={
        1,1,2,3,5,8,13,21,34};
            int index=Arrays.binarySearch(arr,0,5,5);
            int index1=Arrays.binarySearch(arr,0,5,10);
            System.out.println(index);
            System.out.println(index1);
        }
    }

4
    -6

上面的代码中变量`index`的值是元素“5”在数组arr中索引在0～5内的索引位置。`index`的值是“5”的索引位置4。变量`index`的值是元素“10”在数组arr中索引不在0～5内的索引位置。元素“10”应该在“13”的前面，因此插入点应是元素“13”的索引值6，所以`index`的值是-6。

[430a99940eb84cf4831a9a33a9ae33b5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/5bb5bab68a454e1eb1a0caa7c73542eb.png
[49cd6dfbc9b94a649d637d2ea3ed0ea7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/b6216100d87e4799839b9b35191a9f46.png