【水】告别 for 循环告别 if 实现数组去重

告别 for 循环告别 if 实现数组去重

• 水博客 >.<

水博客 >.<

刷博客时偶尔也会看到有时候面试提到 jdk8 的新特性（反正我没遇到过>.<）
今天就来以一个简单例子来搞搞这个 ♥ 特性 之 stream流 和 lambda表达式

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

import static java.util.stream.Collectors.toList;
    @Test
    public void distincFunc(){
        String [] strArr = {"zhao","qian","sun","li","zhao","qian","sun","li"};
        // distinct()方法去重
        List<String> collect = Arrays.stream(strArr).distinct().collect(toList());
        // 传统遍历方式
        for (String c:
                collect) {
            System.out.println(c);
        } 
		// 下面用lambda 表达式改造
        collect.forEach( c-> System.out.println(c) );
    }

注意这里从数组转换成集合了（主要是集合能直接 foreach 然后演示lambda表达式），不过也可以在 去重方法后面改 链 .toArray()方法得到一个 Object数组。

好了，说完了再见！

当然没有

我们大胆点进去 按住 Ctrl + 左键（最多看不懂好像没啥损失），可以看到实际是DistinctOps这个对象的markRef() 方法 在搞鬼 ，快看到重点了 再冲进去看看。

    /**
     * Appends a "distinct" operation to the provided stream, and returns the
     * new stream.
     *
     * @param <T> the type of both input and output elements
     * @param upstream a reference stream with element type T
     * @return the new stream
     */
    static <T> ReferencePipeline<T, T> makeRef(AbstractPipeline<?, T, ?> upstream) {
        return new ReferencePipeline.StatefulOp<T, T>(upstream, StreamShape.REFERENCE,
                                                      StreamOpFlag.IS_DISTINCT | StreamOpFlag.NOT_SIZED) {

            <P_IN> Node<T> reduce(PipelineHelper<T> helper, Spliterator<P_IN> spliterator) {
                // If the stream is SORTED then it should also be ORDERED so the following will also
                // preserve the sort order
                TerminalOp<T, LinkedHashSet<T>> reduceOp
                        = ReduceOps.<T, LinkedHashSet<T>>makeRef(LinkedHashSet::new, LinkedHashSet::add,
                                                                 LinkedHashSet::addAll);
                return Nodes.node(reduceOp.evaluateParallel(helper, spliterator));
            }

em…好像打扰了，走了。

等等 我好像看到了什么

那么我们大胆猜测 distinct方法实际使用 LinkHashSet 实现的去重操作，其他还是看不懂哈哈（千层封装调用，看到一半放弃了），面试说到这里应该也差不多了

有时间有精力的大神可以教教我，跪求！

再来说说 lambda 吧

多了也不懂我就是个臭打代码的，只能在 运用 的层面唇枪舌剑一番

//	返回给定字符串的长度	
(String	str) ->	 str.length()
//	始终返回233的无参方法	
() -> 233
//	返回当前用户是否年龄大于18岁，返回一个boolean值
(User user) -> user.getAge() >	18
//	包含多行表达式，需用花括号括起来，并使用return关键字返回 
(int x,	int	y) -> {
	int	z =	x *	y;
	return	x + z;
}
// 遍历集合
List list =	Arrays.asList(1, 2, 3, 4, 5, 6);	
list.forEach(i -> System.out.println(i));

可以看出 lambda表达式作为 一次性使用的函数 的写法是非常简约（装b)的。

来源：CSDN

作者：9233

链接：https://blog.csdn.net/weixin_45325750/article/details/103645764