Возврат нескольких значений из метода Java: почему нет объектов из n кортежей?

Я предполагаю, что OP означает «Почему Java не поддерживает объекты с n кортежами?». Python, Haskell, Lisp, ML и т. д. имеют разнородные возможности n-кортежей. Также часто способность явно возвращать несколько объектов в языке является синтаксическим сахаром (например, в python возвращаются «a», «b»).

Причина, конечно, в языковом дизайне и согласованности. Java предпочитает быть очень явным и не любит анонимные структуры данных (хотя я бы хотел, чтобы у нас были анонимные замыкания).

Например, в Java нет способа сказать, что мне нужен обратный вызов, который принимает эти параметры типа и возвращает это. Некоторые люди считают это огромной слабостью, другим нравится последовательность и ясность.

ИМХО, хотя это раздражает, я часто борюсь с этой проблемой, создавая статические встроенные классы:

private static class Combo {
   String name;
   int weight;
}

Да, это утомительно, но позже я часто повторно использую и реорганизую эти классы, делая их высшего уровня и добавляя поведение. На самом деле, одно из преимуществ этого пути заключается в том, что гораздо проще добавлять новые поля там, где есть анонимная структура данных (например, в языках FP), становится намного сложнее добавить поле (в конечном итоге вы изменяете тонну кода).

Я должен отметить, что для 2-кортежей некоторые люди используют (или злоупотребляют) java.util.Map.Entry, поскольку в Java 6 есть java.util.AbstractMap.SimpleEntry. Также некоторые люди теперь используют Поддержка пар Commons Lang3 (2-tuple).

Scala имеет поддержку n-кортежей своего рода читерством и имеет целую кучу интерфейсов из 2-16 кортежей, которые являются стандартными для языка и синтаксически скрыты от программиста.

Из чисто образовательных соображений вы можете посмотреть, как это делается в других языках.

ОБНОВЛЕНИЕ: для Java 8

Java 8 будет/возможно (так что вот мой номер... позвоните мне, возможно) будет поддерживать интерфейс с именем java.lang.BiValue с конкретной реализацией, которую вы можете использовать, с именем java.lang.BiVal . Эти классы должны помочь поддерживать новую функциональность лямбда. Но обратите внимание, что это только для двух кортежей.

ОБНОВЛЕНИЕ: за 2015 год

Java 8 не поддерживает кортежи.

ОБНОВЛЕНИЕ: от автора 2015 г.

Если вам все еще нужна поддержка кортежей, есть три библиотеки, которые хорошо поддерживают кортежи:

• javatuples — поддерживает JDK 5 и выше. До 10-кортежа.
• JOOλ — от автора jOOQ, но требуется JDK 8.
• Commons Lang 3 — теперь поддерживает Triple (3-кортеж) и поддерживает JDK 6 и выше.

Методы Java возвращают точно ноль или одно значение; что является стандартом для Java. Если вам нужно вернуть несколько значений, создайте объект с несколькими значениями и верните его.

Если вы хотите вернуть два объекта, вы обычно хотите вернуть один объект, который вместо этого инкапсулирует два объекта.

Есть много хакерских способов сделать это, один из них - вернуть Object[], но тогда у вас есть индексы, о которых нужно беспокоиться, и проверки нулевого указателя, это просто становится неприятно. Другой способ — вернуть String, но тогда вам придется его анализировать, и это становится неприятным.

Я думаю, главный вопрос в том, почему?

Вот в чем загвоздка: если бы я работал с вами над проектом и увидел такое поведение, я бы переписал его, чтобы вы могли увидеть, как с этим следует обращаться. Если вы предоставите пример кода, я перепишу его для иллюстрации.

Пишите свои методы с единой ответственностью, если им нужно вернуть больше данных, чем у них есть возможность, вам, вероятно, следует либо использовать объект, либо разбить его на более мелкие методы.

Доступен новый стиль шаблона, который соответствует «полностью асинхронной» природе, которую вы можете увидеть в таких языках, как JavaScript.

Сейчас большая часть моего кода выглядит так :-)

public class Class1 {

    public interface Callback {
       void setData(String item1, String item2);
    }
    public void getThing(Callback callback) {
        callback.setData("a", "b");
    }
}

public class Class2 {

    public void doWithThing(Class1 o) {
        o.getThing(new Class1.Callback() {
            public void setData(String item1, String item2) {
                ... do something with item 1 and item 2 ...
            }
        });
    }

}

Никаких новых объектов для создания и не так много дополнительных классов, поскольку интерфейс является внутренним классом объекта.

Именно это делает Swift таким замечательным. Код может выглядеть так:

o.getThing({ item1, item2 -> Void in
    ... do something with item 1 and item 2 ...
});

А так как единственный аргумент это блок, то даже это:

o.getThing { item1, item2 -> Void in
    ... do something with item 1 and item 2 ...
};

Java нуждается в доработке, чтобы сделать код, загруженный обратными вызовами, намного более удобным для чтения.

Потому что возврат нескольких значений из метода не рекомендуется (в Java).

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

Возврат нескольких значений в других языках (например, Go) используется, например, для возврата кода ошибки, но Java был разработан по-другому с использованием исключений.