Java Stream 优化java代码

使用strteam就是为了代码更加简洁，同时功能又不会收到影响，废话不多说

使用原始流

使用 int、long 和 double 等基本类型时，请使用IntStream、LongStream 和 DoubleStream 等基本流，而不是 Integer、Long 和 Double 等装箱类型流。原始流可以通过避免装箱和拆箱的成本来提供更好的性能

package com.java.file.operater;
 
import org.junit.Test;
 
import java.util.stream.IntStream;
 
/**
 * @Description:
 * @Author: 喵星人
 * @Create: 2023/10/12 18:23
 */
 
public class StreamTest {
 
    @Test
    public void test(){
        int[] array = new int[]{1, 2, 3, 4, 5};
        IntStream intStream = IntStream.of(array);
        intStream.forEach(a->{
            System.out.println(a);
        });
 
    }
}

嵌套流

最佳实践是避免嵌套流，因为它可能导致代码难以阅读和理解。相反，尝试将问题分解为更小的部分，并使用中间集合或局部变量来存储中间结果

package com.java.file.operater;
 
import org.junit.Test;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
 
/**
 * @Description:
 * @Author: 喵星人
 * @Create: 2023/10/12 18:23
 */
 
public class StreamTest {
 
    @Test
    public void test(){
        List<String> list1 = Arrays.asList("apple", "banana", "cherry");
        List<String> list2 = Arrays.asList("orange", "pineapple", "mango");
        List<String> list3 = Arrays.asList("orange1", "pineapple1", "mango1","orange1", "pineapple1", "mango1");
        List<String> list4 = Arrays.asList("orange2", "pineapple2", "mango2","orange2", "pineapple2", "mango2");
 
        List<String> stringList = Stream.concat(list1.stream(), list4.stream())
                .filter(s -> s.toString().length() > 6)
                .collect(Collectors.toList());
        stringList.forEach(a->{
            System.out.println(a);
        });
         
    }
}

使用并行流

并行虽然很快吗，但是顺序没法保证，常规的情况的很多问题都会在这里暴露出来，可以类比高并发思考

package com.java.file.operater;
 
import org.junit.Test;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
 
/**
 * @Description:
 * @Author: 喵星人
 * @Create: 2023/10/12 18:23
 */
 
public class StreamTest {
 
    @Test
    public void test(){
        List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
        /**
         * 使用reduce求和，reduce方法接受两个参数：一个初始值（在这里是0），
         * 和一个二元操作符（在这里是Integer::sum）。Integer::sum是一个方法引用，
         * 它调用Integer类的sum方法来计算两个整数的和。
         * reduce方法将流中的所有元素结合在一起（在这里是通过求和），并返回结果
         */
        Integer reduce = integerList.parallelStream().reduce(0, Integer::sum);
        System.out.println(reduce);
    }
}

使用惰性求值以获得更好的性能

package com.java.file.operater;
 
import org.junit.Test;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
 
/**
 * @Description:
 * @Author: 喵星人
 * @Create: 2023/10/12 18:23
 */
 
public class StreamTest {
 
    @Test
    public void test(){
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Optional<Integer> integer = list.stream()
                /**
                 * 代码中的filter方法就是一个惰性操作。它不会立即执行，而是创建了一个新的流，
                 * 该流包含了应用过滤操作的逻辑。只有当一个非惰性操作（例如findFirst）被调用时，所有的惰性操作才会被实际执行
                 */
                .filter(n -> n > 3)
                /**
                 * 由于findFirst方法，一旦找到第一个大于3的元素，过滤操作就会停止，
                 * 而不是继续处理列表中的所有元素。这可以减少不必要的计算，从而提高性能
                 * findFirst是一个短路操作，意味着它不需要处理整个流就可以产生结果
                 */
                .findFirst();
        System.out.println(integer.get());
 
    }
}

在map()之前使用filter()以避免不必要的处理

package com.java.file.operater;
 
import org.bouncycastle.tsp.TSPUtil;
import org.junit.Test;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
 
/**
 * @Description:
 * @Author: 喵星人
 * @Create: 2023/10/12 18:23
 */
 
public class StreamTest {
 
    @Test
    public void test(){
        List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> list = integerList.stream()
                .filter(i -> i % 2 == 0)
                .map(i -> i * 2)
                .collect(Collectors.toList());
        for (Integer integer : list) {
            System.out.println(integer);
        }
 
    }
}

使用distinct()删除重复项

package com.java.file.operater;
 
import org.bouncycastle.tsp.TSPUtil;
import org.junit.Test;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
 
/**
 * @Description:
 * @Author: 喵星人
 * @Create: 2023/10/12 18:23
 */
 
public class StreamTest {
 
    @Test
    public void test(){
        List<Integer> integerList = Arrays.asList(1, 2, 3, 3, 4, 5, 5);
        List<Integer> list = integerList.stream()
                .distinct()
                .collect(Collectors.toList());
        list.forEach(a->{
            System.out.println(a);
        });
 
    }
}

谨慎使用sorted()

package com.java.file.operater;
 
import org.bouncycastle.tsp.TSPUtil;
import org.junit.Test;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
 
/**
 * @Description:
 * @Author: 喵星人
 * @Create: 2023/10/12 18:23
 */
 
public class StreamTest {
 
    @Test
    public void test(){
        List<Integer> integerList = Arrays.asList(34, 3, 1, 89, 2, 10000, 998, 77);
        List<Integer> list = integerList.stream()
                .sorted()
                .collect(Collectors.toList());
        list.forEach(a->{
            System.out.println(a);
        });
 
 
    }
}