性能文章>5个方法教你优雅的优化老代码>

5个方法教你优雅的优化老代码转载

2月前
182202

导语

虽然 Stream 在 Java8 中就已经被引入,但是大多数人却没有去使用这个十分有用的特性,本文就通过介绍几个通过使用 Stream 让代码更简洁、可读,来让你了解 Stream 的方便之处。

 

正文

技巧

| 数组转集合

相信经常刷 LeetCode 的小伙伴,偶尔会遇到需要将 List 与基本类型数组进行互转的情况,然后就需要写像下面这样的代码:

// 将 List 元素存储到数组中
List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
int[] arr = new int[list.size()];
Integer[] temp = list.toArray(new Integer[0]);
for (int i = 0; i < temp.length; i++) {
 arr[i] = temp[i];
}

// 将数组元素 存储到 List 中
int[] arr = {1, 2, 3, 4, 5};
List<Integer> list = new ArrayList<>();
for (int val : arr) {
 list.add(val);
}

 

以上两个转换虽然写着还不算麻烦,但是每次都需要写一个循环,尤其在数组转 List 的时候还需要使用一个临时数组,都会让人看着很不舒服,但是如果使用了 Stream 就会大不一样。

用 Stream 实现了相同功能的代码如下:

// 将 List 元素存储到数组中
List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
int[] arr = list.stream().mapToInt(Integer::intValue).toArray();

// 将数组元素 存储到 List 中
int[] arr = {1, 2, 3, 4, 5};
List<Integer> list = IntStream.of(arr).boxed().collect(Collectors.toList());

 

可以发现通过使用 Stream,我们能够在写代码的时候更加连贯,代码也更加可靠易维护,注意力也可以放在业务功能上,相信各位就算对 lambda 语法并不是太熟悉,在阅读上面代码的时候,也很容易能够看懂。

 

| 统计数组元素中的个数

假设我们现在需要统计并输出一个有重复元素的数组中每个元素及对应元素出现的个数,相信各位都能够想到,我们使用一个 Map 就很容易解决这个问题。

代码如下:

String[] arr = {"a", "c", "a", "b", "d", "c"};
Map<String, Integer> map = new HashMap<>();
for (String s : arr) {
    if (map.containsKey(s)) {
        map.put(s, map.get(s) + 1);
    } else {
        map.put(s, 1);
    }
}
map.forEach((key, value) -> System.out.println(key + " : " + value));

 

如果对 Map 中的 API 更加熟悉的小伙伴,可能会写出下面这个更加简洁的代码:

String[] arr = {"a", "c", "a", "b", "d", "c"};
Map<String, Integer> map = new HashMap<>();
for (String s : arr) {
    map.put(s, map.getOrDefault(s, 0) + 1);
}
map.forEach((key, value) -> System.out.println(key + " : " + value));

 

但是,如果使用 Stream,我们还能写出更加简洁的代码,同样不需要写烦人的循环了,而且只需两行代码即可(为了提高可读性,进行了换行):

String[] arr = {"a", "c", "a", "b", "d", "c"};
Stream.of(arr)
      .collect(Collectors.toMap(k -> k, k -> 1, Integer::sum))
      .forEach((k, v) -> System.out.println(k + " : " + v));

 

注意:在上面的代码中,Collectors.toMap(k -> k, k -> 1, Integer::sum) 这一部分可能不好理解。

对于这里面的三个参数,第一个参数代表将 arr 中的每一个元素作为 Map 中的 key,第二个参数代表每一个 key 所对应的 value,在这里每一个元素都对应个数 1。

第三个参数代表,如果存在相同的 key,该如何进行合并,这里通过使用 Integer::sum,代表将具有相同 key 的元素进行合并时,其 value 进行相加,这样便实现了每个元素个数的统计。

 

| 基本数据类型的数组自定义排序

有时我们会遇到对基本数据类型的数组进行自定义排序的情况,不同于包装类型的数组和集合可以直接使用比较器。

我们只能通过将基本数组类型的数组转为包装类型或者存储在集合中,在排序完成后再转为基本类型的数组,再者,我们只能通过手写排序算法,修改排序算法中的比较进行实现。

不管是哪种方法,我们都没办法将精力放在逻辑功能上,必须写一些额外的代码,甚至是修改底层逻辑,就像下面的代码一样(实现数组逆序):

int[] arr = {1, 5, 9, 7, 2, 3, 7, -1, 0, 3};
// 将数组转为包装类型再进行自定义排序
Integer[] temp = new Integer[arr.length];
for (int i = 0; i < arr.length; i++) {
    temp[i] = arr[i];
}
Arrays.sort(temp, Comparator.reverseOrder());
for (int i = 0; i < temp.length; i++) {
    arr[i] = temp[i];
}

// 将数组转为集合类型再进行自定义排序
List<Integer> list = new ArrayList<>();
for (int val : arr) {
    list.add(val);
}
list.sort(Collections.reverseOrder());
for (int i = 0; i < list.size(); i++) {
    arr[i] = list.get(i);
}

// 通过手写排序算法修改比较规则实现
// 为了让代码更加简洁,使用了最暴力且没有优化的冒泡排序
int[] arr = {1, 5, 9, 7, 2, 3, 7, -1, 0, 3};
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 temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}

 

可以发现以上几种方法,我们都需要写很多代码,无法将注意力集中在设计自定义排序这个问题上,但是通过使用 Stream,我们就可以写出下面这样简洁的代码。

如果愿意的话,你也可以把一系列的链式操作写在一行上,但为了代码的可读性,不建议那么做:

int[] arr = {1, 5, 9, 7, 2, 3, 7, -1, 0, 3};
arr = IntStream.of(arr)
               .boxed()
               .sorted(Comparator.reverseOrder())
               .mapToInt(Integer::intValue)
               .toArray();

 

注意:在这里其实为了实现数组的逆序,我们只需要调用 Arrays 的 sort 方法,然后再进行数组元素的反转即可,不过因为是为了讲解自定义排序,大多数情况下不会是数组逆序这么简单,所以我就写了更加通用一些的代码。

| 统计数组中前 k 个个高频元素

在最后,我们通过一道题来进行实战以便更好的体验 Stream 的强大之处,当然我们在练习该题的时候,更需要从算法的角度去考虑该题的解法。

不过在本文,我们主要为了讲解 Stream 的使用,所以就不去考虑算法的东西了,而如果使用 Stream,我们就可以写出下面这样简单易懂的代码:

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        return Arrays.stream(nums)
                     .boxed()
                     .collect(Collectors.toMap(e -> e, e -> 1, Integer::sum))
                     .entrySet()
                     .stream()
                     .sorted((m1, m2) -> m2.getValue() - m1.getValue())
                     .limit(k)
                     .mapToInt(Map.Entry::getKey)
                     .toArray();
    }
}

 

总结

本文介绍了几个简单、实用的 Stream 使用技巧,当然 Stream 的应用远不止此,希望通过本文,能够激发起你学习 Stream 的兴趣,本文若有错误之处,也欢迎你的指正。

分类:标签:
请先登录,感受更多精彩内容
快去登录吧,你将获得
  • 浏览更多精彩评论
  • 和开发者讨论交流,共同进步

为你推荐

从一起GC血案谈到反射原理
前言 首先回答一下提问者的问题。这主要是由于存在大量反射而产生的临时类加载器和 ASM 临时生成的类,这些类会被保留在 Metaspace,一旦 Metaspace 即将满的时候,就会触发 Fu
类初始化导致死锁
一张图简单描述死锁 如上图,Thread1 拿到了 object1,Thread2 拿到了 object2,但是现在 Thread1 需要拿到 object2 的锁才能继续往下,Thread2 又要拿到 object1 才能继续往下
在调试器里看LINUX内核态栈溢出
图灵最先发明了栈,但没有给它取名字。德国人鲍尔也“发明”了栈,取名叫酒窖。澳大利亚人汉布林也“发明”了栈,取名叫弹夹。1959年,戴克斯特拉在度假时想到了Stack这个名字,后来被广泛使用。
盘点:35 个 Java 代码优化魔鬼细节
代码优化 ,一个很重要的课题。可能有些人觉得没用,一些细小的地方有什么好修改的,改与不改对于代码的运行效率有什么影响呢?这个问题我是这么考虑的,就像大海里面的鲸鱼一样,它吃一条小虾米有用吗?没用,但是,吃的小虾米一多之后,鲸鱼就被喂饱了。
5个方法教你优雅的优化老代码
导语虽然 Stream 在 Java8 中就已经被引入,但是大多数人却没有去使用这个十分有用的特性,本文就通过介绍几个通过使用 Stream 让代码更简洁、可读,来让你了解 Stream 的方便之处。 正文技巧| 数组转集合相信经常刷 LeetCode 的小伙伴,偶尔会遇到需要
优化统计代码执行耗时这样做才足够优雅!
导语代码耗时统计在日常开发中算是一个十分常见的需求,特别是在需要找出代码性能瓶颈时。可能也是受限于 Java 的语言特性,总觉得代码写起来不够优雅,大量的耗时统计代码,干扰了业务逻辑。特别是开发功能的时候,有个感受就是刚刚开发完代码很清爽优雅,结果加了一大堆辅助代码后,整个代码就变得臃肿了,自己
编译器优化那些事儿(3):Lazy Code Motion
本文将介绍通过代码移动(插入)的方式消除冗余计算的一个典型方法。
干货!Java代码优化必知的30个小技巧!
大家好,我是苏三,又跟大家见面了。前言我之前写过两篇关于优化相关的问题:《聊聊sql优化的15个小技巧》和《聊聊接口性能优化的11个小技巧》,发表之后,在全网受到广大网友的好评。阅读量和点赞率都很高,说明了这类文章的价值。今天接着优化这个话题,我们一起聊聊Java中代码优化的30个小技巧,希望