Come ordinare un IntStream nell'ordine inverso

Question

Sto leggendo in numeri da un file .txt usando BufferedReader. Voglio invertire l'ordine degli elementi in questo vapore in modo che quando vengono raccolti saranno disposti dal più alto al più basso. Non voglio ordinare dopo che l'array è stato creato perché non ho idea di quanti elementi potrebbero esserci, ho solo bisogno degli elementi N più alti.

in = new BufferedReader(reader); 
       int[] arr = in.lines() 
         .mapToInt(Integer::parseInt) 
         .sorted() 
         .limit((long) N) 
         .toArray(); 

Answer 1

Poiché l'ordine inverso non è l'ordine naturale, sorted() non può essere utilizzato per ordinare in ordine inverso. Se si evita lo IntStream, utilizzando invece Stream<Integer>, è possibile utilizzare uno Collections.reverseOrder() per ordinare lo stream in ordine inverso rispetto all'ordine naturale. Quindi è possibile chiamare mapToInt e convertire in int[] alla fine.

int[] arr = in.lines() 
      .map(Integer::valueOf) // Extract Integer, not int 
      .sorted(Collections.reverseOrder()) // On Stream<Integer> 
      .limit(N) 
      .mapToInt(i -> i)  // map Integer to int 
      .toArray(); 

Answer 2

E 'difficile dire se .sorted().limit((long) N).toArray() sarà ottenere ottimizzato in alcuni casi (è dipendente di attuazione ma data attuale implementazione di Oracle, non mi aspetto di esso), ma in questo caso particolare, il flusso di fonti è un flusso di dimensione sconosciuta che rende le ottimizzazioni ancora meno probabili.

Se si desidera essere sicuri, è possibile adattare this solution per ottenere il numero massimo di n. in modo efficiente. Tutto quello che dovete fare è quello di invertire l'ordine:

public static IntStream maxValuesDescending(IntStream source, int limit) { 
    TreeMap<Integer,Integer> m=new TreeMap<>(Comparator.reverseOrder()); 
    source.forEachOrdered(new IntConsumer() { 
     int size, min=Integer.MIN_VALUE; 
     public void accept(int value) { 
      if(value<min) return; 
      m.merge(value, 1, Integer::sum); 
      if(size<limit) size++; 
      else m.compute(min=m.lastKey(), (k,count)->count==1? null: count-1); 
     } 
    }); 
    if(m.size()==limit)// no duplicates 
     return m.keySet().stream().mapToInt(Integer::valueOf); 
    return m.entrySet().stream().flatMapToInt(e->{ 
     int value = e.getKey(), count = e.getValue(); 
     return count==1? IntStream.of(value): IntStream.range(0, count).map(i->value); 
    }); 
} 

Quindi è possibile utilizzarlo come

int[] arr = maxValuesDescending(in.lines().mapToInt(Integer::parseInt), N).toArray(); 

Ma non sono tenuti a creare un array come si può utilizzare arbitrari IntStream operazioni sul risultato . Questa soluzione manterrà al massimo i valori N, ancor meno se ci sono duplicati in quanto contiene solo valori distinti e il loro conteggio.

Answer 3

Prova negando i valori prima di smistamento e negando (torna alla normalità) dopo la cernita:

in = new BufferedReader(reader); 
int[] arr = in.lines() 
       .mapToInt(Integer::parseInt) 
       .map(i -> -i).sorted().map(i -> -i) 
       .limit((long) N) 
       .toArray();