Overhead: Konvertieren zwischen Primitive Streams vs. Boxen

Question

ich die Java 8 Stream-API wie folgt aus:

private Function<Long, Float> process;   // Intermediate step (& types) 

private long getWeekFrequency(final ScheduleWeek week) { 
    return week.doStreamStuff().count();  // Stream<>.count() returns long 
} 

@Override 
public float analyse(final Schedule sample) { 
    return (float) sample      // cast back to float 
      .getWeeks() 
      .stream() 
      .mapToLong(this::getWeekFrequency) // object to long 
      .mapToDouble(process::apply)  // widen float to double 
      .sum(); 
} 

@Override 
public String explain(final Schedule sample) { 
    return sample 
      .getWeeks() 
      .stream() 
      .map(this::getWeekFrequency)  // change stream type? 
      .map(String::valueOf) 
      .collect(Collectors.joining(", ")); 
} 

Fragen

• Ich nehme an, es Overhead ist, wenn zwischen dem Objekt zu ändern/primitive Stream-Typen ... Wie verhält es sich mit dem Boxen-Overhead, wenn ich mich an Stream <> halte?

• Was ist, wenn ich später zurückwechsle?

Konkret:
In Analytiker soll ich .map(...).mapToDouble(...) verwenden?
In erklären, sollte ich .mapToLong(...).mapToObj(...) verwenden?

Answer 1

Also lassen Sie uns diese brechen:

.mapToLong(this::getWeekFrequency) 

gibt Ihnen eine primitive lang.

.mapToDouble(process::apply) 

Diese primitive lange auf eine Long eingerahmt wird, weil die process Funktion es erfordert. process gibt eine Float zurück, die einem primitiven Double zugeordnet ist (über Float.doubleValue()).

Diese werden summiert und die Summe wird in ein primitives Float umgewandelt (schmaler, aber sicherer), das dann zurückgegeben wird.

---

Also, wie können wir einige der Autoboxing loswerden? Wir wollen einen FunctionalInterface, der genau zu unserer process Funktion passt, ohne irgendwelche Boxklassen zu verwenden. Es gibt nicht ein wir off-the-shelf verwenden können, aber wir können es leicht definieren, wie so:

private LongToFloatFunction process; 

und halten alles andere gleich:

@FunctionalInterface 
public interface LongToFloatFunction 
{ 
    float apply(long l); 
} 

wir unsere Erklärung Dann ändern was jedes automatische Boxen verhindert. Das von der Funktion zurückgegebene primitive Float wird automatisch auf ein primitives Double erweitert.

Answer 2

Nun, es von Ihrer Definition scheint, dass process Art wie folgt aussieht:

double process (long value) { 
     // do something 
} 

Als solche, wenn Sie tun: map(...).mapToDouble Sie würde ein Objekt vom Typ erschaffen Long jedes Mal, es nur unbox unmittelbar nach in process verwendet werden. Ich würde den Code so lassen, wie er ist, um die primitive Implementierung zu verwenden, die dies vermeiden würde.

Der zweite verwendet String#valueOf. Im Fall von long wird String.valueOf(l) aufgerufen, die auf dem Primitiv funktioniert: Long.toString(l).

Bei Object wird die gleiche Methode aufgerufen, aber mit dem Vorbehalt, dass das erste Boxen passiert. Also würde ich es zu mapToLong