java stream is closed

I want to use stream getfirst method two times but an error occurred says (java.lang.IllegalStateException: stream has already been operated upon or closed) and this stream code begins at comment named here.

                //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();
	
    		}  		
    	}
    }

You can't use a stream twice. Create a variable to hold the value of findFirst()

sort2 is not doing anything for you, and simply hiding the issue that you can't reuse sorted.

In this situation, by far the best solution is to store sorted.findFirst() in a variable and reuse it rather than call findFirst() twice. If you wanted to do it like this, then you would have to write

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

...which would sort the entries twice, which would be very inefficient.

Stream.findFirst is a terminal operation - calling findFirst twice on the same stream like you are doing is not possible.

It looks like you don't need to call it twice: even if you restarted a new stream, both times you would expect to get the same map entry. So call findFirst only once, and use the Optional it returns to you:

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

Note that there's a better way to get the maximum item from the stream than sorting: using the max operator.

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