Fem Alternativer Til Parklasse I Java
Et Par er en beholder for å lagre en tuple av to objekter. Java gir egentlig ingen implementering av Parklassen. I dette innlegget vil vi diskutere om ulike alternativer For Å Parre klassen I Java.
Par er ofte nyttig for å spore to objekter sammen. Den inneholder to felt, vanligvis betegnet som første og andre, som er i stand til å lagre noe. Til tross for ikke å ha noe meningsfylt forhold mellom første og andre felt, savner programmerere ofte denne funksjonaliteten I Java.
i forrige innlegg har vi diskutert hvordan vi implementerer vår Egen Parklasse I Java. I dette innlegget vil vi diskutere løsninger som er tilgjengelige I Java for å fylle ønsket gap, som diskutert nedenfor:
Kart.Oppføring< K,V > Grensesnitt
Vi kan bruke Kart.Oppføring< K,V > grensesnitt I Java som ligner på std:: pair I C++. Det er et utmerket eksempel på å ha et meningsfylt navn som representerer et nøkkelverdipar.
For å opprette en oppføring som representerer en tilordning fra den angitte nøkkelen til den angitte verdien, Gir Java to konkrete implementeringer Av Kartet.Inngangsgrensesnitt, nemlig Abstraktmap.SimpleEntry Og AbstractMap.Simpleimutableentry.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
import java.util.AbstractMap;
importer java.util.HashSet;
importer java.util.Kart;
importer java.util.Sett;
klassepar
{
// Returner en kartoppføring (nøkkelverdipar) fra de angitte verdiene
offentlig statisk <T, U> Kart.Oppføring< T, U> av(t første, U andre)
{
returner ny AbstractMap.SimpleEntry< > (første, andre);
}
}
klasse Tuppel
{
// Implementer Parklasse I Java ved Hjelp Av Kart.Oppføring
offentlig statisk tomrom hoved (Streng args)
{
Sett< Kart.Oppføring< Streng, Heltall> > oppføringer = nytt HashSet<>();
oppføringer.legg til (Par.Av («Java», 50));
oppføringer.legg til (Par.av («C++», 30));
System.ut.println (oppføringer);
// kjører I Java 8 og over bare
oppføringer.foreach (oppføring -> {
hvis (oppføring.getKey ().er lik («Java»))
System.ut.println (oppføring.getValue());
});
}
}
|
Last Ned Kjør Kode
Utgang:
50
Java 8-javafx.util.Par
Til Slutt etter en lang ventetid, legges Et Par<K,V> klasse i Java 8 i javafx.util pakke. Klassen representerer nøkkelverdipar og støtter svært grunnleggende operasjoner som getKey(), getValue(), hashCode(), equals(java.lang.Objekt o) og toString () og har få metoder arvet fra java.lang.Objektklasse. Vel, noe er bedre enn ingenting, va?.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
import javafx.util.Pair;
import java.util.ArrayList;
import java.util.List;
Klasse Tuppel
{
// Demonstrere javafx.util.Par klasse introdusert I Java 8 og over
offentlig statisk void main (String args)
{
Liste< Par < Streng, Heltall> > oppføringer = ny ArrayList<>();
oppføringer.legg til (nytt Par< >(«C», 20));
oppføringer.legg til (nytt Par< >(«C++», 30));
// skriv ut første par ved hjelp av getKey() og getValue () – metoden
System.ut.println («{«+oppføringer.få (0).getKey() + «, » +
oppføringer.få (0).getValue ()+»}»);
// skriv ut andre par ved hjelp av getKey() og getValue () – metoden
System.ut.println («{«+oppføringer.få(1).getKey() + «, » +
oppføringer.få(1).getValue() + «}»);
}
}
|
Last Ned Kode
Utgang:
{C, 20}
{C++, 30}
Apache Commons Lang Library
Apache Commons Lang Library gir også Et Par <L, R> verktøyklasse hvis elementer er venstre og høyre. Det er definert som abstrakt og implementerer Kartet.Inngangsgrensesnitt hvor nøkkelen er igjen og verdien er riktig.
den har Par.av () metode som kan brukes til a oppna et uforanderlig par fra angitte par objekter. Dens underklasse MutablePair er foranderlig mens ImmutablePair er uforanderlig. Imidlertid er typen av objektet lagret I Uforanderligpair kan i seg selv være foranderlig.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
import org.apache.vanlig.lang3.tuple.ImmutablePair;
importer org.apache.vanlig.lang3.tuple.MutablePair;
importer org.apache.vanlig.lang3.tuple.Par;
importer java.util.ArrayList;
importer java.util.List;
Klasse Tuppel
{
// Demonstrere Par klasse gitt Apache Commons Bibliotek I Java
offentlig statisk tomrom main (Streng args)
{
Liste< Par < Streng, Heltall> > oppføringer = ny ArrayList<>();
oppføringer.legg til (ny MutablePair< >(«C», 20)); / / bruke MutablePair
oppføringer.legg til (ny ImmutablePair<>(«C++», 30)); // bruke ImmutablePair
oppføringer.legg til (Par.av («Java», 50)); / / ved Hjelp Av Par.av ()
System.ut.println (oppføringer);
// 1. first pair is mutable
Pair<String, Integer> pair = entries.get(0);
pair.setValue(100); // works fine
// printing pair using getKey() and getValue() method
System.out.println(pair.getKey() + «, » + pair.getValue());
// 2. second pair is immutable
pair = entries.get(1);
try {
pair.setValue(100); // runtime error
}
catch (UnsupportedOperationException ex) {
System.out.println(«UnsupportedOperationException thrown»);
}
// utskriftspar ved hjelp av getLeft() og getRight () – metoden
System.ut.println (par.getLeft ()+», » + par.getRight());
// 3. tredje par er også uforanderlig
par = oppføringer.få(2);
prøv {
par.setValue(100); / / kjøretidsfeil
}
fangst (UnsupportedOperationException ex) {
System.ut.println («UnsupportedOperationException kastet»);
}
System.ut.println (par.getLeft ()+», » + par.getRight());
}
}
|
Last Ned Kode
Utgang:
C, 100
UnsupportedOperationException kastet
C++, 30
UnsupportedOperationException kastet
Java, 50
JavaTuples Library
Javatuples er et annet kjent og enkelt java-bibliotek som omhandler tuples. Det gir et sett med tuple java klasser som spenner fra ett til ti elementer. For å tjene vårt formål, kan Vi bruke Par< a, B> klasse.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
import org.javatuples.Par;
importer java.util.ArrayList;
importer java.util.List;
Klasse Tuppel
{
// Demonstrere Par klasse gitt JavaTuples Bibliotek I Java
offentlig statisk tomrom main (Streng args)
{
Liste< Par<Streng, Heltall> > par = ny ArrayList<>();
par.legg til (Par.med («Java», 50)); / / ved Hjelp Av Par.med()
par.legg til (nytt Par<>(«C++», 30)); // ved hjelp av konstruktører
// skriv ut første par ved hjelp av getValue0 () og getValue1 () metode
System.ut.println («{«+par.få (0).getValue0() + «, » +
par.få (0).getValue1() + «}»);
// skriv ut andre par ved hjelp av getValue0() og getValue1 () – metoden
System.ut.println («{«+par.få(1).getValue0() + «, » +
par.få(1).getValue1() + «}»);
}
}
|
Last Ned Kode
Utgang:
{Java, 50}
{C++, 30}
Samlinger.singletonMap ()
En annen tilnærming er å bruke Samlinger.singletonMap () I Java som ligner På Kart.Oppføring< K,V > diskutert tidligere. Den returnerer et uforanderlig singleton-kart som bare inneholder den angitte nøkkelverdipar kartlegging, som kan behandles som Et Par.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
import java.util.Collections;
import java.util.HashSet;
import java.util.Map;
importer java.util.Sett;
klassepar
{
// Returner et uforanderlig singleton-kart som bare inneholder den angitte
// nøkkelverdipar kartlegging
offentlig statisk < T, U>Kart< T, U> av(t første, U andre)
{
retur Samlinger.singletonMap (første, andre);
}
}
klasse Tuppel
{
// Implementer Parklasse I Java ved Hjelp Av Samlinger.singletonMap ()
offentlig statisk tomrom hoved (Streng args)
{
Sett <Kart< Streng, Heltall> > oppføringer = nytt HashSet<>();
oppføringer.legg til (Par.Av («Java», 50));
oppføringer.legg til (Par.av («C++», 30));
System.ut.println (oppføringer);
}
}
|
Last Ned Kjør Kode
Utgang:
Til Slutt I Android-prosjekter kan vi bruke android.util.Pair klasse levert Av Android SDK.