java数组详解

已于 2024-06-28 05:30:25 修改
阅读量740 收藏 35
点赞数 19
分类专栏： JavaSE 文章标签： 开发语言 java intellij-idea
于 2024-06-02 21:27:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C384136844/article/details/139382511
版权

数组概述

数组（Array）是有序的元素序列。在程序设计当中，为了处理数据方便，把具有相同类型的若干元素按有序的形式组织起来的一种形式。这些 有序排列的同类型数据元素的集合称为数组。

作用：数组是一种数据结构，用来存储相同类型值的集合。

在java语言当中数组有以下几个特点：

1：java中的数组存储的每个元素类型相同。

2：java当中的数组长度一旦确定不可改变。

3：java当中的数组都有length属性，可以获取数组中元素的个数。

4：java中的数组对象存储在堆内存当中。

5：java当中每个元素占用空间大小相同，并且数组中每个元素的空间地址连续。

6:java当中数组元素下标从0开始，以1递增，可以通过下标访问数组中的元素。

数组的创建

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

T：表示数组中存放元素的类型

T[]：表示数组的类型

N：表示数组的长度 

请看如下代码：

public class ArrayTest02 {
    public static void main(String[] args) {
        int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组
        double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组
        String[] array3 = new String[3]; // 创建一个可以容纳3个字符串元素的数组
    }
}

数组的初始化 

 数组的初始化：数组的初始化主要分为动态初始化以及静态初始化。

动态初始化：在创建数组时，直接指定数组中元素的个数 格式：T[]数组名 = new T[N]

例如：

 静态初始化：在创建数组时不直接指定数据元素个数。

而直接将具体的数据内容进行指定 语法格式： T[] 数组名称 = {data1, data2, data3, ..., datan}; 

注意：静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度。 静态初始化时, { }中数据类型必须与[]前数据类型一致。 静态初始化可以简写，省去后面的new T[]。 

例如：

 静态和动态初始化可以分为两步，但是省略格式不可以， 如果省略就会编译不通过。

如果省略将是这种效果：

 

如果没有对数组进行初始化，数组中元素有其默认值 如果数组中存储元素类型为基类类型，默认值为基类类型对应的默认值，看如下代码：

public class ArrayTest02 {

    public static void main(String[] args) {
        short[] array1 = new short[2];
        System.out.println(Arrays.toString(array1));
        
        byte[] array2 = new byte[1];
        System.out.println(Arrays.toString(array2));
        
        int[] array3 = new int[5];
        System.out.println(Arrays.toString(array3));
        
        long[] array4 = new long[4];
        System.out.println(Arrays.toString(array4));
        
        float[] array5 = new float[5];
        System.out.println(Arrays.toString(array5));
        
        double[] array6 = new double[10];
        System.out.println(Arrays.toString(array6));
        
        boolean[] array7 = new boolean[1];
        System.out.println(Arrays.toString(array7));

    }
}

如果数组中存储元素类型为引用类型，默认值为null。

请看如下代码：

public class ArrayTest02 {
    public static void main(String[] args) {
        int[] array = null;
        System.out.println(array);//null
    }
}

数组的内存布局图

请看如下代码：

package array;

import java.util.Arrays;

public class ArrayTest02 {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4};
        System.out.println(Arrays.toString(array));//1234
        
        int[] array2 = array;
        array2[0] = 100;
        System.out.println(Arrays.toString(array));//100 2 3 4
        System.out.println(Arrays.toString(array2));//100 2 3 4
    }
}

简图分析：

注意：一个引用不能同时指向多个对象，但是多个引用可以同时指向同一个对象。 

请看如下代码：


public class ArrayTest02 {

    public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4};
        int[] array2 = {4, 5, 6, 7, 8};
        array1 = array2;
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
    }
}

简图分析： 

数组的使用

1：数组中元素访问

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

int[]array = {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]);

// 也可以通过[]对数组中的元素进行修改
array[0] = 100;
System.out.println(array[0]);

【注意事项】 1. 数组是一段连续的内存空间，因此支通过下标访问快速访问持随机访问，即数组中任意位置的元素  2.下标从0开始，介于[ 0, array.length - 1 ] , length为元素个数，不能越界，否则会报出 java.lang.ArrayIndexOutOfBoundsException 异常 , 需注意下标越界 .

​
public class ArrayTest02 {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4};
        System.out.println(array.length);
        System.out.println(array[4]);
    }
}

​

2：数组的遍历
​//：暴力输出：如果数组中元素较多的时候，显然这种方法就不能适应我们的需要了

int[]array = {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]);

........
​
​
//for循环遍历：
int[]array = new int[]{10, 20, 30, 40, 50};
for(int i = 0; i < array.length; i++){
System.out.println(array[i]);
}


// foreach遍历：
int[] array = {1, 2, 3};
for (int x : array) {
System.out.println(x);
}
​

3： 基本类型变量与引用类型变量的区别
基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值； 而引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址。

请看如下代码：

​public static void func() {
int a = 10;
int b = 20;
int[] arr = new int[]{1,2,3};
}
​

 在上述代码中，a、b、arr，都是函数内部的变量，因此其空间都在main方法对应的栈帧中分配。 a、b是内置类型的变量，因此其空间中保存的就是给该变量初始化的值。 array是数组类型的引用变量，其内部保存的内容可以简单理解成是数组在堆空间中的首地址。

 从上图可以看到，引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。通过该地址，引用变量便可以去操作对象。

public class ArrayTest02 {
    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]);
        }
    }

    public static void main(String[] args) {
        func();
    }
}

注意：null 在 Java 中表示 "空引用" , 也就是一个不指向任何对象的引用.  都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操 作. 一旦尝试读写, 就会抛出 NullPointerException. 注意: Java 中并没有约定 null 和 0 号地址的内存有任何关联。

请看如下代码：

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

. 数组的应用场景

1： 保存数据
public class ArrayTest02 {
    public static void main(String[] args) {
        int[] array = {1, 2, 3};
        for (int i = 0; i < array.length; ++i) {
            System.out.print(array[i] + " ");
        }
    }
}
2： 作为函数的参数

1. 参数传基本数据类型

public class ArrayTest02 {
    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

发现在func方法中修改形参 x 的值, 不影响实参的 num 值。

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

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

发现在func方法内部修改数组的内容, 方法外部的数组内容也发生改变.
因为数组是引用类型，按照引用类型来进行传递，是可以修改其中存放的内容的。但不意味参数是数组类型就可以发生值的改变。例如：

package array;

import java.util.Arrays;

public class ArrayTest02 {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4};
        func1(array);
        System.out.println(Arrays.toString(array));//1 2 3 4
        func2(array);
        System.out.println(Arrays.toString(array));//100 2 3 4
    }

    public static void func2(int[] array) {
        array[0] = 100;
    }

    public static void func1(int[] array) {
        array = new int[10];
    }
}

结论：传引用可以修改数据，但不意味所有的传引用 都可以修改数据，关键要看这个引用的指向有没有发生改变。 

总结: 所谓的 "引用" 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实
只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大). 

3：作为函数的返回值

比如：获取斐波那契数列的前N项

public class ArrayTest02 {
    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;
    }

    public static void main(String[] args) {
        int[] array = fib(10);
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

数组转字符串：(java.util.Arrays)

import java.util.Arrays
int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr);
// 执行结果
[1, 2, 3, 4, 5, 6]

 数组拷贝

自己实现数组的拷贝：看如下代码

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

        //自己实现数组的拷贝
        int[] array1 = {1, 2, 3, 4, 5};
        int[] array2 = new int[array1.length];
        for (int i = 0; i < array1.length; i++) {
            array2[i] = array1[i];
        }
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
    }
}

JAVA API 提供的拷贝数组的方法 

public class ArrayTest05 {
    public static void main(String[] args) {
        //数组的拷贝
        int[] array1 = {1,2,3,4,5};
        int[] array2 = Arrays.copyOf(array1,array1.length);
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
    }
}
public class ArrayTest06 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] copy = new int[array.length];
        
        System.arraycopy(array,0,copy,0,array.length);
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(copy));
    }
}


public class ArrayTest07 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] array2 = Arrays.copyOfRange(array,0,3);//左闭右开
        System.out.println(Arrays.toString(array2));
        System.out.println(Arrays.toString(array));

        int[] arr1 = {10,20,30,40,50};
        int[] arr2 = arr1.clone();
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr2));
    }
}

二分查找

//自己实现二分查找：
public class ArrayTest10 {
    public static int binarySearch(int[] arr, int key) {

        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (key < arr[mid]) {
                // 去左侧区间找
                right = mid - 1;
            } else if (key > arr[mid]) {
                // 去右侧区间找
                left = mid + 1;
            } else {
                // 相等, 说明找到了
                return mid;
            }
        }
        // 循环结束, 说明没找到
        return 1;
    }

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

数组逆置

import java.util.Arrays;

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

        int[] arr = {1, 2, 3, 4};
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }

    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++;
            right--;
        }
    }
}

qq_384136844
关注
专栏目录
Java 数组
Naion的博客
03-22 2万+
本文章介绍了Java中数组的一些概念和一些方法的使用。
Java数组详解1：数组的定义、创建及使用
sunyusong666的博客
03-02 1456
Java数组详解
学习java Day10
Angeefly的博客
07-05 165
①数组 定义 数组是相同类型数据的集合。 数组描述相同类型的若干个数据，按一定的先后次序排列组合而成。 每个数据称作一个数组元素，每个数据元素可以通过一个下标来访问。 声明 首先必须声明数组变量，才能在程序中使用数组。 声明数组变量语法如下： dataType[] arrayRefVar; //首选方法 或 dataType arrayRefVar[]; //效果相同，但不是首选方法 Java语言使用new操作符来创建数组，语法如下： dataType[] arrayRefVar
【Java】数组——这一篇就够了
Dong_duan的博客
03-14 615
数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。
java 数组
Claroja
03-14 2138
定义数组 float[] arr = new float[10]; // arr可以装10个float数据 int[] arr2 = new int[8]; // arr2可以装8个int数据 String[] arr3 = new String[7]; //arr3 可以装7个String数据 添加数据 arr[0] = 1.8; arr2[2]=5; arr3[1] = ...
java 数组
无成的博客
08-12 373
数组 数组与继承 父类类型数组引用 子类类型数组 √ 将父类类型存入 实际上是子类类型的数组 ——&gt; 运行时产生 java.lang.ArrayStoreException 异常 数组元素的类型称为该数字的基类型 数组的长度为固定属性 length java支持引用类型和基类型的数组 通过索引操作符[ ]来访问元素 一维数组 ...
Java 数组详解及示例代码
09-01
这些是Java数组常见的操作方法。在实际开发中，了解和掌握这些方法能够帮助我们更高效地处理数组数据。除此之外，数组还有许多其他操作，如排序、复制、填充等，都可以通过内置函数或第三方库实现。对于复杂的数据...
Java数组详解（Java基础）
12-21
Java数组是编程中的一种基础数据结构，用于存储同类型的多个数据。数组的使用在Java编程中至关重要，尤其对于初学者来说，理解其基本概念和操作是掌握编程技能的基础。 一、数组的概念 数组是一种特殊的变量，它能...
java数组
cpf1985的专栏
08-20 99
[code="java"] --java里面的数组不能这样写int a[5]; *为什么呢？如果这样写的话一般情况下会将五个内存空间分配到栈上，但是java的数据是放在堆上的，栈上只能分配一个指针地址而已 *数组的神明有两种方式int[] a;或者int a[]; --数据的问题 方法中int[] a=new int[5];由于使用了new关键字，那么数组中的值（堆中已经分配内...
14 数组
qq_53537301的博客
03-21 976
数组 数组的定义 数组是相同类型数据的有序集合 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成 其中,每一个数据称作一个数组元素每个数组元素可以通过一个下标来访问它们 数组声明创建 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法: dataType[] arrayRefVar; // 首选的方法 或 dataType arrayRefVar[]; // 效果相同，但不是首选方法 Java语言使用new操作符来创建数组，语法如下: dataType[] array
Java数组（这一篇就够了）（超详细）
最新发布
m0_73158088的博客
03-21 1万+
文字定义：数组是一种数据结构，用于存储多个相同类型的数据。java中 "类型[ ]" 即数组，并且索引下标从0开始。
8.Java数组
W_chuanqi的博客
08-04 3443
在Java中，声明数组的方式有两种。数据类型 [ ] 数组名 = null;数据类型 [ ] 数组名;数组名 = new 数据类型 [ 长度 ];int [ ] x;// 声明一个int[]类型的变量 x = new int [ 100 ];// 为数组x分配100个元素空间上述语句就相当于在内存中定义了100个int类型的变量，第一个变量的名称为x[0]，第二个变量的名称为x[1]，以此类推，第100个变量的名称为x[99]，这些变量的初始值都是0。...
Java代码之数组
weixin_46181329的博客
03-23 187
数组 /* * 数组：是具有相同数据类型的集合。 * * 数组的定义 * 数据类型 [] 数组名 = 数组值 ; * * 数组可以没有元素。 * 数组是通过下标访问的数组里面的元素，数组[下标] 。下标从0开始 * 数组的长度通过length属性访问的。数组长度是固定不变的。 数组 .length * 数组是引用数据类型 。 * 数组在内存中是一段连续的内...
java数组代码
08-28
java数组代码
Java的数组代码
xuanyuanchun的博客
10-31 552
Java的数组 1.1-1.2 数据类型[] 数组名 数据类型 数组名[] 数据类型[] 数组名=new 数据类型[数组长度] Int[] arr={1,2,3,4}; Int[] arr =new int[10]; 数组长度 Int[] a={1,2,3,4,5,6,7,8,9,10}; Length表示数组长度 如a.length 2.1 数组：Array package com.imooc.flow1; public class ArrayDemo{ public static void main (
java中数组6_6. JAVA数组
weixin_35748508的博客
02-24 133
JAVA数组1、数组概述数组的定义数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个数组元素，每一个数组元素可以通过一个下标来访问它们。2、数组声明创建首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：dataType[] arrayRefVar; //首选的方法或dataType arrayRefVar[...
Java之数组的定义
热门推荐
qq_53190275的博客
11-09 2万+
数组
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值