जावा में जोड़े की सरणी कैसे स्टोर करें?

Question

मैं जावा के लिए नया हूं, मैं युगल की जोड़ी की एक सरणी स्टोर करना चाहता हूं।

import java.util.ArrayList; 
import java.util.Map.Entry; 

List<Entry<Double, Double>> values = new ArrayList<>(); 
Entry<Double, Double> pair; 
// set pair values: 
// pair.setKey(0.5); // this method does not exists 
// pair.setValue(3.6); 
values.add(pair); 

मैं जोड़ी चर कैसे प्रारंभ कर सकते हैं: मेरे कोड इस तरह दिखता है? क्या युगल की जोड़ी की मेरी सरणी को स्टोर करने के लिए एक बेहतर संरचना है?

Answer 1

अपनी खुद की कक्षा बनाएं एक जोड़ी का प्रतिनिधित्व करने और एक निर्माता है कि दो तर्क लेता जोड़ें: What is the equivalent of the C++ Pair<L,R> in Java?

Answer 2

आप इस्तेमाल कर सकते हैं:

public class MyPair 
{ 
    private final Double key; 
    private final Double value; 

    public MyPair(Double aKey, Double aValue) 
    { 
     key = aKey; 
     value = aValue; 
    } 

    public Double key() { return key; } 
    public Double value() { return value; } 
} 

कारण एक Pair जावा में मौजूद नहीं है के लिए इस उत्तर देखें इसे हल करने के लिए एक नक्शा।

Answer 3

Entry एक कक्षा है जिसे आपने परिभाषित किया है? आप new के साथ इसे तुरंत चालू करें।

Entry<Double, Double> pair = new Entry<Double, Double>(d1, d2); 

नोट मैं तुम्हें एक निर्माता है कि 2 युगल लेता परिभाषित संभालने रहा हूँ, और आप d1 और d2 के लिए संदर्भ की है।

मेरा सुझाव है कि आप Map.Entry कक्षा का उपयोग न करें। उस वर्ग के लिए अर्थशास्त्र इस प्रकार हैं कि मान एक कुंजी और मूल्य हैं, जो मैप्स के काम के तरीके के साथ उपयुक्त हैं।

Answer 4

यदि आपके पास एंट्री क्लास तक पहुंच है, तो आप एक कन्स्ट्रक्टर बना सकते हैं जो पैरामीटर के रूप में कुंजी और मान लेता है।

Entry<Double, Double> pair = new Entry<Double, Double>(0.5, 3.6); 
values.add(pair); 

Answer 5

Map.Entry प्रकार है कि आप उपयोग करना चाहते हैं तो बस एक इंटरफेस है, और इसलिए instantiated नहीं किया जा सकता है। यदि आप आंतरिक प्रकार के Map का उपयोग करना चाहते हैं, तो कंक्रीट Map.Entry कार्यान्वयन HashEntry एक विकल्प होगा।

हालांकि यह आपके खुद के जोड़ी प्रकार को लागू करने के लिए एक बेहतर विचार है। या यदि आपको उपयुक्त सूट की आवश्यकता है तो सरणी के बजाय मानचित्र का उपयोग करें।

Answer 6

आप प्रवेश का उपयोग नहीं करना चाहते हैं यह एक इंटरफेस है, क्लास नहीं। उस इंटरफ़ेस का उपयोग सेट के कार्यान्वयन द्वारा किया जाता है जब आप एंटसेटसेट() को उस क्लास पर कॉल करते हैं जो मानचित्र लागू करता है। यह मूल रूप से आपको लागू मानचित्र में हेरफेर करने देता है जैसे कि यह एक सेट था।

आप क्या करेंगे (लेकिन नहीं कर सकते) यह है। यदि आप ऐसा करने का प्रयास करते हैं तो आपको "Map.Entry टाइप प्रकार को तत्काल नहीं कर सकता" के साथ एक कंपाइलर त्रुटि दिखाई देगी। ऐसा इसलिए है क्योंकि Map.Entry एक इंटरफ़ेस है, कक्षा नहीं। एक इंटरफ़ेस में कोई वास्तविक कोड नहीं होता है, इसलिए यहां चलाने के लिए कोई वास्तविक निर्माता नहीं है।

Entry<Double, Double> pair = new Entry<Double, Double>(); 

आप नीचे दिए गए डॉक्स आप स्पष्ट रूप से शीर्ष कि यह एक "इंटरफेस Map.Entry" है जो इसे एक इंटरफेस का मतलब पर देख सकते हैं देखें। http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Map.Entry.html

इंटरफ़ेस को तुरंत चालू करने की कोशिश करने के बजाय आपको क्या करना चाहिए, जो असंभव है, जो आपकी खुद की कक्षा को जोड़े कहा जाता है। कुछ इस तरह। यदि आप नीचे दिए गए कोड का उपयोग करते हैं तो पैकेज को बदलना याद रखें।

package org.mike.test; 

public class Pair { 
    private double x = 0.0; 
    private double y = 0.0; 

    public Pair(double x, double y) 
    { 
     this.x = x; 
     this.y = y; 
    } 

    public Pair() 
    { 

    } 

    public double getX() { 
     return x; 
    } 

    public void setX(double x) { 
     this.x = x; 
    } 

    public double getY() { 
     return y; 
    } 

    public void setY(double y) { 
     this.y = y; 
    } 


} 

अपने जोड़ी वर्ग लिखने के बाद अपने कोड अब इस तरह दिखेगा।

package org.mike.test; 

import java.util.ArrayList; 
import org.mike.test.Pair; //You don't need this if the Pair class is in the same package as the class using it 

public class tester { 

    /** 
    * @param args 
    */ 
    public static void main(String[] args) { 
     ArrayList<Pair> values = new ArrayList<Pair>(); 
     Pair pair = new Pair(); 
     // set pair values: 
     pair.setY(3.6); 
     pair.setX(3.6); 
     values.add(pair); 
    } 

} 

Answer 7

एक और दृष्टिकोण है, और शायद सबसे कारगर तरीका स्टोर और डबल जोड़े की सरणी को युगल की एक सारिणी का उपयोग करने के लिए, और प्रयोग (2 * i) और है (2 * मैं +1) अपने अनुक्रमण के रूप में योजना। इसके अतिरिक्त आप लाभ प्राप्त करते हैं कि जब आप इसे बनाते हैं तो सरणी को सभी 0s में प्रारंभ किया जाएगा, कोई अतिरिक्त कदम आवश्यक नहीं है। दुर्भाग्य से ऐड() को हटाने और हटाने() को लागू करने के लिए थोड़ा अतिरिक्त कोडिंग ओवरहेड है, लेकिन आश्चर्य की बात यह है कि यह जोड़ी के लिए अपना कंटेनर क्लास बनाने से शायद कम है।

class MyClass { 
    double[] values; 
    int count; 

    MyClass(int initialCapacity) { 
     values = new double[initialCapacity*2]; 
    } 

    // adding a pair 
    void addPair(double x, double y) { 
     if (count*2 >= values.length) { 
      values = Arrays.copyOf(values, values.length*2); 
     } 
     values[count*2] = x; 
     values[count*2 + 1] = y; 
     count++; 
    } 

    void remove(int index) { 
     if (index >= count) throw new IndexOutOfBoundsException(); 

     if (index < --count) { 
      System.arraycopy(values, (index+1)*2, values, index*2, (count - index) * 2); 
     } 
    } 

    int size() { return count; } 

    // both these should check that index < count. 
    double getX(int index) { return values[index*2]; } 
    double getY(int index) { return values[index*2 + 1]; } 

    void exampleIteration() { 
     // getX/Y accessors are examples of how to get 
     // the values, but it will be more efficient 
     // in most cases to just access the array 
     // array directly as so... 
     for (int i=0 ; i<count ; ++i) { 
      System.out.printf("%d: (%f,%f)%n", i, values[i*2], values[i*2+1]); 
     } 
    } 
} 

Answer 8

तुम सिर्फ

public class MyClass<A,B> extends ArrayList{ 
private A first; 
private B second; 
public MyClass(A first, B second){ 
super(); 
this.first = first; 
this.second = second;} 
} 

का उपयोग नहीं किया जा सका और फिर ऐड विधि के कुछ फार्म जोड़ने के एक पहले और दूसरे एक्सेसर & mutator विधि के साथ? मैं प्रोग्रामिंग के लिए नया हूं, लेकिन इस तरह ऐसा लगता है कि यह काम कर सकता है, और केवल डबल के अलावा अन्य चीजों के लिए सुलभ हो सकता है, (जिस सड़क पर आप अन्य प्रकारों का उपयोग करना चाहते हैं, जैसे इंटीजर, या यहां तक ​​कि स्ट्रिंग) ।