专栏首页丑胖侠Java数组,这一篇文章就真够了

Java数组,这一篇文章就真够了

虽然随着Java版本的演变,数组的分量在慢慢减弱,日常使用时大多使用List进行替代。但ArrayList底层依旧采用数组来进行实现,而数组依旧有很多应用的场景。在使用数组的过程中,你是否汇总过数组的特性及功能,并停下来思考几个为什么呢?如果没有,本篇文章将带领大家从头梳理一下数组,一定会为你带来一些未曾发掘的特性和功能。

何谓数组

学习数组,我们最先要知道的就是它是什么,能做什么?

数组,就是相同类型的对象或基本类型数据的集合。也可以理解为把有限个类型相同的元素按一定顺序排列的集合,然后用一个名字命名,用编号区分具体的元素。而这个名字称为数组名,编号称为下标。

数组在内存中是连续存储的,所以索引速度是非常的快,数组的赋值与修改元素也很简单。但是数组也有不足的地方,那就是如果想在两个相邻元素之间插入新的元素会非常麻烦。

另外,数组声明的时候必须指定数组的长度,而数组的长度是不可变的。在此,数组长度过长会造成内存浪费,长度过短则会造成溢出。

数组的应用场景

上面提到了数组的那么多缺点,但我们知道“存在即合理”,下面看看哪些场景适合数组的使用。

1、数据比较少,能够确定长度;存取或修改操作较多,插入和删除较少的情况。

2、使用(遍历)时,经常需要按照序号来进行访问数据元素或做运算的情况。

3、对性能要求较高时,数组是首选。

也正是由于性能较高,所以我们在阅读源码时经常会看到数组的身影。特别是针对基础类型进行操作,效率提升甚至可以达到基于List等集合性能的10倍。

以下面一段遍历数组和List求和的场景来做对比。

// 对数组求和
public static int sum(int[] datas) {
	int sum = 0;
	for (int data : datas) {
		sum += data;
	}
	return sum;
}

// 对List求和
public static int sum(List<Integer> datas) {
	int sum = 0;
	for (Integer data : datas) {
		// 拆箱操作
		sum += data;
	}
	return sum;
}

在上述两个方法中,影响性能的最大地方便是List中的Integer对象的拆箱和装箱操作,特别是数据量比较大的时候。我们都知道基础类型是在栈内存中操作的,而对象是在堆内存中操作的。栈内存的特点是速度快、容量小,堆内存的特点是速度慢、容量大,因此从性能上来讲,基本类型的处理占优势。

有同学可能会说了有整型缓存池的存在。但整型缓存池容纳的是﹣128到127之间的Integer对象,超过这个范围便需要创建Integer对象了,而超过这个容纳范围基本上是大概率事件。

数据变量定义

下面来说说数组的名称定义,我们可以通过两种形式来进行声明数组:

int[] a;

int b[];

其中后一种格式符合C和C++程序员的习惯,如果你是Java开发人员,建议统一使用前一种。为什么呢?因为前一种从语义上来说更合理,它表示“一个int型数组”。

拓展一下:如果你懂一些其他编程语言,比如C语言,你会看到类似如下的声明。

int A[10];

Java中却不能如此声明。思考一下为什么?

这个要回到Java的“引用”问题上。我们在上述代码中声明的只是数组的一个引用,JVM会为该引用分配存储空间。但是,这个引用并没有指向任何对象,也就是说没有给数组对象本身分配任何空间。只有在数组真正创建时才会分配空间。因此,编译器不允许在此指定数组的大小。

数组的创建与初始化

数组的创建与初始化有两种形式:

// 方式一的创建
int[] a = new int[5];
// 方式一的初始化
a[1] = 1;
a[2] = 2;
a[3] = 3;
a[4] = 4;

// 方式二(创建+初始化)
int[] b = {0, 1, 2, 3, 4};

第一种方式通过new关键字创建一个指定长度(为5)的数组,然后通过数组下标对内容进行逐一初始化。那么,如果不进行逐一初始化会怎样?默认会采用int类型的默认值,也就是0进行初始化。

第二种方式,创建与初始化融为一体,其实也采用了new关键字进行创建,只不过是编译器负责来做,更加方便一些。

拓展一下:我们可以通过方式二的形式进行数组的创建和初始化,那么为什么还提供了int[] a这种基于数组引用的声明呢?

这是因为在Java中,可以将一个数组的引用赋值给另外一个数组。比如,我们可以如下方式使用:

int[] c;
int[] b = {0, 1, 2, 3, 4};
c = b;

经过c=b的操作,数组c的引用同样指向了b。这里又会出现一个我们常见的面试题。看看下面代码打印的结果是什么:

public static void main(String[] args) {
	String[] strings = {"a","b","c"};
	String string = "abc";
	change(strings,string);
	System.out.println(strings[1]);
	System.out.println(string.charAt(1));
}

public static void change(String[] strings,String string){
	strings[1] = "e";
	string = "aec";
}

想好答案了吧?现在公布答案:第一行打印的是“e”,第二行打印的“b”。这与上面所说的数组的引用有密切关联,数组传递进入change方法的是引用,而String类型的参数传递的只是值的copy。

数组的存储结构

这里我们再以一张简单的图展示一下,数组在内存中存储的形式。

上图需注意的是数组使用的存储空间是连续的。其中创建的对象通常位于堆中,上图对堆中的数据存储进行了简化示意。

数组的长度

在很久之前,面试的时候还出现这样的面试题:如何获取数组的长度?

当然,我们知道该面试题考察的就是通过length属性获取数组长度与通过size()方法获取集合长度的区别。

所有的数组都有一个固定的成员,可以通过它来获取数组的长度,这便是length属性。在使用的过程中我们需要注意的是数组的下标是从0开始计算的。因此,我们在遍历或修改数组的时候,需要注意数组的下标最大值是length-1,否则,会出现数组越界的问题。

数组的处理

针对数组,Java标准类库里特意提供了Arrays类,我们可以通过该类提供的方法进行数组的处理。

数组的打印

可通过Arrays.toString()方法对数组的内容进行打印。下面通过示例我们来对比一下通过toString方法和直接打印的区别。

String[] strings = {"a","b","c"};
System.out.println(strings);
System.out.println(Arrays.toString(strings));

打印结果:

[Ljava.lang.String;@36baf30c
[a, e, c]

可以看到,如果直接打印则打印出来的是strings数组的引用,而并不是真实的内容。

数组的排序

可通过Arrays.sort()方法对数组进行排序,但对于数组中的元素有一定的要求,要实现Comparable接口。看下面的实例:

String[] sorts = {"c","b","a"};
Arrays.sort(sorts);
System.out.println(Arrays.toString(sorts));

打印结果:

[a, b, c]

很明显已经进行正常排序了。为什么String可以直接进行排序?那是因为String已经实现了Comparable接口。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {}

另外,对于数组的排序还有常见的:冒泡排序、快速排序、选择排序、插入排序、希尔(Shell)排序、堆排序等。面试过程中的排序往往也是基于数组来进行展开的。感兴趣的朋友可拿数组来练习一下排序的算法。

数组转集合

通过Arrays.asList()方法,可将数组转化为列表。

String[] sorts = {"程序","新","视界"};
List<String> list = Arrays.asList(sorts);
System.out.println(list);

打印结果:

[程序, 新, 视界]

关于asList的源码如下:

public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}

看到asList源码,你能想到什么?是不是发现该方法的参数为可变参数,并且支持数组作为参数传入。关于可变参数,下篇文章我们会详细讲一下,别忘记关注公众号“程序新视界”学习。

当然,这里也可以转化为Set集合,但需创建一个Set的实现类(这里用HashSet),将asList的结果作为参数传入:

Set<String> sets = new HashSet<>(Arrays.asList(sorts));

数组内容查找

可以通过Arrays.binarySearch()方法来对数据中的元素进行查找,顾名思义,这里是通过二分查找法进行查找的。

String[] sorts = {"c","a","b"};
Arrays.sort(sorts);
int index = Arrays.binarySearch(sorts,"b");
System.out.println(index);
System.out.println(sorts[index]);

打印结果:

1
b

结果中的"1"指的是字符串所在的下标值,通过下标可以获得对应位置的值。这里需要注意的是,既然是二分查找法,那么在查找之前必定需要进行排序,不然二分查找的意义便不存在了。

数组的拷贝

可以通过Arrays.copyOf()方法对数组进行复制,其中第一个参数是被复制数组,第二个参数为新数组的长度,返回的结果为新的数组。示例如下:

int[] sourceArray = {1, 3, 5, 7, 0};
int[] newArray = Arrays.copyOf(sourceArray, sourceArray.length);
System.out.println(Arrays.toString(newArray));

打印结果:

[1, 3, 5, 7, 0]

此时,需要思考一个问题Arrays.copyOf()复制的功能是一个什么层次的复制。也就说,如果修改新数组的值,是否会影响到原有数组。

先猜测一下,下面看示例代码:

int[] sourceArray = {1, 3, 5, 7, 0};
int[] newArray = Arrays.copyOf(sourceArray, sourceArray.length);
newArray[1] = 8;
System.out.println(Arrays.toString(newArray));
System.out.println(Arrays.toString(sourceArray));

打印结果:

[1, 8, 5, 7, 0]
[1, 3, 5, 7, 0]

结果能说明什么?说明Arrays.copyOf()的复制功能是创建一个全新的数组及数组元素吗?NO,NO,NO!

我们再来看另外一个示例,先创建一个User对象,源码如下:

public class User {

	private String userNo;

	public User(String userNo){
		this.userNo = userNo;
	}

	public String getUserNo() {
		return userNo;
	}

	public void setUserNo(String userNo) {
		this.userNo = userNo;
	}
}

然后创建数组进行复制操作,复制完成之后对新数组的数据进行修改。

User[] sourceArray = {new User("N1"), new User("N2"),new User("N3")};
User[] newArray = Arrays.copyOf(sourceArray, sourceArray.length);
newArray[1].setUserNo("N4");
System.out.println(newArray[1].getUserNo());
System.out.println(sourceArray[1].getUserNo());

打印结果如下:

N4
N4

我们在代码中只是修改了新数组中的User的属性,结果原有数组的值也同样被修改了。

上面的两个示例说明数组的copy操作只是一个浅拷贝。这与序列化的浅拷贝完全相同:基本类型是直接拷贝值,其他都是拷贝引用地址。

同样,数组和集合的clone也是如此,同样是浅拷贝,使用时需多加留意。

基于数组浅拷贝实现变长数组

关于List是如何实现变长的,大家可以参考List的源码进行学习。这里基于上面提到的Arrays.copyOf()方法的功能来实现动态变长。

实现原理很简单,就是基于Arrays.copyOf()方法的第二个参数来进行扩容。

相关方法如下:

public static <T> T[] expandCapacity(T[] datas, int newLen) {
	// 校验长度值,如果小于0,则为0
	newLen = Math.max(newLen, 0);
	// 生成一个新数组,并拷贝原值,指定新的数组长度
	return Arrays.copyOf(datas, newLen);
}

在上述方法中除了校验部分,核心机制便是利用了Arrays.copyOf()方法来实现一个可变长的数组。

小结

关于数组部分,我们就讲这么多,其实数组还有多维数组以及通过Arrays.asList()方法转换为List之后基于List的更多操作,在这里我们就不进行拓展了。感兴趣的朋友可自行实践。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • solidity定长数组和动态数组

    其中第二种情况未声明数组内容时,可通过直接通过push向数组中添加值,或初始化一个数组然后再赋值。

    用户1161110
  • 以太坊实战之《如何正确处理nonce》

    问题概述 以太坊系列(ETH&ETC)在发送交易有三个对应的RPC接口,分别是eth_sendTransaction、eth_sendRawTransactio...

    用户1161110
  • SOLIDITY REMIX方法传递数组参数

    版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。

    用户1161110
  • Python-NumPy基础

    前言 这两天读完《利用Python进行数据分析》 这本书的第4章:NumPy 基础:数组和矢量计算 后,在进行下一步阅读高级应用前,先整理本章内容,做个笔记备查...

    Alan Lee
  • 数据结构与算法学习笔记之 从0编号的数组

    数组看似简单,但掌握精髓的却没有多少;他既是编程语言中的数据类型,又是最基础的数据结构;

    Dawnzhang
  • Java 多维数组遍历

    数组是Java中的一种容器对象,它拥有多个单一类型的值。当数组被创建的时候数组长度就已经确定了。在创建之后,其长度是固定的。下面是一个长度为10的数组:

    哲洛不闹
  • 探究JS V8引擎下的“数组”底层实现

    JavaScript 中的数组有很多特性:存放不同类型元素、数组长度可变等等,这与数据结构中定义的数组结构或者C++、Java等语言中的数组不太一样,那么JS数...

    2020labs小助手
  • 13 个 JS 数组精简技巧,一起来看看。

    数组是 JS 最常见的一种数据结构,咱们在开发中也经常用到,在这篇文章中,提供一些小技巧,帮助咱们提高开发效率。

    前端小智@大迁世界
  • 数组是如何随机访问元素?数组下标为什么从0开始,而不是1?

    数组(Array)是一种线性表数据结构,它用一组连续的内存空间,来存储相同类型的数据。

    搜云库技术团队
  • Java数组

    数组对于每一门编程语言来说都是重要的数据结构之一,当然不同语言对数组的实现及处理也不尽相同。

    用户5224393

扫码关注云+社区

领取腾讯云代金券