开发中使用JDK8提升效率

for 循环

package org.example;


import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * JDK8的方法
 */
public class UnitTest {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "orange");
        System.out.println("普通循环");
        for (String str : list) {
            System.out.println(str);
        }
        // 标准的lambda表达式
        System.out.println("标准的lambda表达式");
        list.forEach(str -> {
            System.out.println(str);
        });
        System.out.println("jdk8的for循环");
        list.forEach(System.out::println);
    }
}

输出结果

filter过滤

package org.example;

import org.junit.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@SpringBootTest
public class DemoTest {
    @Test
    public void test1() {
        List<String> list = Arrays.asList("apple", "banana", "orange");
        List<String> list2 = list.stream().filter(x -> x.startsWith("a")).collect(Collectors.toList());
        list2.forEach(System.out::println);
    }
}

输出结果

map

使用map进行转换操作

package org.example;

import org.junit.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@SpringBootTest
public class DemoTest {
    @Test
    public void test1() {
        List<String> list = Arrays.asList("apple", "banana", "orange");
        List<Integer> list2 = list.stream().map(s -> {
            return s.length();
        }).collect(Collectors.toList());
        System.out.println(list2);
    }
}

输出结果

上述代码进行优化

package org.example;

import org.junit.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@SpringBootTest
public class DemoTest {
    @Test
    public void test1() {
        List<String> list = Arrays.asList("apple", "banana", "orange");
        List<Integer> list2 = list.stream().map(s -> s.length()).collect(Collectors.toList());
        System.out.println(list2);
    }
}

输出结果

reduce

使用reduce进行聚合操作

package org.example;

import org.junit.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Arrays;
import java.util.List;

@SpringBootTest
public class DemoTest {
    @Test
    public void test1() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        // 传统的方式计算集合中元素的和
        int sum = 0;
        for (Integer i : list) {
            sum += i;
        }
        System.out.println("sum=" + sum);

        /**
         * 使用jdk8中的reduce方法计算集合中元素的和
         * reduce(T identity, BinaryOperator<T> accumulator)
         * identity: 初始值，这个值将作为累积计算的起点
         * accumulator: 累积计算器，将两个值相加，得到一个新值
         * 使用 lambda 表达式计算总和
         */
        int sum2 = list.stream().reduce(0, (a, b) -> a + b);
        System.out.println("sum2=" + sum2);

        // 使用方法引用计算总和
        int sum3 = list.stream().reduce(0, Integer::sum);
        System.out.println("sum3=" + sum3);

    }
}

输出结果

groupBy

分组

package org.example;

import org.junit.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.*;
import java.util.concurrent.ConcurrentMap;
import java.util.stream.Collectors;

@SpringBootTest
public class DemoTest {
    @Test
    public void test1() {
        List<String> list = Arrays.asList("apple", "banana", "orange");
        Map<Integer, List<String>> groups = new HashMap<>();
        for (String item : list) {
            int length = item.length();
            if (!groups.containsKey(length)) {
                groups.put(length, new ArrayList<>());
            }
            groups.get(length).add(item);
        }

        System.out.println(groups);

        // jdk8中的分组
        Map<Integer, List<String>> groups2 = list.stream().collect(Collectors.groupingBy(String::length));
        System.out.println(groups2);

        /**
         * groupingByConcurrent 是一个用于并行流处理的分组操作，它可以更高效地处理并行流中的数据。与普通的 groupingBy 相比，groupingByConcurrent 更适合在并行流中使用，因为它提供了更好的并发性能
         */
        // 使用并行流和 groupingByConcurrent 进行分组
        ConcurrentMap<Integer, List<String>> groups3 = list.parallelStream().collect(Collectors.groupingByConcurrent(String::length));
        System.out.println(groups3);

    }
}

输出结果

线程

package org.example;

import org.junit.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class DemoTest {
    @Test
    public void test1() {
        // 传统的创建线程方式
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello world");
            }
        });
        thread.start();

        // lambda表达式创建线程
        Thread thread1 = new Thread(() -> {
            System.out.println("hello world");
        });

        thread1.start();

    }
}

输出结果

Optional

使用Optional对空指针进行判断

package org.example;

import org.junit.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Optional;

@SpringBootTest
public class DemoTest {
    @Test
    public void test1() {
        String str = "hello world";
        if (null != str) {
            System.out.println(str.toUpperCase());
        }
        /**
         * 使用了Optional类来安全地处理可能为null的字符串str：
         * 如果str不为null，则调用toUpperCase()方法并将其打印出来；
         */
        Optional.ofNullable(str).ifPresent(x -> System.out.println(x.toUpperCase()));

        // 也可以这样使用lambda表达式
        Optional.ofNullable(str).map(String::toUpperCase).ifPresent(System.out::println);

    }
}

输出结果

sort

集合的排序

package org.example;

import org.junit.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

@SpringBootTest
public class DemoTest {
    @Test
    public void test1() {
        List<String> list = Arrays.asList("apple", "banana", "orange");
        List<String> list2 = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("a")) {
                list2.add(s.toUpperCase());
            }
        }
        // 排序
        Collections.sort(list2);
        System.out.println(list2);

        // 使用stream流进行筛选、转换和排序
        List<String> list3 = list.stream().filter(x -> x.startsWith("a"))
                .map(String::toUpperCase).sorted().collect(Collectors.toList());
        System.out.println(list3);


    }
}

输出结果