met behulp van paren of 2-tuples in Java

Mijn hashtable in Java zou profiteren van een waarde met een tuple-structuur. Welke gegevensstructuur kan ik in Java gebruiken om dat te doen?

Hashtable<Long, Tuple<Set<Long>,Set<Long>>> table = ...

1, Autoriteit 100%

Ik denk niet dat er een algemene tuple-klasse in Java is, maar een aangepaste persoon kan zo eenvoudig zijn als het volgende:

public class Tuple<X, Y> { 
  public final X x; 
  public final Y y; 
  public Tuple(X x, Y y) { 
    this.x = x; 
    this.y = y; 
  } 
} 

Natuurlijk zijn er enkele belangrijke implicaties van het ontwerpen van deze klasse verder met betrekking tot gelijkheid, immutabiliteit, enz., Vooral als u van plan bent om gevallen als sleutels voor hashing te gebruiken.

2, Autoriteit 50%

javatuistuizen is een toegewijd project voor tuples in Java.

Unit<A> (1 element)
Pair<A,B> (2 elements)
Triplet<A,B,C> (3 elements)

3, Autoriteit 31%

Apache Commons verstrekt enkele gemeenschappelijke Java-hulpprogramma’s, waaronder een paar . Het implementeert Map.Entry, Comparableen Serializable.

4, Autoriteit 19%

Als u op zoek bent naar een ingebouwd Java-tuPle, probeer dan AbstractMap.SimpleEntry.

5, Autoriteit 11%

Als uitbreiding op het mooie antwoord van @maerics heb ik een paar handige methoden toegevoegd:

public class Tuple<X, Y> { 
    public final X x; 
    public final Y y; 
    public Tuple(X x, Y y) { 
        this.x = x; 
        this.y = y; 
    }
    @Override
    public String toString() {
        return "(" + x + "," + y + ")";
    }
    @Override
    public boolean equals(Object other) {
        if (other == this) {
            return true;
        }
        if (!(other instanceof Tuple)){
            return false;
        }
        Tuple<X,Y> other_ = (Tuple<X,Y>) other;
        // this may cause NPE if nulls are valid values for x or y. The logic may be improved to handle nulls properly, if needed.
        return other_.x.equals(this.x) && other_.y.equals(this.y);
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((x == null) ? 0 : x.hashCode());
        result = prime * result + ((y == null) ? 0 : y.hashCode());
        return result;
    }
}

Antwoord 6, autoriteit 8%

Nog 2 cent: vanaf Java 7 is er nu een klasse voor in standaard Lib: javafx.util.Pair.

En ja, het is standaard Java, nu JavaFx is opgenomen in de JDK 🙂

Antwoord 7, autoriteit 5%

Hier is exact dezelfde vraag elders, die een robuustere equals, hashbevat waarop maerics zinspeelt:

http://groups.google. com/group/comp.lang.java.help/browse_thread/thread/f8b63fc645c1b487/1d94be050cfc249b

Die discussie gaat verder met spiegelen de Maerics vs Colind-benaderingen van “Moet ik een klasse-tuple met een niet-specifieke naam opnieuw gebruiken of een nieuwe klasse maken met specifieke namen telkens wanneer ik deze situatie tegenkom”. Jaren geleden was ik in het laatste kamp; Ik heb geëvolueerd om de eerste te ondersteunen.

8, Autoriteit 2%

Android Tuple Utils

Dit object geeft een verstandige implementatie van gelijken (), die waar is als gelijk is aan () is waar op elk van de ingesloten objecten.

9, Autoriteit 2%

Maak een klasse die het concept beschrijft dat u eigenlijk modelleert en gebruikt. Het kan gewoon twee opslaan Set<Long>en bieden accessors voor hen, maar het moet worden genoemd om aan te geven wat precies elk van die sets is en waarom ze worden gegroepeerd.

10

Om het antwoord van @ Maerics aan te vullen, is hier de Comparabletuple:

import java.util.*;
/**
 * A tuple of two classes that implement Comparable
 */
public class ComparableTuple<X extends Comparable<? super X>, Y extends Comparable<? super Y>>
       extends Tuple<X, Y>
       implements Comparable<ComparableTuple<X, Y>>
{
  public ComparableTuple(X x, Y y) {
    super(x, y);
  }
  /**
   * Implements lexicographic order
   */
  public int compareTo(ComparableTuple<X, Y> other) {
    int d = this.x.compareTo(other.x);
    if (d == 0)
      return this.y.compareTo(other.y);
    return d;
  }
}

Antwoord 11

Hoewel het artikel nu behoorlijk oud is, en hoewel ik begrijp dat ik niet echt behulpzaam ben, denk ik dat het werk hier is gedaan: http://www.pds.ewi.tudelft.nl/pubs/papers/cpe2005.pdf, zou leuk geweest zijn in mainstream Java.

Je kunt dingen doen als:

int a;
char b;
float c;
[a,b,c] = [3,'a',2.33];

of

[int,int,char] x = [1,2,'a'];

of

public [int,boolean] Find(int i)
{
  int idx = FindInArray(A,i);
  return [idx,idx>=0];
}
[idx, found] = Find(7);

Hier zijn tupels:

• Gedefinieerd als primitieve typen – geen sjablonen/generieken
• Toegewezen stapel indien lokaal gedeclareerd
• Toegewezen met behulp van patroonovereenkomst

Deze aanpak neemt toe

• Prestaties
• Leesbaarheid
• Expressiviteit

Antwoord 12

U kunt de Google Guava-tabel

gebruiken