ฉันชอบวิธีที่ Java มีแผนที่ซึ่งคุณสามารถกำหนดประเภทของแต่ละรายการในแผนที่ได้ <String, Integer>ได้

สิ่งที่ฉันกำลังมองหาคือประเภทของคอลเลกชันที่แต่ละองค์ประกอบในคอลเลกชันเป็นคู่ของค่า แต่ละค่าในคู่สามารถมีชนิดของตัวเอง (เช่นตัวอย่าง String และ Integer ด้านบน) ซึ่งกำหนดไว้ในเวลาที่ประกาศ

คอลเลกชันจะรักษาลำดับที่ได้รับและจะไม่ถือว่าหนึ่งในค่าเป็นคีย์เฉพาะ (เช่นในแผนที่)

เป็นหลักฉันต้องการกำหนดประเภทของ ARRAY <String,Integer>หรือ 2 ประเภทอื่น ๆ

ฉันรู้ว่าฉันสามารถสร้างคลาสได้โดยไม่ต้องใช้อะไรนอกจากตัวแปร 2 ตัวในนั้น แต่ดูเหมือนว่า verbose มากเกินไป

ฉันยังตระหนักว่าฉันสามารถใช้อาร์เรย์ 2 มิติ แต่เนื่องจากประเภทที่แตกต่างกันที่ฉันต้องการใช้ฉันจะต้องทำให้อาร์เรย์ของวัตถุนั้นและจากนั้นฉันจะต้องโยนตลอดเวลา

ฉันต้องการเก็บคู่ในคอลเลกชันเท่านั้นดังนั้นฉันจึงต้องการเพียงสองค่าต่อรายการ มีบางสิ่งเช่นนี้อยู่โดยไม่ต้องไปตามเส้นทางชั้นเรียนหรือไม่? ขอบคุณ!

คลาส Pair เป็นหนึ่งในตัวอย่างทั่วไป "gimme" ที่ง่ายพอที่จะเขียนด้วยตัวคุณเอง ตัวอย่างเช่นปิดส่วนหัวของฉัน:

public class Pair<L,R> {

  private final L left;
  private final R right;

  public Pair(L left, R right) {
    assert left != null;
    assert right != null;

    this.left = left;
    this.right = right;
  }

  public L getLeft() { return left; }
  public R getRight() { return right; }

  @Override
  public int hashCode() { return left.hashCode() ^ right.hashCode(); }

  @Override
  public boolean equals(Object o) {
    if (!(o instanceof Pair)) return false;
    Pair pairo = (Pair) o;
    return this.left.equals(pairo.getLeft()) &&
           this.right.equals(pairo.getRight());
  }

}

และใช่มันมีอยู่ในหลาย ๆ ที่บนเน็ตด้วยองศาที่สมบูรณ์และคุณสมบัติที่แตกต่างกัน (ตัวอย่างของฉันด้านบนมีจุดมุ่งหมายที่จะไม่เปลี่ยนรูป)

AbstractMap.SimpleEntry

ง่ายที่คุณกำลังมองหาสิ่งนี้:

java.util.List<java.util.Map.Entry<String,Integer>> pairList= new java.util.ArrayList<>();

คุณเติมได้อย่างไร?

java.util.Map.Entry<String,Integer> pair1=new java.util.AbstractMap.SimpleEntry<>("Not Unique key1",1);
java.util.Map.Entry<String,Integer> pair2=new java.util.AbstractMap.SimpleEntry<>("Not Unique key2",2);
pairList.add(pair1);
pairList.add(pair2);

สิ่งนี้ทำให้ง่ายต่อการ:

Entry<String,Integer> pair1=new SimpleEntry<>("Not Unique key1",1);
Entry<String,Integer> pair2=new SimpleEntry<>("Not Unique key2",2);
pairList.add(pair1);
pairList.add(pair2);

และด้วยความช่วยเหลือของcreateEntryวิธีการสามารถลด verbosity เพื่อ:

pairList.add(createEntry("Not Unique key1", 1));
pairList.add(createEntry("Not Unique key2", 2));

เนื่องจากArrayListไม่ใช่ขั้นตอนสุดท้ายจึงสามารถ subclassed เพื่อแสดงofวิธีการ (และcreateEntryวิธีการดังกล่าวข้างต้น) ทำให้เกิดข้อสรุปทางไวยากรณ์:

TupleList<java.util.Map.Entry<String,Integer>> pair = new TupleList<>();
pair.of("Not Unique key1", 1);
pair.of("Not Unique key2", 2);

Java 9+

ใน Java 9 คุณสามารถเขียน: Map.entry(key, value) เพื่อสร้างคู่ที่ไม่เปลี่ยนรูปได้

หมายเหตุ:วิธีนี้ไม่อนุญาตให้ใช้คีย์หรือค่าเป็นโมฆะ หากคุณต้องการที่จะให้ค่า null Map.entry(key, Optional.ofNullable(value))ตัวอย่างเช่นคุณต้องการที่จะเปลี่ยนนี้ไปที่:

Java 8+

ใน Java 8 คุณสามารถใช้วัตถุประสงค์ทั่วไปมากขึ้นjavafx.util.Pairเพื่อสร้างคู่ที่ไม่เปลี่ยนรูปแบบและไม่เปลี่ยนแปลง คลาสนี้อนุญาตให้ใช้คีย์ที่ไม่มีค่าและค่าว่าง (ใน Java 9 คลาสนี้รวมอยู่ในjavafx.baseโมดูล) แก้ไข: ตั้งแต่วันที่ Java 11, JavaFX ได้รับการแยกออกจาก JDK ดังนั้นคุณต้องมีสิ่งประดิษฐ์ maven เพิ่มเติม org.openjfx: javafx-base

Java 6+

ใน Java 6 และสูงกว่าคุณสามารถใช้ verbose เพิ่มเติมAbstractMap.SimpleImmutableEntryสำหรับคู่ที่ไม่เปลี่ยนรูปหรือAbstractMap.SimpleEntryสำหรับคู่ที่สามารถเปลี่ยนค่าได้ คลาสเหล่านี้ยังอนุญาตให้มีคีย์ Null และค่า Null และสามารถจัดลำดับได้

Android

หากคุณกำลังเขียนสำหรับ Android เพียงใช้Pair.create(key, value)เพื่อสร้างคู่ที่ไม่เปลี่ยนรูป

Apache Commons

Apache Commons Langให้ประโยชน์Pair.of(key, value)ในการสร้างคู่ที่ไม่เปลี่ยนรูปเทียบเคียงและเทียบเคียงได้

Eclipse Collections

หากคุณกำลังใช้คู่ที่มีการดึกดำบรรพ์Eclipse Collectionsมีคลาสการจับคู่แบบดั้งเดิมที่มีประสิทธิภาพมากซึ่งจะช่วยหลีกเลี่ยงการชกมวยอัตโนมัติที่ไม่มีประสิทธิภาพและการยกเลิกการทำกล่องอัตโนมัติ

ตัวอย่างเช่นคุณสามารถใช้PrimitiveTuples.pair(int, int)ในการสร้างIntIntPairหรือการสร้างPrimitiveTuples.pair(float, long)FloatLongPair

โครงการลอมบอก

การใช้โปรเจ็กต์ลอมบอกคุณสามารถสร้างคลาสคู่ที่ไม่เปลี่ยนรูปได้ง่ายๆโดยการเขียน:

@Value
public class Pair<K, V> {
    K key;
    V value;
}

ลอมบอกจะเติมในตัวสร้าง, getters ที่equals(), hashCode()และtoString()วิธีการให้คุณโดยอัตโนมัติใน bytecode สร้าง หากคุณต้องการวิธีการที่โรงงานคงแทนนวกรรมิกเช่นเป็นเพียงแค่เปลี่ยนคำอธิบายประกอบเพื่อ:Pair.of(k, v)@Value(staticConstructor = "of")

มิฉะนั้น

หากไม่มีวิธีแก้ไขปัญหาข้างต้นลอยเรือของคุณคุณสามารถคัดลอกและวางรหัสต่อไปนี้ (ซึ่งแตกต่างจากชั้นเรียนที่ระบุไว้ในคำตอบที่ได้รับการยอมรับป้องกัน NullPointerExceptions):

import java.util.Objects;

public class Pair<K, V> {

    public final K key;
    public final V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public boolean equals(Object o) {
        return o instanceof Pair && Objects.equals(key, ((Pair<?,?>)o).key) && Objects.equals(value, ((Pair<?,?>)o).value);
    }

    public int hashCode() {
        return 31 * Objects.hashCode(key) + Objects.hashCode(value);
    }

    public String toString() {
        return key + "=" + value;
    }
}

Map.Entry

คลาสในตัวเหล่านี้เป็นตัวเลือกด้วย ทั้งสองใช้Map.Entryอินเตอร์เฟส

• AbstractMap.SimpleEntry
• AbstractMap.SimpleImmutableEntry

Apache ทั่วไป lang3 มีคลาส Pair และไลบรารีอื่น ๆ อีกไม่กี่ที่กล่าวถึงในเธรดนี้ค่าเทียบเท่าของ C ++ Pair <L, R> ใน Java คืออะไร

ตัวอย่างที่ตรงกับความต้องการจากคำถามเดิมของคุณ:

List<Pair<String, Integer>> myPairs = new ArrayList<Pair<String, Integer>>();
myPairs.add(Pair.of("val1", 11));
myPairs.add(Pair.of("val2", 17));

//...

for(Pair<String, Integer> pair : myPairs) {
  //following two lines are equivalent... whichever is easier for you...
  System.out.println(pair.getLeft() + ": " + pair.getRight());
  System.out.println(pair.getKey() + ": " + pair.getValue());
}

ให้ทุกคนที่พัฒนาสำหรับ Android คุณสามารถใช้android.util.Pair :)

แล้วPairคลาส"Apache Commons Lang 3" และคลาสย่อยสัมพันธ์ล่ะ

    import org.apache.commons.lang3.tuple.ImmutablePair;
    import org.apache.commons.lang3.tuple.Pair;
    ...
    @SuppressWarnings("unchecked")
    Pair<String, Integer>[] arr = new ImmutablePair[]{
            ImmutablePair.of("A", 1),
            ImmutablePair.of("B", 2)};

    // both access the 'left' part
    String key = arr[0].getKey();
    String left = arr[0].getLeft();

    // both access the 'right' part
    Integer value = arr[0].getValue();
    Integer right = arr[0].getRight();

ImmutablePairเป็นคลาสย่อยเฉพาะที่ไม่อนุญาตให้ค่าในคู่ที่จะแก้ไข แต่มีการใช้งานอื่น ๆ ที่มีความหมายแตกต่างกัน นี่คือพิกัด Maven หากคุณต้องการ

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.4</version>
        </dependency>

คุณสามารถเขียนคลาสคู่ <A, B> และใช้สิ่งนี้ในอาร์เรย์หรือรายการ ใช่คุณต้องเขียนคลาส แต่คุณสามารถนำคลาสเดิมกลับมาใช้ใหม่ได้ทุกประเภทดังนั้นคุณต้องทำเพียงครั้งเดียว

การขยายคำตอบอื่น ๆ คู่ที่ไม่เปลี่ยนรูปแบบทั่วไปควรมีวิธีการแบบคงที่เพื่อหลีกเลี่ยงความยุ่งเหยิงโค้ดของคุณด้วยการเรียกไปยังตัวสร้าง:

class Pair<L,R> {
      final L left;
      final R right;

      public Pair(L left, R right) {
        this.left = left;
        this.right = right;
      }

      static <L,R> Pair<L,R> of(L left, R right){
          return new Pair<L,R>(left, right);
      }
}

หากคุณตั้งชื่อวิธีการคงที่ "ของ" หรือ "pairOf" รหัสจะคล่องแคล่วในขณะที่คุณสามารถเขียน:

    list.add(Pair.of(x,y)); // my preference
    list.add(pairOf(x,y)); // use with import static x.y.Pair.pairOf

มันเป็นความอัปยศจริง ๆ ที่ห้องสมุดหลักของจาวานั้นกระจัดกระจายอยู่ในสิ่งต่าง ๆ ที่คุณต้องใช้คอมมอนส์ - แลงหรือบุคคลที่สามอื่น ๆ เพื่อทำสิ่งพื้นฐาน อีกเหตุผลหนึ่งในการอัปเกรดเป็นสกาล่า ...

ฉันจะถามว่าคุณไม่ต้องการใช้List<Pair<T, U>>หรือไม่? แต่แน่นอน JDK ไม่มีคลาส Pair <> แต่อย่างรวดเร็ว Google พบว่าหนึ่งทั้งในวิกิพีเดียและforums.sun.com ไชโย

โซลูชันที่ต้องการตามที่คุณอธิบายไว้คือ List of Pairs (เช่น List)

ในการทำสิ่งนี้ให้สำเร็จคุณจะสร้างคลาส Pair สำหรับใช้ในคอลเลกชันของคุณ นี่คือคลาสยูทิลิตี้ที่มีประโยชน์ในการเพิ่มรหัสฐานของคุณ

คลาสที่ใกล้เคียงที่สุดใน Sun JDK ที่มีฟังก์ชันการทำงานคล้ายกับคลาส Pair ทั่วไปคือ AbstractMap.SimpleEntry คุณสามารถใช้คลาสนี้แทนการสร้างคลาส Pair ของคุณเองแม้ว่าคุณจะต้องใช้ชีวิตด้วยข้อ จำกัด ที่น่าอึดอัดใจและฉันคิดว่าคนส่วนใหญ่จะขมวดคิ้วในเรื่องนี้เพราะไม่ใช่บทบาทที่แท้จริงของ SimpleEntry ตัวอย่างเช่น SimpleEntry ไม่มีเมธอด "setKey ()" และไม่มีคอนสตรัคเตอร์เริ่มต้นดังนั้นคุณอาจพบว่ามัน จำกัด เกินไป

โปรดทราบว่าคอลเล็กชันได้รับการออกแบบให้มีองค์ประกอบประเภทเดียว อินเตอร์เฟสยูทิลิตี้ที่เกี่ยวข้องเช่น Map ไม่ใช่คอลเล็กชันจริง (เช่น Map ไม่ได้ใช้อินเตอร์เฟสการรวบรวม) Pair จะไม่ใช้อินเตอร์เฟสการรวบรวม แต่เห็นได้ชัดว่าเป็นคลาสที่มีประโยชน์ในการสร้างโครงสร้างข้อมูลขนาดใหญ่

สิ่งนี้เป็นไปตามโค้ดของ JavaHelp4u

แสดงรายละเอียดน้อยลงและแสดงวิธีการในหนึ่งบรรทัดและวิธีวนรอบสิ่งต่าง ๆ

//======>  Imports
import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;

//======>  Single Entry
SimpleEntry<String, String> myEntry = new SimpleEntry<String, String>("ID", "Text");
System.out.println("key: " + myEntry.getKey() + "    value:" + myEntry.getValue());
System.out.println();

//======>  List of Entries
List<Entry<String,String>> pairList = new ArrayList<>();

//-- Specify manually
Entry<String,String> firstButton = new SimpleEntry<String, String>("Red ", "Way out");
pairList.add(firstButton);

//-- one liner:
pairList.add(new SimpleEntry<String,String>("Gray", "Alternate route"));  //Ananomous add.

//-- Iterate over Entry array:
for (Entry<String, String> entr : pairList) {
    System.out.println("Button: " + entr.getKey() + "    Label: " + entr.getValue());
}

Apache CrunchมีPairคลาสด้วย: http://crunch.apache.org/apidocs/0.5.0/org/apache/crunch/Pair.html

เพียงแค่สร้างคลาสเช่น

class tuples 
{ 
int x;
int y;
} 

จากนั้นสร้างรายการของวัตถุของสิ่งอันดับ

List<tuples> list = new ArrayList<tuples>();

เพื่อให้คุณสามารถใช้โครงสร้างข้อมูลใหม่อื่น ๆ ในลักษณะเดียวกัน

ฉันหมายถึงแม้ว่าจะไม่มีPairคลาสใน Java แต่ก็มีบางอย่างที่ค่อนข้างคล้ายกัน:Map.Entry

Map.Entry Documentation

นี่คือ (ลดความซับซ้อนเล็กน้อย) สิ่งที่HashMapจริงหรือMapร้านค้าใด ๆ

คุณสามารถสร้างอินสแตนซ์ของการMapจัดเก็บค่าของคุณในนั้นและรับชุดรายการ คุณจะจบลงด้วยการSet<Map.Entry<K,V>>ที่มีประสิทธิภาพเป็นสิ่งที่คุณต้องการ

ดังนั้น:

public static void main(String []args)
{    
    HashMap<String, Integer> values = new HashMap<String,Integer>();
    values.put("A", 235);//your custom data, the types may be different
    //more data insertions....
    Set<Map.Entry<String,Integer>> list = values.entrySet();//your list 
    //do as you may with it
}

Spring มีPair<S,T>ประเภทในแพ็คเกจ Data Utilsorg.springframework.data.util

Pair<String,Integer> pair = Pair.of("Test", 123);
System.out.println(pair.getFirst());
System.out.println(pair.getSecond());

สิ่งที่เกี่ยวกับ com.sun.tools.javac.util.Pair?

สิ่งแรกที่ฉันนึกเมื่อพูดถึงคู่คีย์ / ค่าคือคลาสคุณสมบัติที่คุณสามารถบันทึกและโหลดรายการไปยังสตรีม / ไฟล์

ใน Project Reactor (io.projectreactor: reactor-core) มีการรองรับขั้นสูงสำหรับ n-Tuples:

Tuple2<String, Integer> t = Tuples.of("string", 1)

ที่นั่นคุณสามารถได้รับt.getT1(), t.getT2(), ...โดยเฉพาะกับ Stream หรือ Flux คุณสามารถแมปองค์ประกอบ tuple:

Stream<Tuple2<String, Integer>> s;
s.map(t -> t.mapT2(i -> i + 2));