Mi Hashtable în Java ar putea beneficia de o valoare având un tuplu structura. Ce structura de date pot folosi în Java pentru a face asta?
Hashtable<Long, Tuple<Set<Long>,Set<Long>>> table = ...
Eu nu't cred că există un scop general tuplu clasa in Java, dar unul personalizat ar putea fi la fel de ușor ca următoarele:
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;
}
}
Desigur, există unele implicații importante de cum de a proiecta această clasă în ceea ce privește egalitatea, imutabilitatea, etc., mai ales dacă aveți de gând să utilizați cazuri ca cheile de hashing.
Apache Commons a furnizat unele comune java utilități, inclusiv o Pereche. El pune în aplicare Hartă.Intrare", "Comparabile" și " Serializable
.
Ca o extensie a @maerics frumos de raspuns, m-am'am adăugat câteva metode utile:
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;
}
}
Aici's exact aceeași întrebare în altă parte, care include o mai robust este egal cu
, hash
că maerics face referire la:
Că discuția se duce la oglindă maerics vs ColinD apropie de "ar trebui să mă re-utiliza o clasă Tuplu cu un nespecifice nume, sau de a face o nouă clasă cu nume specifice de fiecare data ma lovesc de această situație". Cu ani în urmă am fost în cele din urmă tabără; I'am evoluat în sprijinirea fostul.
Cu lombok's ușor pentru a declara o "Pereche" de clasă:
@Data(staticConstructor = "of")
public class Pair<A, B> {
private final A left;
private final B right;
}
Acest lucru va genereaza getters, constructor static numit "a", este egal cu()
, hashcode () " și " toString()
.
vezi @Date
documentația pentru mai multe informații
Creați o clasă care descrie conceptul're, de fapt, de modelare și de a folosi asta. Acesta poate stoca doar două
Pentru a suplimenta @maerics's a răspunde, aici este "Comparabile" tuplu:
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;
}
}
Deși articolul este destul de vechi acum, și, deși am înțeles că m-am'm nu într-adevăr foarte util, cred că activitatea desfășurată aici: http://www.pds.ewi.tudelft.nl/pubs/papers/cpe2005.pdf ar fi fost frumos în masă Java.
Puteți face lucruri cum ar fi:
int a;
char b;
float c;
[a,b,c] = [3,'a',2.33];
sau
[int,int,char] x = [1,2,'a'];
sau
public [int,boolean] Find(int i)
{
int idx = FindInArray(A,i);
return [idx,idx>=0];
}
[idx, found] = Find(7);
Aici tupluri sunt:
Această abordare crește
Puteți utiliza Google Guava Masă
Voi începe de la un punct de vedere general despre tupluri în Java și să termin cu o implicație pentru probleme concrete.
tuplu = (4, 7.9, 'python')
). Dacă totuși doriți să utilizați ceva de genul un scop general tuplu (care este nu se recomandă), ar trebui să utilizați Object [] " sau " Lista<Obiect>
și a aruncat elementele după o verificare cu instanceof să vă asigur de tip siguranță.De obicei, tupluri într-o anumită setare sunt utilizate întotdeauna în același mod, cu conținut de aceeași structură. În Java, trebuie să definiți această structură în mod explicit într-o "clasă" pentru a oferi bine definite, de tip în condiții de siguranță valori și metode. Acest lucru pare enervant și unnecessairy la început, dar previne erorile deja la compilare.
Dacă aveți nevoie de un tuplu care conține aceleași (super-)clase Foo
, utilizat Foo[]
, Listă<Foo>", sau " Lista<? se extinde Foo>
(sau liste de's imuabil omologii). Când un tuplu nu este de o anumită lungime, această soluție este echivalentă.
In cazul tau, pari să ai nevoie de o "Pereche" (adică un tuplu de bine definite lungime 2). Aceasta face maerics's a răspunde sau unul suplimentar răspunsurile cele mai eficiente, deoarece puteți reutiliza codul în viitor.