किसी भी इसी तरह मूल्य

Question

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

परिदृश्य # 1:2 दोनों सरणियों में पाया जाता है, तो परिणाम true है।

String[] x = {"1","2","3"}; 
String[] y = {"2","5","6"}; 

परिदृश्य # 2: कोई मिलती-जुलती मूल्य है, तो परिणाम false है।

String[] x = {"1","2","3"}; 
String[] y = {"4","5","6"}; 

क्या जावा में कोई अंतर्निहित विधि है, या कोई पुस्तकालय जो इस आवश्यकता को संभाल सकता है?

मैं जोर देना है कि मैं एक जावा पुस्तकालय या किसी भी जावा विधि है कि बॉक्स से बाहर ऐसा कर सकते हैं रहा हूँ चाहते हैं।

Collection.contains एक विकल्प है क्योंकि दोनों सरणियों में सभी मान आदेश सही वापस जाने के लिए एक समान होनी चाहिए नहीं है। (मैं अगर कम से कम एक मूल्य दोनों सरणियों में समान है सच लौटने के लिए की जरूरत है)

Answer 1

आप java.util.Set उपयोग कर सकते हैं, उदाहरण के लिए इस के लिए HashSet:

1. अगर सेट y

http://docs.oracle.com/javase/8/docs/api/java/util/Set.html

http://docs.oracle.com/javase/8/docs/api/java/util/HashSet.html

Answer 2

इस से किसी भी तत्व शामिल हैं सम्मिलित x से सभी तत्वों सेट

उपयोग Set#contains(Object) में जाँच करने के लिए मदद हो सकती है। सच लौटने के लिए मुद्रण बयान बदलें; अगर तुम चाहते हो।

for (int i = 0; i < x.length; i++) { 
    for (int j = 0; j < y.length; j++) { 
     if (x[i].equals(y[j])) { 
      System.out.println(x[i] + " is equal to " + y[j]); 
     } 
    } 
} 

Answer 3

ऐसा लगता है कि आप सरणी के साथ खेल रहे हैं, इसलिए मैं यहां किसी भी जादू कक्षाओं का उपयोग नहीं कर रहा हूं। सिर्फ शुद्ध सरणियों के साथ, आप

public boolean checkArrayEquals() { 
    String[] x = { "1", "2", "3" }; 
    String[] y = { "2", "5", "6" }; 
    for (int i = 0; i < x.length; i++) { 
     String xval = x[i]; 
     for (int j = 0; j < y.length; j++) { 
      if (xval.equals(y[j])) { 
       return true; 
      } 
     } 
    } 
    return false; 
} 

Answer 4

कर सकते हैं विधि में एक निर्मित वहाँ नहीं है, लेकिन आप अपने खुद के उपयोगिता विधि है कि एक Set का उपयोग करें और मिलानों को खोजेगी लिख सकते हैं।

private boolean sharesAnElement(String[] a, String[] b) { 
    Set<String> bSet = new HashSet<>(Arrays.asList(b)); 

    for (String str : a) { 
     if (bSet.contains(str)) { 
      return true; 
     } 
    } 

    return false; 
} 

Answer 5

समाधान क्या आप सरणी 1 मान को पुन: सक्रिय कर सकते हैं और प्रत्येक तत्व के साथ दूसरी सरणी में खोज सकते हैं।

public static void compareArrays(String[] array1, String[] array2) { 
    boolean b = false; 

    for(String str1 : array1){ 
     for(String str2 : array2){ 
      if(str1 == str1){ 
       b = true; 
       break; 
      } 
     } 
    } 
    System.out.println(b); 
} 

---

पूरा कोड:

public class HelloWorld{ 

    public static void main(String []args){ 
     String[] x = {"1","2","3"}; 
     String[] y = {"3","5","6"}; 
     compareArrays(x, y); 
    } 

    public static void compareArrays(String[] array1, String[] array2) { 
     boolean b = false; 

     for(String str1 : array1){ 
      for(String str2 : array2){ 
       if(str1 == str1){ 
        b = true; 
        break; 
       } 
      } 
     } 
     System.out.println(b); 
    } 
} 

Answer 6

आप उस के लिए Collections#disjoint उपयोग कर सकते हैं,

रिटर्न सच अगर दो निर्दिष्ट संग्रह आम में कोई तत्व है।

...

ध्यान दें कि दोनों पैरामीटर में एक ही संग्रह को पारित करने की अनुमति है, इस मामले में विधि केवल तभी वापस आ जाएगी जब संग्रह खाली हो।

boolean isNoCommonElements = Collections.disjoint(
             Arrays.asList(x), Arrays.asList(y)); 

Answer 7

यह एक नहीं बल्कि विशिष्ट जरूरत है और मुझे नहीं लगता है कि लोकप्रिय संग्रह पुस्तकालयों के किसी भी है कि के लिए एक विशेष कार्य है है। आप कर सकता है:

Collection<String> set = new HashSet<String>(Arrays.asList(x)); 
boolean result = false; 
for (String str: y) { 
    result |= set.contains(str); 
} 

कौन सा हे (एन) के बजाय दोनों सरणियों के माध्यम से पुनरावृत्ति की O (n^2) जटिलता है और तत्व द्वारा तत्व की तुलना करें।

Answer 8

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

String[] x = { "1", "2", "3" }; 
String[] y = { "2", "5", "6" }; 

Set<String> set = new HashSet<>(Arrays.asList(y)); 
boolean result = Arrays.stream(x).anyMatch(set::contains); // true 

जो O(n) है।

यह @ मार्कस के उत्तर का जावा 8 संस्करण है, हालांकि anyMatch() एक मैच मिलने पर पुनरावृत्ति को रोकता है।

नोट:x और y लंबाई भिन्न हैं, तो कम तत्वों के साथ सरणी के आसपास धारा बनाने पर विचार करें। ऐसा इसलिए है क्योंकि HashSet.contains() विधि O(1) अमूर्त समय में set की लंबाई के बावजूद चलती है, इसलिए सबसे खराब स्थिति के लिए, कम समय में पुनरावृत्ति बेहतर प्रदर्शन होता है।