Эффективный возврат двух значений из функции Java

Оптимизация -XX:+EliminateAllocations (включена по умолчанию в Java 8) отлично подходит для этого.

Всякий раз, когда вы возвращаете new Pair(a, b) прямо в конце метода вызываемого объекта и сразу же используете результат в вызывающем объекте, JVM, скорее всего, выполнит скалярную замену, если вызываемый объект встроен.

Простой эксперимент показывает, что при возврате объекта почти нет накладных расходов. Это не только эффективный способ, но и самый читаемый.

Benchmark                        Mode  Cnt    Score   Error   Units
ReturnPair.manualInline         thrpt   30  127,713 ± 3,408  ops/us
ReturnPair.packToLong           thrpt   30  113,606 ± 1,807  ops/us
ReturnPair.pairObject           thrpt   30  126,881 ± 0,478  ops/us
ReturnPair.pairObjectAllocated  thrpt   30   92,477 ± 0,621  ops/us

Эталон:

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;

import java.util.concurrent.ThreadLocalRandom;

@State(Scope.Benchmark)
public class ReturnPair {
    int counter;

    @Benchmark
    public void manualInline(Blackhole bh) {
        bh.consume(counter++);
        bh.consume(ThreadLocalRandom.current().nextInt());
    }

    @Benchmark
    public void packToLong(Blackhole bh) {
        long packed = getPacked();
        bh.consume((int) (packed >>> 32));
        bh.consume((int) packed);
    }

    @Benchmark
    public void pairObject(Blackhole bh) {
        Pair pair = getPair();
        bh.consume(pair.a);
        bh.consume(pair.b);
    }

    @Benchmark
    @Fork(jvmArgs = "-XX:-EliminateAllocations")
    public void pairObjectAllocated(Blackhole bh) {
        Pair pair = getPair();
        bh.consume(pair.a);
        bh.consume(pair.b);
    }

    public long getPacked() {
        int a = counter++;
        int b = ThreadLocalRandom.current().nextInt();
        return (long) a << 32 | (b & 0xffffffffL);
    }

    public Pair getPair() {
        int a = counter++;
        int b = ThreadLocalRandom.current().nextInt();
        return new Pair(a, b);
    }

    static class Pair {
        final int a;
        final int b;

        Pair(int a, int b) {
            this.a = a;
            this.b = b;
        }
    }
}

Описанное вами решение почти настолько же хорошо, как вы можете получить в Hotspot - передача объекта для хранения возвращаемых значений и его изменение. (Типы значений Java 10 могли бы сделать здесь что-то лучше, но я не думаю, что это еще даже на стадии прототипа.)

Тем не менее, небольшие короткоживущие объекты на самом деле не так уж далеки от нулевых накладных расходов. Сборка мусора из недолговечных объектов преднамеренно очень дешева.

Мне пришлось столкнуться с этой проблемой, и я обнаружил, что лучший способ — создать экземпляр простого final class с public полями, а затем передать его в качестве параметра вашему методу. Отправьте результаты в этот экземпляр.

Если у вас есть цикл, попробуйте повторно использовать этот экземпляр как можно дольше.

Наличие сеттеров и геттеров в Java 7 (когда я это делал) имело очень небольшие накладные расходы. То же самое происходит с созданием новых объектов в каждом цикле.