那些相见恨晚的Java工具类

Java工具类简介

  • 定义： 工具类是对String，Collection，IO等基础、常用功能的封装、扩展
  • 目的： 为开发者提供便利，减少重复代码
  • 优势： 更快、更好、更容易

CompletableFuture

  • 包： java.util.concurrent
  • 作用： 构建异步应用，实现异步调用
  • 优势： 简化异步编程的复杂性，提供了函数式编程的能力

CompletableFuture的使用

  1. 构造CompletableFuture对象

  • runAsync方法，不支持返回值

  • supplyAsync方法，支持返回值

  1. 返回计算结果

    • get方法，抛出具体的异常

    • join抛出具体的异常

    例子如下：

    CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
    for (int i = 0; i < 5000; i ++) {
        System.out.println("future1: " + i);
    }
});

CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
    for (int i = 0; i < 5000; i ++) {
        System.out.println("future2: " + i);
    }
});

CompletableFuture<Void> future3 = CompletableFuture.runAsync(() -> {
    for (int i = 0; i < 5000; i ++) {
        System.out.println("future3: " + i);
    }
});

try {
    future1.get();
    future2.get();
    future3.get();
}  catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

    输出如下：


  1. 上一阶段的处理完成后的下一阶段处理

    • thenApply方法，接收上一阶段的处理结果，处理后返回

      CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "hello")
    .thenApply(str -> str + " world！");
try {
    System.out.println(future.get());
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

      输出：

 hello world！

  • thenAccept方法，接收上一阶段的处理结果，处理后无返回

    CompletableFuture.supplyAsync(() -> "hello").thenAccept(System.out::println);

    输出:

    hello

  • thenRun方法，不接收上一阶段处理结果，只进行后续操作

    CompletableFuture.supplyAsync(() -> "hello").thenRun(() -> System.out.println("then run"));

    输出：

    then run

  1. 计算完成后的结果处理或抛出异常的处理

    • whenComplete方法

      CompletableFuture.supplyAsync(() -> "hello")
    .whenComplete((s, throwable) -> System.out.println(s));

      
输出：
  
  hello

Stream

  • 包：java.util.stream

  • 作用：集合数据处理

stream() − 为集合创建串行流。

parallelStream() − 为集合创建并行流。

  • 优势： 写出高效率、干净、简洁的代码

    遍历一个数组统计1的数目的两种方式对比如下：

    // 构造数组
List<Integer> numbers = Stream.of(1,2,3,5,1,2,1,1,5).collect(Collectors.toList());

// 遍历
int count = 0;
for (Integer num : numbers) {
  if (num == 1) {
      count ++;
  }
}
System.out.println(count);

// stream
long count1 = numbers.stream().filter(num -> num == 1).count();
System.out.println(count1);

Stream的特点

  • stream不会存储元素,遍历完一次就等于消费完了；
  • stream只会操作数据,不会改变数据；
  • stream采用的是内部迭代,访问者模式(Visitor)实现；
  • stream中间操作都会返回流对象本身,多个操作串联成一个管道,流式风格,都是懒加载的,只有用到结果的时候才会去执行

Stream的操作

Stream和集合的相互转化

  • stream -> 集合 (.collect)

  • 集合 -> stream (.stream或.parallelStream)

    // 生成stream
Stream<Integer> stream = Stream.of(1,2,3,5,1,2,1,1,5);

// stream -> 集合
List<Integer> numbers = stream.collect(Collectors.toList());

// 集合 -> stream
Stream<Integer> streamFromList = numbers.stream();
Stream<Integer> parallelStreamFromList = numbers.parallelStream();
中间的操作(对流的操作)

  • filter(Predicate p)，在流中筛选一些符合要求的元素

  • distinct()，在流中利用hashCode和equals方法去除相同的元素

  • limit(long maxSize)，在流中数据达到最大值时截断流

    List<Integer> numbers = Stream.of(1,2,3,5,1,2,1,1,5).collect(Collectors.toList());
numbers = numbers.stream().filter(num -> num <= 4)
    .distinct().limit(3).collect(Collectors.toList());
System.out.println(numbers);

    输出：

    [1, 2, 3]

  • skip(long n)，丢弃掉流中的前n个元素

  • map(Function function)，接受一个函数入参,用在每个元素上,并将其结果映射成一个新的元素


  • flatMap(Function function)，接受一个函数入参,该函数会用在每个元素上,并将流中每个元素换到另一个流中.然后将所有的流连在一起.


  • sorted()方法，按照自然规则排序

  • sorted(Comparator comparator)方法，按照给定的规则排序

    List<Integer> numbers = Stream.of(1,2,3,5,1,2,1,1,5).collect(Collectors.toList());
// skip
List<Integer> numbersSkipped = numbers.stream().skip(3).collect(Collectors.toList());
// 打印出的结果为: [5, 1, 2, 1, 1, 5]
System.out.println(numbersSkipped);

// map
List<Integer> numbersMapped = numbers.stream().map(i -> i + 1).collect(Collectors.toList());
// 打印出的结果为: [2, 3, 4, 6, 2, 3, 2, 2, 6]
System.out.println(numbersMapped);

// flatMap
List<String> strings = Stream.of("A-A-A", "B-B-B").collect(Collectors.toList());
List<String> stringsFlatMapped = strings.stream()
    .flatMap(i -> Arrays.stream(i.split("-"))).collect(Collectors.toList());
// 打印出的结果为: [A, A, A, B, B, B]
System.out.println(stringsFlatMapped);

// sorted
List<Integer> numbersSorted = numbers.stream().sorted().collect(Collectors.toList());
// 打印出的结果为: [1, 1, 1, 1, 2, 2, 3, 5, 5]
System.out.println(numbersSorted);

// sorted(Comparator comparator)
numbersSorted = numbers.stream()
    .sorted(Comparator.comparing(Integer::intValue).reversed()).collect(Collectors.toList());
// 打印出的结果为: [5, 5, 3, 2, 2, 1, 1, 1, 1]
System.out.println(numbersSorted);
终止操作(操作后获得结果)

  • count()，返回该流存在的元素个数

  • findFirst()，返回该流中第一个元素，返回值为Optional类型

  • findAny()，返回流中任意一个元素，返回值为Optional类型

  • allMatch(Predicate predicate)，返回流中所有的元素是否满足Predicate条件

  • anyMatch(Predicate predicate)，是否有

  • noneMatch(Predicate predicate)，是否都不满足

  • max(Comparator comparator)，返回流中Comparator比较后的最大值

  • min(Comparator comparator)，返回流中Comparator比较后的最小值

  • forEach(Consumer consumer)，对流中所有的元素进行迭代操作(内部迭代),并行执行

  • forEachOrdered(Consumer consumer),对流中所有的元素进行迭代操作(内部迭代),顺序执行

    List<Integer> numbers = Stream.of(1,2,3,5,1,2,1,1,5).collect(Collectors.toList());
// 打印出的结果为: 9
System.out.println(numbers.stream().count());

Optional<Integer> firstTwo = numbers.stream().filter(i -> i == 2).findFirst();
// 打印出的结果为: 2
firstTwo.ifPresent(System.out::println);

Optional<Integer> anyOne = numbers.stream().filter(i -> i == 1).findAny();
// 打印出的结果为: 1
anyOne.ifPresent(System.out::println);

// 打印出的结果为: false
System.out.println(numbers.stream().allMatch(i -> i > 4));

// 打印出的结果为: true
System.out.println(numbers.stream().anyMatch(i -> i > 4));

// 打印出的结果为: false
System.out.println(numbers.stream().noneMatch(i -> i > 4));

Optional<Integer> max = numbers.stream().max(Comparator.naturalOrder());
// 打印出的结果为: 5
max.ifPresent(System.out::println);

Optional<Integer> min = numbers.stream().min(Comparator.naturalOrder());
// 打印出的结果为: 1
min.ifPresent(System.out::println);

// 打印出的结果为: 123512115
numbers.forEach(System.out::print);

// 打印出的结果为: 234623226
numbers.stream().forEachOrdered(i -> System.out.print(i + 1));
归约将集合中的所有元素经过指定运算(加减乘除等),折叠成一个元素输出)

  • reduce(T identity, BinaryOperator accumulator)，返回一个T类型的值.第一个值为初始值.

  • reduce(BinaryOperator accumulator)，返回一个Optional类型的值.

    List<Integer> numbers = Stream.of(1,2,3,5,1,2,1,1,5).collect(Collectors.toList());
Integer multi = numbers.stream().reduce(2, (i1, i2) -> i1 * i2);
// 打印出的结果为: 600 
System.out.println(multi);

Optional<Integer> multi1 = numbers.stream().reduce((i1, i2) -> i1 * i2);
// 打印出的结果为: 300
multi1.ifPresent(System.out::println);

Optional

  • 包：java.util.Optional

  • 作用：是个可以为null的容器对象。它可以保存类型T的值，或者仅仅保存null

  • 优势：很好的解决空指针异常

    类声明

    以下是一个java.util.Optional<T>类的声明:

    public final class Optional<T>
extends Object

Optional操作

  • empty()，构造一个空Optional实例

  • get(),如果在Optional中包含这个值，返回值，否则抛出NoSuchElementException异常

  • ofPresent(Consumer consumer)，如果值存在则使用该值调用consumer , 否则不做任何事情

  • ofNullable(T value)，如果为非空，返回Optional描述的指定值

  • orElse(T other),如果存在该值，返回值，否则返回other

    public class OptionalTest {
    public static void main(String[] args) {
        OptionalTest optionalTest = new OptionalTest();
        Integer value1 = null;
        Integer value2 = 10;

        // Optional.ofNullable - 允许传递为 null 参数
        Optional<Integer> a = Optional.ofNullable(value1);

        // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
        Optional<Integer> b = Optional.of(value2);
        
        System.out.println(optionalTest.sum(a,b));
    }

    public Integer sum(Optional<Integer> a, Optional<Integer> b) {
        // Optional.isPresent - 判断值是否存在
        System.out.println("第一个参数值存在: " + a.isPresent());
        System.out.println("第二个参数值存在: " + b.isPresent());

        // Optional.orElse - 如果值存在，返回它，否则返回默认值
        Integer value1 = a.orElse(0);

        //Optional.get - 获取值，值需要存在
        Integer value2 = b.get();
        return value1 + value2;
    }
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 214,904评论 6赞 497
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 91,581评论 3赞 389
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 160,527评论 0赞 350
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 57,463评论 1赞 288
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 66,546评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,572评论 1赞 293
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,582评论 3赞 414
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,330评论 0赞 270
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,776评论 1赞 307
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,087评论 2赞 330
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,257评论 1赞 344
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,923评论 5赞 338
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,571评论 3赞 322
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,192评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,436评论 1赞 268
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,145评论 2赞 366
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,127评论 2赞 352