fem alternativer til par klasse i Java
et par er en beholder til at gemme en tupel af to objekter. Java giver ikke rigtig nogen implementering af Parklassen. I dette indlæg vil vi diskutere om forskellige alternativer til at parre klasse i Java.
par er ofte nyttigt at spore to objekter sammen. Den indeholder to felter, normalt betegnet som første og anden, der er i stand til at lagre noget. På trods af ikke at have noget meningsfuldt forhold mellem det første og andet felt, savner programmører ofte denne funktionalitet i Java.
i det forrige indlæg har vi diskuteret, hvordan vi implementerer vores egen Parklasse i Java. I dette indlæg vil vi diskutere løsninger, der er tilgængelige i Java for at udfylde det ønskede hul, som diskuteret nedenfor:
kort.Indgang< K,V> Interface
vi kan bruge kort.Indgang< K,V> interface i Java, der ligner std::par i C++. Det er et glimrende eksempel på at have et meningsfuldt navn, der repræsenterer et nøgleværdipar.
for at oprette en post, der repræsenterer en kortlægning fra den angivne nøgle til den angivne værdi, giver Java to konkrete implementeringer af kortet.Indgangsgrænseflade, nemlig AbstractMap.SimpleEntry og AbstractMap.SimpleImmutableEntry.
|
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;
import java.util.HashSet;
import java.util.Kort;
import java.util.Sæt;
klassepar
{
// returner en kortpost (nøgleværdipar) fra de angivne værdier
offentlig statisk <T, U> kort.Indgang<T, U > af (T første, U anden)
{
returner nyt AbstractMap.SimpleEntry< >(første, anden);
}
}
klasse Tuple
{
// Gennemfør par klasse i Java ved hjælp af kort.Indgang
offentlig statisk void main (String args)
{
sæt < kort.Indgang< streng, heltal>> poster = nyt HashSet<>();
indlæg.Tilføj (par.af (“Java”, 50));
indlæg.Tilføj (par.af (“C++”, 30));
System.uden.println (poster);
// kører kun i Java 8 og derover
poster.forEach (indgang -> {
hvis (indgang.getKey ().lig (“Java”))
System.uden.println (indgang.getValue());
});
}
}
|
Hent Kør kode
udgang:
50
Java 8-Java.util.Par
endelig efter en lang ventetid tilføjes et par< K, V > klasse i Java 8 i javaf.util pakke. Klassen repræsenterer nøgleværdipar og understøtter meget grundlæggende operationer som gekey(), getValue(), hashCode(), lig med(java.lang.Objekt o) og toString () og har få metoder arvet fra java.lang.Objekt klasse. Noget er bedre end ingenting, ikke?.
|
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 Tuple
{
// demonstrere javafks.util.Par klasse introduceret i Java 8 og derover
offentlig statisk void main(String args)
{
liste< par< streng, heltal>> poster = ny ArrayList<>();
indlæg.Tilføj (nyt par< >(“C”, 20));
indlæg.Tilføj (nyt par< >(“C++”, 30));
// Udskriv første par ved hjælp af gekey() og getValue () metode
System.uden.println (“{“+poster.få (0).getKey() + “, ” +
indlæg.få (0).getValue ()+”}”);
/ / Udskriv andet par ved hjælp af gekey() og getValue() metode
System.uden.println (“{“+poster.få (1).getKey() + “, ” +
indlæg.få (1).getValue() + “}”);
}
}
|
Hent kode
udgang:
{C, 20}
{C++, 30}
Apache Commons Lang Bibliotek
Apache Commons Lang bibliotek giver også et par< L,R > utility klasse, hvis elementer er venstre og højre. Det er defineret som abstrakt og implementerer kortet.Indgangsgrænseflade, hvor nøglen er tilbage, og værdien er rigtig.
det har Par.af () metode, der kan bruges til at opnå et uforanderligt par fra specificerede par objekter. Dens underklasse MutablePair er mutable mens ImmutablePair er uforanderlig. Men typen af objektet gemt i Uforanderligtpar kan i sig 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.fælles.lang3.tupel.Uforanderlig par;
import org.apache.fælles.lang3.tupel.MutablePair;
import org.apache.fælles.lang3.tupel.Par;
import java.util.ArrayList;
import java.util.Liste;
klasse Tuple
{
// demonstrere par klasse forudsat Apache Commons bibliotek i Java
offentlig statisk void main (String args)
{
liste< par< streng, heltal>> poster = ny ArrayList<>();
indlæg.tilføje (ny MutablePair<> (“C”, 20)); // brug af MutablePair
poster.Tilføj (ny ImmutablePair<> (“C++”, 30)); // brug af ImmutablePair
poster.Tilføj (par.af (“Java”, 50)); // brug af par.af ()
System.uden.println (poster);
// 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”);
}
// udskrivning par ved hjælp af getLeft() og getRight () metode
System.uden.println (par.getLeft ()+”, ” + par.getRight());
// 3. tredje par er også uforanderligt
par = poster.få(2);
prøv {
par.setValue (100); // runtime fejl
}
fangst (ikke understøttet Driftundtagelse eks) {
System.uden.println (“ikke-Understøttetoperationundtagelse kastet”);
}
System.uden.println (par.getLeft ()+”, ” + par.getRight());
}
}
|
Hent kode
udgang:
C, 100
ikke-Understøttetoperationundtagelse kastet
C++, 30
ikke-Understøttetoperationundtagelse kastet
Java, 50
JavaTuples Library
Javatuples er et andet berømt og simpelt java-bibliotek, der beskæftiger sig med tupler. Det giver et sæt tuple java-klasser, der spænder fra et til ti elementer. For at tjene vores formål kan vi bruge 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;
import java.util.ArrayList;
import java.util.Liste;
klasse Tuple
{
// demonstrere par klasse forudsat JavaTuples bibliotek i Java
offentlig statisk void main (String args)
{
liste< par< streng, heltal> > par = ny ArrayList<>();
par.Tilføj (par.med (“Java”, 50)); // brug af par.med ()
par.Tilføj (nyt par<> (“C++”, 30)); // brug af konstruktører
/ / Udskriv første par ved hjælp af getValue0() og getValue1() metode
System.uden.println (“{“+par.få (0).getValue0() + “, ” +
par.få (0).getValue1() + “}”);
// Udskriv andet par ved hjælp af getValue0() og getValue1 () metode
System.uden.println (“{“+par.få (1).getValue0() + “, ” +
par.få (1).getValue1() + “}”);
}
}
|
Hent kode
udgang:
{Java, 50}
{C++, 30}
samlinger.singletonMap ()
en anden tilgang er at bruge samlinger.singletonMap () i Java, der ligner kort.Indgang< K,V> diskuteret tidligere. Det returnerer en uforanderlig singleton kort indeholder kun den angivne nøgle-værdi par kortlægning, 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;
import java.util.Sæt;
klassepar
{
// returner et uforanderligt singleton-kort, der kun indeholder det angivne
// nøgleværdi par kortlægning
offentlig statisk < T, U>kort< T, U> af(T første, u anden)
{
retur samlinger.singletonMap (første, anden);
}
}
klasse Tuple
{
// Gennemfør par klasse i Java ved hjælp af samlinger.singletonMap ()
offentlig statisk void main (String args)
{
sæt<kort< streng, heltal> > poster = nyt HashSet<>();
indlæg.Tilføj (par.af (“Java”, 50));
indlæg.Tilføj (par.af (“C++”, 30));
System.uden.println (poster);
}
}
|
Hent Kør kode
udgang:
endelig i Android-projekter kan vi bruge android.util.Par klasse leveret af Android SDK.