viisi vaihtoehtoa Pariluokalle Javassa
pari on säiliö, johon voi tallentaa kahden esineen Kopan. Java ei oikeastaan tarjoa mitään toteutusta Pariluokasta. Tässä viestissä, keskustelemme eri vaihtoehtoja pari luokan Java.
parista on usein hyötyä seurata kahta kohdetta yhdessä. Se sisältää kaksi kenttää, joita yleensä kutsutaan ensimmäiseksi ja toiseksi, jotka kykenevät tallentamaan mitä tahansa. Huolimatta siitä, että ensimmäisen ja toisen kentän välillä ei ole mitään mielekästä suhdetta, ohjelmoijat usein kaipaavat tätä toimintoa Javassa.
edellisessä postauksessa on pohdittu, miten oma Pariluokka toteutettaisiin Jaavalla. Tässä viestissä käsitellään Java-kielellä saatavilla olevia työreittejä halutun aukon täyttämiseksi, kuten alla on käsitelty:
kartta.Merkintä<K, V> liittymä
Voimme käyttää karttaa.Merkintä<K, V> liitäntä Java, joka on samanlainen kuin std:: pair C++. Se on erinomainen esimerkki merkityksellisestä nimestä, joka edustaa avainarvoparia.
luodakseen tietueen, joka edustaa kartoitusta määritetystä avaimesta määritettyyn arvoon, Java tarjoaa kartan kaksi konkreettista toteutusta.Syöttöliittymä, nimittäin AbstractMap.SimpleEntry ja AbstractMap.Yksinkertaisesti helppo laskeutua.
|
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;
tuo java.util.HashSet;
tuo java.util.Kartta;
tuo java.util.Sarja;
luokkapari
{
// Palauta karttamerkintä (avainarvopari) annetuista arvoista
public static <T, U> Map.Merkintä<T, U> of (t first, U second)
{
palauta Uusi Abstraktikartta.Simpeleentry<>(ensimmäinen, toinen);
}
}
Luokka Tuple
{
// toteuta Pariluokka Javassa kartan avulla.Merkintä
public static void main (String args)
{
Aseta< kartta.Entry<String, Integer>> entries = new HashSet<>();
merkinnät.add (pari.of (”Jaava”, 50));
merkinnät.add (pari.of (”C++”, 30));
järjestelmä.ulos.println(merkinnät);
// toimii Java 8: ssa ja sen yläpuolella vain
merkinnät.forEach(täsmennyssivu -> {
if (engl.getKey ().equals (”Java”))
System.ulos.println(täsmennyssivugetValue());
});
}
}
|
Lataa Ajokoodi
tuloste:
50
Java 8-javafx.util.Pari
lopulta pitkän odotuksen jälkeen lisätään pari<K, V> Luokka Java 8: ssa javafx: ssä.util-paketti. Luokka edustaa avainarvopareja ja tukee hyvin perusoperaatioita, kuten getKey(), getValue(), hashCode (), equals (java.lang.Object o) ja toString () ja sillä on muutamia javalta periytyviä menetelmiä.lang.Objektiluokka. Jokin on parempi kuin ei mitään..
|
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;
Luokka Tuple
{
// Esittele javafx.util.Pariluokka käyttöön Java 8: ssa ja sitä korkeammalla
public staattinen void main(String args)
{
luettelo<pari<merkkijono, kokonaisluku>> merkinnät = uusi Arraylisti<>();
merkinnät.add (uusi pari<>(”C”, 20));
merkinnät.add (uusi pari<>(”C++”, 30));
// tulosta ensimmäinen pari käyttäen getkey () – ja getValue () – menetelmää
järjestelmällä.ulos.println (”{”+ merkinnät.get (0).getKey() + ”, ” +
merkinnät.get (0).getValue ()+”}”);
/ / tulosta toinen pari käyttäen getKey () – ja getValue () – menetelmää
– järjestelmää.ulos.println (”{”+ merkinnät.get (1).getKey() + ”, ” +
merkinnät.get (1).getValue() + ”}”);
}
}
|
latauskoodi
Lähtö:
{C, 20}
{C++, 30}
Apache Commons Lang Library
Apache Commons Lang Library tarjoaa myös parin<L,r> utility class, jonka elementit ovat vasen ja oikea. Se on määritelty abstraktiksi ja toteuttaa kartan.Syöttöliittymä, jossa avain on vasemmalla ja arvo on oikea.
sillä on pari.of () menetelmä, jota voidaan käyttää saada muuttumaton pari alkaen määritetyn pari esineitä. Sen alaluokka MutablePair on mutable, kun taas muuttumaton Air on muuttumaton. Muuttumattomaan ilmaan tallennetun esineen tyyppi voi kuitenkin itsessään olla muuntuva.
|
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
|
tuo org.apassit.yhteinen.lang3.tuple.ImmutablePair;
import org.apassit.yhteinen.lang3.tuple.MutablePair;
import org.apassit.yhteinen.lang3.tuple.Pari;
tuo java.util.ArrayList;
tuo java.util.Luettelo;
Luokka Tuple
{
// demonstroi Pariluokka edellyttäen Apache Commons-kirjastoa Java-kielellä
public static void main (String args)
{
luettelo<pari<merkkijono, kokonaisluku>> merkinnät = uusi Arraylisti<>();
merkinnät.add(new MutablePair<>(”C”, 20)); // käyttäen MutablePair
merkinnät.add(new ImmutablePair<>(”C++”, 30)); // using ImmutablePair
entries.add (pari.of (”Java”, 50)); // käyttäen paria.of ()
systeemi.ulos.println(merkinnät);
// 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”);
}
// painopari käyttäen getLeft () – ja getRight () – menetelmää
– systeemiä.ulos.println(pari.getLeft ()+”, ” + pari.getRight());
// 3. kolmas pari on myös muuttumaton
pari = merkinnät.Hae(2);
kokeile {
paria.setValue (100); / / ajonaikavirhe
}
catch (UnsupportedOperationException ex) {
System.ulos.println (”UnsupportedOperationException throught”);
}
järjestelmä.ulos.println(pari.getLeft ()+”, ” + pari.getRight());
}
}
|
latauskoodi
Lähtö:
C, 100
UnsupportedOperationException threaded
C++, 30
Unsupportedoperation Exception threaded
Java, 50
Javatuplesin kirjasto
Javatuples on toinen kuuluisa ja yksinkertainen Java-kirjasto, joka käsittelee tupleja. Se tarjoaa joukon tuple java-luokkia, jotka vaihtelevat yhdestä kymmeneen elementtiin. Tarkoituksemme täyttämiseksi voidaan käyttää paria<A, B> luokkaa.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
tuo org.javatuples.Pari;
tuo java.util.ArrayList;
tuo java.util.Luettelo;
Luokka Tuple
{
// demonstroi Pariluokka edellyttäen, että Javatuples-kirjasto Java-kielellä
public static void main (String args)
{
luettelo<pari<merkkijono, kokonaisluku>> parit = Uusi Arraylisti<>();
pareja.add (pari.kanssa (”Java”, 50)); // käyttäen paria.kanssa ()
paria.lisää(uusi pari<>(”C++”, 30)); // käyttäen konstruktoreita
// tulosta ensimmäinen pari käyttäen getValue0() ja getValue1() menetelmää
systeemiä.ulos.println (”{”+ parit.get (0).getValue0() + ”, ” +
pareja.get (0).getvalue1color() + ”}”);
// tulosta toinen pari käyttäen getValue0() ja getValue1 () menetelmää
järjestelmällä.ulos.println (”{”+ parit.get (1).getValue0() + ”, ” +
pareja.get (1).getvalue1color() + ”}”);
}
}
|
latauskoodi
Lähtö:
{Java, 50}
{C++, 30}
kokoelmat.singletonMap ()
toinen lähestymistapa on käyttää kokoelmia.singletonMap () Jaavalla, joka muistuttaa karttaa.Merkintä<K, V> käsitelty aiemmin. Se palauttaa muuttumattoman singleton-kartan, joka sisältää vain määritetyn avainarvoparin kartoituksen, jota voidaan käsitellä parina.
|
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;
tuo java.util.Sarja;
luokkapari
{
// Return an immutable singleton map containing only the specified
/ / key-value pair mapping
public static <T, U> Map<T, U> of (t first, U second)
{
palauta kokoelmat.singletonMap(ensimmäinen, toinen);
}
}
Luokka Tuple
{
// toteuta Pariluokka Javassa kokoelmien avulla.singletonMap ()
public staattinen void main(String args)
{
Set<kartta<merkkijono, kokonaisluku>> merkinnät = uusi HashSet<>();
merkinnät.add (pari.of (”Jaava”, 50));
merkinnät.add (pari.of (”C++”, 30));
järjestelmä.ulos.println(merkinnät);
}
}
|
Lataa Ajokoodi
tuloste:
lopuksi Android-projekteissa voimme käyttää Androidia.util.Pariluokka tarjoaa Android SDK.