Eu gosto de como o Java tem um mapa onde você pode definir os tipos de cada entrada no mapa, por exemplo <String, Integer>.

O que estou procurando é um tipo de coleção em que cada elemento da coleção é um par de valores. Cada valor no par pode ter seu próprio tipo (como o exemplo String e Inteiro acima), que é definido no momento da declaração.

A coleção manterá sua ordem determinada e não tratará um dos valores como uma chave exclusiva (como em um mapa).

Essencialmente, eu quero poder definir uma ARRAY do tipo <String,Integer>ou quaisquer outros 2 tipos.

Percebo que posso fazer uma aula com nada além das 2 variáveis, mas isso parece excessivamente detalhado.

Também percebo que eu poderia usar uma matriz 2D, mas, devido aos diferentes tipos que preciso usar, precisaria transformá-los em matrizes de OBJECT e, em seguida, precisaria converter o tempo todo.

Eu só preciso armazenar pares na coleção, então só preciso de dois valores por entrada. Existe algo assim sem seguir a rota da classe? Obrigado!

A classe Pair é um daqueles exemplos genéricos "gimme" que são fáceis de escrever por conta própria. Por exemplo, em cima da minha cabeça:

public class Pair<L,R> {

  private final L left;
  private final R right;

  public Pair(L left, R right) {
    assert left != null;
    assert right != null;

    this.left = left;
    this.right = right;
  }

  public L getLeft() { return left; }
  public R getRight() { return right; }

  @Override
  public int hashCode() { return left.hashCode() ^ right.hashCode(); }

  @Override
  public boolean equals(Object o) {
    if (!(o instanceof Pair)) return false;
    Pair pairo = (Pair) o;
    return this.left.equals(pairo.getLeft()) &&
           this.right.equals(pairo.getRight());
  }

}

E sim, isso existe em vários locais da Internet, com diferentes graus de completude e recursos. (Meu exemplo acima pretende ser imutável.)

AbstractMap.SimpleEntry

Fácil você está procurando isso:

java.util.List<java.util.Map.Entry<String,Integer>> pairList= new java.util.ArrayList<>();

Como você pode preenchê-lo?

java.util.Map.Entry<String,Integer> pair1=new java.util.AbstractMap.SimpleEntry<>("Not Unique key1",1);
java.util.Map.Entry<String,Integer> pair2=new java.util.AbstractMap.SimpleEntry<>("Not Unique key2",2);
pairList.add(pair1);
pairList.add(pair2);

Isso simplifica para:

Entry<String,Integer> pair1=new SimpleEntry<>("Not Unique key1",1);
Entry<String,Integer> pair2=new SimpleEntry<>("Not Unique key2",2);
pairList.add(pair1);
pairList.add(pair2);

E, com a ajuda de um createEntrymétodo, pode reduzir ainda mais a verbosidade para:

pairList.add(createEntry("Not Unique key1", 1));
pairList.add(createEntry("Not Unique key2", 2));

Como ArrayListnão é final, pode ser subclassificado para expor um ofmétodo (e o createEntrymétodo mencionado acima ), resultando na síntese sintática:

TupleList<java.util.Map.Entry<String,Integer>> pair = new TupleList<>();
pair.of("Not Unique key1", 1);
pair.of("Not Unique key2", 2);

Java 9 ou superior

No Java 9, você pode simplesmente escrever: Map.entry(key, value) para criar um par imutável.

Nota: este método não permite que chaves ou valores sejam nulos. Se você quiser permitir valores nulos, por exemplo, que você gostaria de mudar isso para: Map.entry(key, Optional.ofNullable(value)).

Java 8+

No Java 8, você pode usar o propósito mais geral javafx.util.Pairpara criar um par serializável e imutável. Esta classe não permitir chaves nulos e valores nulos. (No Java 9, essa classe está incluída no javafx.basemódulo). EDIT: A partir do Java 11, o JavaFX foi dissociado do JDK, portanto, você precisa do artefato maven adicional org.openjfx: javafx-base.

Java 6+

No Java 6 e superior, você pode usar o mais detalhado AbstractMap.SimpleImmutableEntrypara um par imutável ou AbstractMap.SimpleEntrypara um par cujo valor pode ser alterado. Essas classes também permitem chaves e valores nulos e são serializáveis.

Android

Se você está escrevendo para Android, use Pair.create(key, value)para criar um par imutável.

Apache Commons

Apache Commons Langfornece o útil Pair.of(key, value)para criar um par imutável, comparável e serializável.

Coleções Eclipse

Se você estiver usando pares que contêm primitivas, o Eclipse Collections fornecerá algumas classes de pares primitivos muito eficientes que evitarão todo o ineficiente auto-boxe e auto-unboxing.

Por exemplo, você pode usar PrimitiveTuples.pair(int, int)para criar um IntIntPairou PrimitiveTuples.pair(float, long)para criar um FloatLongPair.

Projeto Lombok

Usando o Projeto Lombok , você pode criar uma classe de pares imutável simplesmente escrevendo:

@Value
public class Pair<K, V> {
    K key;
    V value;
}

Lombok vai encher No construtor, getters, equals(), hashCode(), e toString()métodos para você automaticamente no bytecode gerado. Se você quer um método de fábrica estático em vez de um construtor, por exemplo, um Pair.of(k, v), basta alterar a anotação para: @Value(staticConstructor = "of").

De outra forma

Se nenhuma das soluções acima flutuar no seu barco, você pode simplesmente copiar e colar o código a seguir (que, diferentemente da classe listada na resposta aceita, protege contra NullPointerExceptions):

import java.util.Objects;

public class Pair<K, V> {

    public final K key;
    public final V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public boolean equals(Object o) {
        return o instanceof Pair && Objects.equals(key, ((Pair<?,?>)o).key) && Objects.equals(value, ((Pair<?,?>)o).value);
    }

    public int hashCode() {
        return 31 * Objects.hashCode(key) + Objects.hashCode(value);
    }

    public String toString() {
        return key + "=" + value;
    }
}

Map.Entry

Essas classes internas também são uma opção. Ambos implementam a Map.Entryinterface.

• AbstractMap.SimpleEntry
• AbstractMap.SimpleImmutableEntry

O Apache common lang3 possui a classe Pair e poucas outras bibliotecas mencionadas neste segmento Qual é o equivalente do par C ++ <L, R> em Java?

Exemplo que corresponde ao requisito da sua pergunta original:

List<Pair<String, Integer>> myPairs = new ArrayList<Pair<String, Integer>>();
myPairs.add(Pair.of("val1", 11));
myPairs.add(Pair.of("val2", 17));

//...

for(Pair<String, Integer> pair : myPairs) {
  //following two lines are equivalent... whichever is easier for you...
  System.out.println(pair.getLeft() + ": " + pair.getRight());
  System.out.println(pair.getKey() + ": " + pair.getValue());
}

Para quem estiver desenvolvendo para Android, você pode usar android.util.Pair . :)

E a Pairclasse "Apache Commons Lang 3" e as subclasses relativas?

    import org.apache.commons.lang3.tuple.ImmutablePair;
    import org.apache.commons.lang3.tuple.Pair;
    ...
    @SuppressWarnings("unchecked")
    Pair<String, Integer>[] arr = new ImmutablePair[]{
            ImmutablePair.of("A", 1),
            ImmutablePair.of("B", 2)};

    // both access the 'left' part
    String key = arr[0].getKey();
    String left = arr[0].getLeft();

    // both access the 'right' part
    Integer value = arr[0].getValue();
    Integer right = arr[0].getRight();

ImmutablePairé uma subclasse específica que não permite que os valores do par sejam modificados, mas existem outras implementações com semântica diferente. Essas são as coordenadas do Maven, se você precisar delas.

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.4</version>
        </dependency>

Você pode escrever uma classe Pair <A, B> genérica e usá-la em uma matriz ou lista. Sim, você precisa escrever uma turma, mas pode reutilizar a mesma turma para todos os tipos, portanto, apenas uma vez.

Expandindo as outras respostas, um par imutável genérico deve ter um método estático para evitar sobrecarregar seu código com a chamada ao construtor:

class Pair<L,R> {
      final L left;
      final R right;

      public Pair(L left, R right) {
        this.left = left;
        this.right = right;
      }

      static <L,R> Pair<L,R> of(L left, R right){
          return new Pair<L,R>(left, right);
      }
}

se você nomear o método estático "de" ou "pairOf", o código se tornará fluente, pois você pode escrever:

    list.add(Pair.of(x,y)); // my preference
    list.add(pairOf(x,y)); // use with import static x.y.Pair.pairOf

é uma pena que as principais bibliotecas java sejam tão escassas em coisas que você precisa usar o commons-lang ou outros terceiros para fazer essas coisas básicas. mais um motivo para atualizar para o scala ...

Eu ia perguntar se você não gostaria de usar apenas um List<Pair<T, U>>? mas é claro que o JDK não tem uma classe Pair <>. Mas um rápido Google encontrou um na Wikipedia e no forums.sun.com . Felicidades

A solução preferida, como você descreveu, é uma lista de pares (ou seja, lista).

Para fazer isso, você criaria uma classe Pair para uso em sua coleção. Esta é uma classe de utilitário útil para adicionar à sua base de código.

A classe mais próxima no Sun JDK que fornece funcionalidade semelhante a uma classe Pair típica é AbstractMap.SimpleEntry. Você poderia usar essa classe em vez de criar sua própria classe Pair, embora tenha que conviver com algumas restrições embaraçosas e acho que a maioria das pessoas se desaprova como não é o papel pretendido do SimpleEntry. Por exemplo, o SimpleEntry não possui o método "setKey ()" e nenhum construtor padrão; portanto, você pode achar isso muito limitador.

Lembre-se de que as coleções são projetadas para conter elementos de um único tipo. As interfaces de utilidade relacionadas, como o Mapa, não são realmente Coleções (ou seja, o Mapa não implementa a interface Coleção). Um par também não implementaria a interface Collection, mas é obviamente uma classe útil na construção de estruturas de dados maiores.

Isso é baseado no código do JavaHelp4u.

Menos detalhado e mostra como fazer em uma linha e como fazer um loop sobre as coisas.

//======>  Imports
import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;

//======>  Single Entry
SimpleEntry<String, String> myEntry = new SimpleEntry<String, String>("ID", "Text");
System.out.println("key: " + myEntry.getKey() + "    value:" + myEntry.getValue());
System.out.println();

//======>  List of Entries
List<Entry<String,String>> pairList = new ArrayList<>();

//-- Specify manually
Entry<String,String> firstButton = new SimpleEntry<String, String>("Red ", "Way out");
pairList.add(firstButton);

//-- one liner:
pairList.add(new SimpleEntry<String,String>("Gray", "Alternate route"));  //Ananomous add.

//-- Iterate over Entry array:
for (Entry<String, String> entr : pairList) {
    System.out.println("Button: " + entr.getKey() + "    Label: " + entr.getValue());
}

O Apache Crunch também possui uma Pairclasse: http://crunch.apache.org/apidocs/0.5.0/org/apache/crunch/Pair.html

basta criar uma classe como

class tuples 
{ 
int x;
int y;
} 

então crie a Lista desses objetos de tuplas

List<tuples> list = new ArrayList<tuples>();

para que você também possa implementar outras novas estruturas de dados da mesma maneira.

Quero dizer, mesmo que não haja Pairclasse em Java, há algo bastante semelhante:Map.Entry

Documentação de Map.Entry

Isto é (simplificando bastante) o que HashMap, ou realmente qualquer Maploja.

Você pode criar uma instância de Maparmazenar seus valores nela e obter o conjunto de entradas. Você vai acabar com um Set<Map.Entry<K,V>>que efetivamente é o que você deseja.

Assim:

public static void main(String []args)
{    
    HashMap<String, Integer> values = new HashMap<String,Integer>();
    values.put("A", 235);//your custom data, the types may be different
    //more data insertions....
    Set<Map.Entry<String,Integer>> list = values.entrySet();//your list 
    //do as you may with it
}

Spring tem um Pair<S,T>tipo no pacote Data Utilsorg.springframework.data.util

Pair<String,Integer> pair = Pair.of("Test", 123);
System.out.println(pair.getFirst());
System.out.println(pair.getSecond());

E o com.sun.tools.javac.util.Pair?

A primeira coisa que penso em pares de chave / valor é a Classe de Propriedades, na qual é possível salvar e carregar itens em um fluxo / arquivo.

No projeto Reator (io.projectreactor: reator-core), há suporte avançado para n-Tuplas:

Tuple2<String, Integer> t = Tuples.of("string", 1)

Lá você pode obter t.getT1(), t.getT2(), ...Especialmente com Stream ou Flux, você pode até mapear os elementos da tupla:

Stream<Tuple2<String, Integer>> s;
s.map(t -> t.mapT2(i -> i + 2));