jdk descargar actualizar java

descargar - ¿Una colección de Java de pares de valores?(tuplas?)



java descargar (17)

Me gusta cómo Java tiene un Mapa en el que puede definir los tipos de cada entrada en el mapa, por ejemplo, <String, Integer> .

Lo que estoy buscando es un tipo de colección donde cada elemento de la colección es un par de valores. Cada valor en el par puede tener su propio tipo (como el ejemplo anterior de Cadena y Entero), que se define en el momento de la declaración.

La colección mantendrá su orden dado y no tratará uno de los valores como una clave única (como en un mapa).

Esencialmente quiero poder definir un ARRAY de tipo <String,Integer> o cualquier otro tipo de 2.

Me doy cuenta de que puedo hacer una clase con nada más que las 2 variables, pero eso parece demasiado detallado.

También me doy cuenta de que podría usar una matriz 2D, pero debido a los diferentes tipos que necesito usar, tendría que hacer las matrices de OBJECT, y luego tendría que emitir todo el tiempo.

Solo necesito almacenar pares en la colección, así que solo necesito dos valores por entrada. ¿Existe algo como esto sin seguir la ruta de clase? ¡Gracias!

Java 9+

En Java 9, simplemente puede escribir: Map.entry(key, value) para crear un par inmutable.

Nota: este método no permite que las claves o valores sean nulos. Si desea permitir valores nulos, por ejemplo, desea cambiar esto a: Map.entry(key, Optional.ofNullable(value)) .

Java 8+

En Java 8, puede usar el javafx.util.Pair uso más general para crear un par serializable e inmutable. Esta clase permite claves nulas y valores nulos. (En Java 9, esta clase se incluye en el módulo javafx.base ). EDITAR: A partir de Java 11, JavaFX se ha desacoplado del JDK, por lo que necesitaría el artefacto maven adicional org.openjfx: javafx-base.

Java 6+

En Java 6 y versiones posteriores, puede utilizar AbstractMap.SimpleImmutableEntry más detallado para un par inmutable, o AbstractMap.SimpleEntry para un par cuyo valor se puede cambiar. Estas clases también permiten claves nulas y valores nulos, y son serializables.

Androide

Si está escribiendo para Android, solo use Pair.create(key, value) para crear un par inmutable.

Apache Commons

Apache Commons Lang proporciona el útil Pair.of(key, value) para crear un par inmutable, comparable y serializable.

Colecciones de eclipse

Si está utilizando pares que contienen primitivas, Eclipse Collections proporciona algunas clases de par primitivo muy eficientes que evitarán todo el ineficiente autoajuste y desajuste automático.

Por ejemplo, podría usar PrimitiveTuples.pair(int, int) para crear un IntIntPair , o PrimitiveTuples.pair(float, long) para crear un FloatLongPair .

Proyecto Lombok

Usando Project Lombok , puedes crear una clase de par inmutable simplemente escribiendo:

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

Lombok rellenará los métodos de constructor, getters, equals() , hashCode() y toString() automáticamente en el bytecode generado. Si desea un método de fábrica estático en lugar de un constructor, por ejemplo, un Pair.of(k, v) , simplemente cambie la anotación a: @Value(staticConstructor = "of") .

De otra manera

Si ninguna de las soluciones anteriores hace flotar su barco, puede simplemente copiar y pegar el siguiente código (que, a diferencia de la clase que figura en la respuesta aceptada, protege contra las 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; } }

AbstractMap.SimpleEntry

Fácil que estás buscando esto:

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

¿Cómo se puede llenar?

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);

Esto simplifica a:

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);

Y, con la ayuda de un método createEntry , puede reducir aún más la verbosidad a:

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

Dado que ArrayList no es definitivo, se puede clasificar en subclases para exponer un método (y el método createEntry mencionado createEntry ), lo que da como resultado un createEntry sintáctico:

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

¿Qué pasa con com.sun.tools.javac.util.Pair?

¿Qué pasa con la clase de Pair "Apache Commons Lang 3" y las subclases 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 es una subclase específica que no permite modificar los valores del par, pero existen otras implementaciones con diferentes semánticas. Estas son las coordenadas de Maven, si las necesitas.

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

Ampliando en las otras respuestas, un par inmutable genérico debería tener un método estático para evitar saturar su código con la llamada al constructor:

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); } }

Si nombra el método estático "of" o "pairOf", el código se vuelve fluido, ya que puede escribir:

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

Es una verdadera lástima que las bibliotecas principales de java sean tan escasas en tales cosas que tienes que usar commons-lang u otros terceros para hacer cosas tan básicas. Otra razón más para actualizar a Scala ...

Apache common lang3 tiene la clase Pair y algunas otras bibliotecas mencionadas en este hilo. ¿Cuál es el equivalente del par C ++ <L, R> en Java?

Ejemplo que coincide con el requisito de su pregunta 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()); }

Esto se basa en el código de JavaHelp4u.

Menos detallado y muestra cómo hacer en una línea y cómo hacer un bucle sobre las cosas.

//======> 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()); }

Iba a preguntar si no desea utilizar una List<Pair<T, U>> ? pero luego, por supuesto, el JDK no tiene una clase Pair <>. Pero un Google rápido encontró uno en Wikipedia y en forums.sun.com . Aclamaciones

La clase Pair es uno de esos ejemplos genéricos "dame" que es bastante fácil de escribir por tu cuenta. Por ejemplo, en la parte superior de mi cabeza:

public class Pair<L,R> { private final L left; private final R right; public Pair(L left, R right) { 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()); } }

Y sí, esto existe en varios lugares de la red, con diversos grados de integridad y características. (Mi ejemplo anterior pretende ser inmutable.)

La solución preferida como la describió es una Lista de pares (es decir, Lista).

Para lograr esto, crearías una clase Pair para usar en tu colección. Esta es una clase de utilidad útil para agregar a su base de código.

La clase más cercana en el Sun JDK que proporciona una funcionalidad similar a una clase típica de Par es AbstractMap.SimpleEntry. Podría usar esta clase en lugar de crear su propia clase de pareja, aunque tendría que vivir con algunas restricciones incómodas y creo que la mayoría de la gente no consideraría el rol deseado de SimpleEntry. Por ejemplo, SimpleEntry no tiene un método "setKey ()" ni un constructor predeterminado, por lo que puede que le resulte demasiado limitante.

Tenga en cuenta que las colecciones están diseñadas para contener elementos de un solo tipo. Las interfaces de utilidades relacionadas, como Map, en realidad no son colecciones (es decir, Map no implementa la interfaz de colección). Un par tampoco implementaría la interfaz de la colección, pero obviamente es una clase útil para construir estructuras de datos más grandes.

Lo primero que tengo en mente al hablar sobre los pares clave / valor es la Clase de propiedades donde puede guardar y cargar elementos en una secuencia / archivo.

Para cualquier persona que esté desarrollando para Android, puede usar android.util.Pair . :)

Podría escribir una clase de par genérico <A, B> y usarla en una matriz o lista. Sí, tienes que escribir una clase, pero puedes reutilizar la misma clase para todos los tipos, así que solo tienes que hacerlo una vez.

Quiero decir, aunque no hay una clase Pair en Java, hay algo muy similar: Map.Entry

Map.Entry Documentación

Esto es (simplificando bastante) lo que HashMap , o en realidad cualquier Map almacena.

Puede crear una instancia de Map almacenar sus valores en ella y obtener el conjunto de entradas. Terminará con un Set<Map.Entry<K,V>> que efectivamente es lo que quiere.

Asi que:

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 }

solo crea una clase como

class tuples { int x; int y; }

luego crea Lista de estos objetos de tuplas

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

por lo que también puede implementar otras nuevas estructuras de datos de la misma manera.