一次List对象去重失败，引发对Java8中distinct

　　作者：puppylpg
　　blog。csdn。netpuppylpgarticledetails78556730list的转map的另一种猜想
　　Java8使用lambda表达式进行函数式编程可以对集合进行非常方便的操作。一个比较常见的操作是将list转换成map，一般使用Collectors的toMap（）方法进行转换。一个比较常见的问题是当list中含有相同元素的时候，如果不指定取哪一个，则会抛出异常。因此，这个是必须的。
　　当然，使用toMap（）的另一个重载方法，可以直接指定。这里，我们想讨论的是另一种方法：在进行转map的操作之前，能不能使用distinct（）先把list的重复元素过滤掉，然后转map的时候就不用考虑重复元素的问题了。使用distinct（）给list去重直接使用distinct（），失败packageexample。mystream；importlombok。AllArgsConstructor；importlombok。Getter；importlombok。NoArgsConstructor；importlombok。ToString；importjava。util。Arrays；importjava。util。List；importjava。util。Map；importjava。util。stream。Collectors；publicclassListToMap｛AllArgsConstructorNoArgsConstructorToStringprivatestaticclassVideoInfo｛GetterStringid；intwidth；intheight；｝publicstaticvoidmain（String〔〕args）｛ListVideoInfolistArrays。asList（newVideoInfo（123，1，2），newVideoInfo（456，4，5），newVideoInfo（123，1，2））；preferred：handleduplicateddatawhentoMap（）MapString，VideoInfoid2VideoInfolist。stream（）。collect（Collectors。toMap（VideoInfo：：getId，xx，（oldValue，newValue）newValue））；System。out。println（NoDuplicated1：）；id2VideoInfo。forEach（（x，y）System。out。println（x，y））；handleduplicateddatausingdistinct（），beforetoMap（）MapString，VideoInfoid2VideoInfo2list。stream（）。distinct（）。collect（Collectors。toMap（VideoInfo：：getId，xx））；System。out。println（NoDuplicated2：）；id2VideoInfo2。forEach（（x，y）System。out。println（x，y））；｝｝
　　list里总共有三个元素，其中有两个我们认为是重复的。第一种转换是使用toMap（）直接指定了对重复key的处理情况，因此可以正常转换成map。而第二种转换是想先对list进行去重，然后再转换成map，结果还是失败了，抛出了IllegalStateException，所以distinct（）应该是失败了。NoDuplicated1：123，ListToMap。VideoInfo（id123，width1，height2）456，ListToMap。VideoInfo（id456，width4，height5）Exceptioninthreadmainjava。lang。IllegalStateException：DuplicatekeyListToMap。VideoInfo（id123，width1，height2）atjava。util。stream。Collectors。lambdathrowingMerger0（Collectors。java：133）atjava。util。HashMap。merge（HashMap。java：1253）atjava。util。stream。Collectors。lambdatoMap58（Collectors。java：1320）atjava。util。stream。ReduceOps3ReducingSink。accept（ReduceOps。java：169）atjava。util。stream。DistinctOps12。accept（DistinctOps。java：175）atjava。util。SpliteratorsArraySpliterator。forEachRemaining（Spliterators。java：948）atjava。util。stream。AbstractPipeline。copyInto（AbstractPipeline。java：481）atjava。util。stream。AbstractPipeline。wrapAndCopyInto（AbstractPipeline。java：471）atjava。util。stream。ReduceOpsReduceOp。evaluateSequential（ReduceOps。java：708）atjava。util。stream。AbstractPipeline。evaluate（AbstractPipeline。java：234）atjava。util。stream。ReferencePipeline。collect（ReferencePipeline。java：499）atexample。mystream。ListToMap。main（ListToMap。java：79）原因：distinct（）依赖于equals（）
　　查看distinct（）的API，可以看到如下介绍：
　　Returnsastreamconsistingofthedistinctelements（accordingto｛linkObjectequals（Object）｝）ofthisstream。
　　显然，distinct（）对对象进行去重时，是根据对象的equals（）方法去处理的。如果我们的VideoInfo类不overrride超类Object的equals（）方法，就会使用Object的。
　　但是Object的equals（）方法只有在两个对象完全相同时才返回true。而我们想要的效果是只要VideoInfo的idwidthheight均相同，就认为两个videoInfo对象是同一个。所以我们比如重写属于videoInfo的equals（）方法。重写equals（）的注意事项
　　我们设计VideoInfo的equals（）如下：Overridepublicbooleanequals（Objectobj）｛if（！（objinstanceofVideoInfo））｛returnfalse；｝VideoInfovi（VideoInfo）obj；returnthis。id。equals（vi。id）this。widthvi。widththis。heightvi。height；｝
　　这样一来，只要两个videoInfo对象的三个属性都相同，这两个对象就相同了。欢天喜地的去运行程序，依旧失败！why？
　　《EffectiveJava》是本好书，连Java之父JamesGosling都说，这是一本连他都需要的Java教程。在这本书中，作者指出，如果重写了一个类的equals（）方法，那么就必须一起重写它的hashCode（）方法！必须！没有商量的余地！
　　必须使得重写后的equals（）满足如下条件：根据equals（）进行比较，相等的两个对象，hashCode（）的值也必须相同；根据equals（）进行比较，不相等的两个对象，hashCode（）的值可以相同，也可以不同；
　　因为这是Java的规定，违背这些规定将导致Java程序运行不再正常。
　　具体更多的细节，建议大家读读原书，必定获益匪浅。强烈推荐！
　　最终，我按照神书的指导设计VideoInfo的hashCode（）方法如下：OverridepublicinthashCode（）｛intn31；nn31this。id。hashCode（）；nn31this。height；nn31this。width；returnn；｝
　　终于，distinct（）成功过滤了list中的重复元素，此时使用两种toMap（）将list转换成map都是没问题的：NoDuplicated1：123，ListToMap。VideoInfo（id123，width1，height2）456，ListToMap。VideoInfo（id456，width4，height5）NoDuplicated2：123，ListToMap。VideoInfo（id123，width1，height2）456，ListToMap。VideoInfo（id456，width4，height5）引申
　　既然说distinct（）是调用equals（）进行比较的，那按照我的理解，list的3个元素至少需要比较3次吧。那是不是就调用了3次equals（）呢？
　　在equals（）中加入一句打印，这样就可以知道了。加后的equals（）如下：Overridepublicbooleanequals（Objectobj）｛if（！（objinstanceofVideoInfo））｛returnfalse；｝VideoInfovi（VideoInfo）obj；System。out。println（Invokeequals（）this。toString（）vs。vi。toString（））；returnthis。id。equals（vi。id）this。widthvi。widththis。heightvi。height；｝
　　结果：NoDuplicated1：123，ListToMap。VideoInfo（id123，width1，height2）456，ListToMap。VideoInfo（id456，width4，height5）Invokeequals（）ListToMap。VideoInfo（id123，width1，height2）vs。ListToMap。VideoInfo（id123，width1，height2）NoDuplicated2：123，ListToMap。VideoInfo（id123，width1，height2）456，ListToMap。VideoInfo（id456，width4，height5）
　　结果发现才调用了一次equals（）。为什么不是3次呢？仔细想想，根据hashCode（）进行比较，hashCode（）相同的情况就一次，就是list的第一个元素和第三个元素（都是VideoInfo（id123，width1，height2））会出现hashCode（）相同的情况。
　　所以我们是不是可以这么猜想：只有当hashCode（）返回的hashCode相同的时候，才会调用equals（）进行更进一步的判断。如果连hashCode（）返回的hashCode都不同，那么可以认为这两个对象一定就是不同的了！
　　验证猜想：
　　更改hashCode（）如下：OverridepublicinthashCode（）｛return1；｝
　　这样一来，所有的对象的hashCode（）返回值都是相同的。当然，这样搞是符合Java规范的，因为Java只规定equals（）相同的对象的hashCode必须相同，但是不同的对象的hashCode未必会不同。
　　结果：NoDuplicated1：123，ListToMap。VideoInfo（id123，width1，height2）456，ListToMap。VideoInfo（id456，width4，height5）Invokeequals（）ListToMap。VideoInfo（id456，width4，height5）vs。ListToMap。VideoInfo（id123，width1，height2）Invokeequals（）ListToMap。VideoInfo（id456，width4，height5）vs。ListToMap。VideoInfo（id123，width1，height2）Invokeequals（）ListToMap。VideoInfo（id123，width1，height2）vs。ListToMap。VideoInfo（id123，width1，height2）NoDuplicated2：123，ListToMap。VideoInfo（id123，width1，height2）456，ListToMap。VideoInfo（id456，width4，height5）
　　果然，equals（）调用了三次！看来的确只有hashCode相同的时候才会调用equal（）进一步判断两个对象究竟是否相同；如果hashCode不相同，两个对象显然不相同。猜想是正确的。结论list转map推荐使用toMap（），并且无论是否会出现重复的问题，都要指定重复后的取舍规则，不费功夫但受益无穷；对一个自定义的class使用distinct（），切记覆写equals（）方法；覆写equals（），一定要覆写hashCode（）；虽然设计出一个hashCode（）可以简单地让其return1，这样并不会违反Java规定，但是这样做会导致很多恶果。比如将这样的对象存入hashMap的时候，所有的对象的hashCode都相同，最终所有对象都存储在hashMap的同一个桶中，直接将hashMap恶化成了一个链表。从而O（1）的复杂度被整成了O（n）的，性能自然大大下降。好书是程序员进步的阶梯。高尔基。比如《EffecctiveJava》。
　　最终参考程序：packageexample。mystream；importlombok。AllArgsConstructor；importlombok。Getter；importlombok。NoArgsConstructor；importlombok。ToString；importjava。util。Arrays；importjava。util。List；importjava。util。Map；importjava。util。stream。Collectors；publicclassListToMap｛AllArgsConstructorNoArgsConstructorToStringprivatestaticclassVideoInfo｛GetterStringid；intwidth；intheight；publicstaticvoidmain（String〔〕args）｛System。out。println（newVideoInfo（123，1，2）。equals（newVideoInfo（123，1，2）））；｝Overridepublicbooleanequals（Objectobj）｛if（！（objinstanceofVideoInfo））｛returnfalse；｝VideoInfovi（VideoInfo）obj；returnthis。id。equals（vi。id）this。widthvi。widththis。heightvi。height；｝Ifequals（）isoverride，hashCode（）mustbeoverride，too。1。ifaequalsb，theymusthavethesamehashCode；2。ifadoesntequalsb，theymayhavethesamehashCode；3。hashCodewritteninthiswaycanbeaffectedbysequenceofthefields；3。25131。So31willbefasterwhendothemultiplication，becauseitcanbereplacedbybitshifting：31i（i5）i。returnOverridepublicinthashCode（）｛intn31；nn31this。id。hashCode（）；nn31this。height；nn31this。width；returnn；｝｝publicstaticvoidmain（String〔〕args）｛ListVideoInfolistArrays。asList（newVideoInfo（123，1，2），newVideoInfo（456，4，5），newVideoInfo（123，1，2））；preferred：handleduplicateddatawhentoMap（）MapString，VideoInfoid2VideoInfolist。stream（）。collect（Collectors。toMap（VideoInfo：：getId，xx，（oldValue，newValue）newValue））；System。out。println（NoDuplicated1：）；id2VideoInfo。forEach（（x，y）System。out。println（x，y））；handleduplicateddatausingdistinct（），beforetoMap（）Notethatdistinct（）reliesonequals（）intheobjectifyouoverrideequals（），hashCode（）mustbeoverridetogetherMapString，VideoInfoid2VideoInfo2list。stream（）。distinct（）。collect（Collectors。toMap（VideoInfo：：getId，xx））；System。out。println（NoDuplicated2：）；id2VideoInfo2。forEach（（x，y）System。out。println（x，y））；｝｝再拓展假设类是别人的，不能修改
　　以上，VideoInfo使我们自己写的类，我们可以往里添加equals（）和hashCode（）方法。如果VideoInfo是我们引用的依赖中的一个类，我们无权对其进行修改，那么是不是就没办法使用distinct（）按照某些元素是否相同，对对象进行自定义的过滤了呢？使用wrapper
　　在stackoverflow的一个回答上，我们可以找到一个可行的方法：使用wrapper。
　　假设在一个依赖中（我们无权修改该类），VideoInfo定义如下：AllArgsConstructorNoArgsConstructorToStringpublicclassVideoInfo｛GetterStringid；intwidth；intheight；｝
　　使用刚刚的wrapper思路，写程序如下（当然，为了程序的可运行性，还是把VideoInfo放进来了，假设它就是不能修改的，不能为其添加任何方法）：packageexample。mystream；importlombok。AllArgsConstructor；importlombok。Getter；importlombok。NoArgsConstructor；importlombok。ToString；importjava。util。Arrays；importjava。util。List；importjava。util。Map；importjava。util。stream。Collectors；publicclassDistinctByWrapper｛privatestaticclassVideoInfoWrapper｛privatefinalVideoInfovideoInfo；publicVideoInfoWrapper（VideoInfovideoInfo）｛this。videoInfovideoInfo；｝publicVideoInfounwrap（）｛returnvideoInfo；｝Overridepublicbooleanequals（Objectobj）｛if（！（objinstanceofVideoInfo））｛returnfalse；｝VideoInfovi（VideoInfo）obj；returnvideoInfo。id。equals（vi。id）videoInfo。widthvi。widthvideoInfo。heightvi。height；｝OverridepublicinthashCode（）｛intn31；nn31videoInfo。id。hashCode（）；nn31videoInfo。height；nn31videoInfo。width；returnn；｝｝publicstaticvoidmain（String〔〕args）｛ListVideoInfolistArrays。asList（newVideoInfo（123，1，2），newVideoInfo（456，4，5），newVideoInfo（123，1，2））；VideoInfomap（）VideoInfoWrapperdistinct（）：VideoInfoWrappermap（）VideoInfoMapString，VideoInfoid2VideoInfolist。stream（）。map（VideoInfoWrapper：：new）。distinct（）。map（VideoInfoWrapper：：unwrap）。collect（Collectors。toMap（VideoInfo：：getId，xx，（oldValue，newValue）newValue））；id2VideoInfo。forEach（（x，y）System。out。println（x，y））；｝｝AssumethatVideoInfoisaclassthatwecantmodifyAllArgsConstructorNoArgsConstructorToStringclassVideoInfo｛GetterStringid；intwidth；intheight；｝
　　整个wrapper的思路无非就是构造另一个类VideoInfoWrapper，把hashCode（）和equals（）添加到wrapper中，这样便可以按照自定义规则对wrapper对象进行自定义的过滤。
　　我们没法自定义过滤VideoInfo，但是我们可以自定义过滤VideoInfoWrapper啊！
　　之后要做的，就是将VideoInfo全部转化为VideoInfoWrapper，然后过滤掉某些VideoInfoWrapper，再将剩下的VideoInfoWrapper转回VideoInfo，以此达到过滤VideoInfo的目的。很巧妙！使用filter（）自定义函数取代distinct（）
　　另一种更精妙的实现方式是自定义一个函数：privatestaticTPredicateTdistinctByKey（Functionlt；？superT，ObjectkeyExtractor）｛MapObject，BooleanmapnewConcurrentHashMap（）；returntmap。putIfAbsent（keyExtractor。apply（t），Boolean。TRUE）null；｝
　　（输入元素的类型是T及其父类，keyExtracctor是映射函数，返回Object，整个传入的函数的功能应该是提取key的。distinctByKey函数返回的是Predicate函数，类型为T。）
　　这个函数传入一个函数（lambda），对传入的对象提取key，然后尝试将key放入concurrentHashMap，如果能放进去，说明此key之前没出现过，函数返回false；如果不能放进去，说明这个key和之前的某个key重复了，函数返回true。
　　这个函数最终作为filter（）函数的入口。根据JavaAPI可知filter（func）过滤的规则为：如果func为true，则过滤，否则不过滤。因此，通过filter（）自定义的函数，凡是重复的key都返回true，并被filter（）过滤掉，最终留下的都是不重复的。
　　最终实现的程序如下packageexample。mystream；importlombok。AllArgsConstructor；importlombok。Getter；importlombok。NoArgsConstructor；importlombok。ToString；importjava。util。Arrays；importjava。util。List；importjava。util。Map；importjava。util。concurrent。ConcurrentHashMap；importjava。util。function。Function；importjava。util。function。Predicate；importjava。util。stream。Collectors；publicclassDistinctByFilterAndLambda｛publicstaticvoidmain（String〔〕args）｛ListVideoInfolistArrays。asList（newVideoInfo（123，1，2），newVideoInfo（456，4，5），newVideoInfo（123，1，2））；GetdistinctonlyMapString，VideoInfoid2VideoInfolist。stream（）。filter（distinctByKey（vivi。getId（）））。collect（Collectors。toMap（VideoInfo：：getId，xx，（oldValue，newValue）newValue））；id2VideoInfo。forEach（（x，y）System。out。println（x，y））；｝IfakeycouldnotbeputintoConcurrentHashMap，thatmeansthekeyisduplicatedparamkeyExtractoramappingfunctiontoproducekeysparamTthetypeoftheinputelementsreturntrueifkeyisduplicated；elsereturnfalseprivatestaticTPredicateTdistinctByKey（Functionlt；？superT，ObjectkeyExtractor）｛MapObject，BooleanmapnewConcurrentHashMap（）；returntmap。putIfAbsent（keyExtractor。apply（t），Boolean。TRUE）null；｝｝AssumethatVideoInfoisaclassthatwecantmodifyAllArgsConstructorNoArgsConstructorToStringclassVideoInfo｛GetterStringid；intwidth；intheight；｝