java流已关闭

我想使用stream getfirst方法两次，但出现了一个错误，即（java.lang.IllegalStateException:stream已被操作或关闭），并且此流代码从此处命名的注释开始

                //code
                Stream<Map.Entry<String,Integer>> sorted =
                        map.entrySet().stream()
                           .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()));
                
                Supplier<Stream<Map.Entry<String,Integer>>>  sort2 = () -> sorted;
                Optional<String> kk = Optional.of(sort2.get().findFirst().get().getKey());
                Optional<Integer> vv = Optional.of(sort2.get().findFirst().get().getValue());
                int vmax = vv.get().intValue() ;    
                int count=0;
                ArrayList<String> a = new ArrayList<String>() ;
                for(Map.Entry<String,Integer> h: map.entrySet() ) {
                    if(h.getValue()==vmax) {
                        a.add(h.getKey()) ;
                        count++;
                    }
                }
                
                if(count>1) {
                    Collections.sort(a);
                    System.out.println(a.get(0));
                    
                }
                else {
                    System.out.println(kk.get());
                }    
                map.clear();
    
            }       
        }
    }
        
    
     

//代码
流排序=
map.entrySet（）.stream（）
.sorted（Collections.reverseOrder（Map.Entry.comparingByValue（））；
供应商排序2=（）->已排序；
可选kk=Optional.of（sort2.get（）.findFirst（）.get（）.getKey（））；
可选vv=Optional.of（sort2.get（）.findFirst（）.get（）.getValue（））；
intvmax=vv.get（）.intValue（）；
整数计数=0；
ArrayList a=新的ArrayList（）；
对于（Map.Entry h:Map.entrySet（））{
如果（h.getValue（）==vmax）{
a、 添加（h.getKey（））；
计数++；
}
}
如果（计数>1）{
收集.分类（a）；
System.out.println（a.get（0））；
}
否则{
System.out.println（kk.get（））；
}    
map.clear（）；
}       
}
}

sort2

并没有为您做任何事情，只是隐藏了您无法重用的问题

排序

在这种情况下，到目前为止最好的解决方案是将

sorted.findFirst（）

存储在变量中并重用它，而不是调用

findFirst（）

两次。如果你想这样做，那你就得写

Supplier<Stream<Map.Entry<String,Integer>>> sort2 = () ->  map.entrySet().stream()
   .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()));

Supplier sort2=（）->map.entrySet（）.stream（）
.sorted（Collections.reverseOrder（Map.Entry.comparingByValue（））；

---

…这将对条目进行两次排序，这将非常低效。

流不能使用两次。创建一个变量来保存

findFirst（）

流的值。findFirst

是一个终端操作-不可能像现在这样在同一个流上调用

findFirst

两次

看起来您不需要调用它两次：即使您重新启动了一个新流，两次您都希望得到相同的映射条目。因此，只需调用一次

findFirst

，并使用它返回给您的可选选项：

Optional<Map.Entry<String, Integer>> firstEntry = sorted.findFirst();
Optional<String> kk = firstEntry.map(Map.Entry::getKey);
Optional<Integer> vv = firstEntry.map(Map.Entry::getValue);

Optional<Map.Entry<String, Integer>> maxEntry = map.entrySet().stream()
    .max(Map.Entry.comparingByValue());