जावा, सरलीकृत जांच अगर इंट सरणी में इंट शामिल हैं

Question

मूल रूप से मेरा साथी कह रहा है कि मैं एक अलग सरणी का उपयोग करके अपने कोड को कम कर सकता हूं यदि कोई इंट सरणी में कोई इंट है, हालांकि वह मुझे यह नहीं बताएगा कि यह क्या है: P।

वर्तमान:

public boolean contains(final int[] array, final int key) {
    for (final int i : array) {
        if (i == key) {
            return true;
        }
    }
    return false;
}

यह भी करने की कोशिश की है, हालांकि यह हमेशा किसी कारण के लिए गलत लौटता है।

public boolean contains(final int[] array, final int key) {
    return Arrays.asList(array).contains(key);
}

क्या कोई मेरी मदद कर सकता हैं?

धन्यवाद।

Comments

आपका Arrays.asList (...) कॉल एक vararg लेता है, अर्थात यह एक सूची में आपके द्वारा पारित किए जा सकने वाले तर्कों की मनमानी संख्या को लपेट देगा। आपके मामले में, आपको एकल तत्व के साथ सरणियों की एक सूची मिल रही है, और इस सूची में स्पष्ट रूप से इंट शामिल नहीं है।

— साकिन

आपकी टिप्पणी का अर्थ क्या है?

— साकिन

चेक Hashsetआधारित रेट्रियल तंत्र उत्तर। यह सबसे तेज़ तरीका है।

— अमित देशपांडे

मुझे आपके मूल कोड को छोटा करने का कोई मतलब नहीं दिखता क्योंकि आपका तर्क एक आदिम सरणी है और आपका कोड बहुत स्पष्ट और सीधा है। ArrayListकार्यान्वयन वही कर रहा है।

— जेनर

मैं आपका कोड कम नहीं करूंगा। (१) सरणीसूची वही काम करती है जो आपने किया था। (2) - अधिक महत्वपूर्ण बात यह है कि Arrays.asList का उपयोग करने वाला छोटा कोड नई वस्तु बनाता है, जो कुछ प्रदर्शन महत्वपूर्ण कोड के भीतर समस्या हो सकती है। पहला कोड स्निपेट सबसे अच्छी बात है जो आप कर सकते हैं।

— मार्टिन पोडवाल

Answer 1

यहाँ जावा 8 समाधान है

public static boolean contains(final int[] arr, final int key) {
    return Arrays.stream(arr).anyMatch(i -> i == key);
}

Answer 2

आप बस इस्तेमाल कर सकते हैं ArrayUtils.containsसे Apache Commons Lang library।

public boolean contains(final int[] array, final int key) {     
    return ArrayUtils.contains(array, key);
}

Comments

जब तक आप ArrayUtils का उपयोग कर रहे हैं, तब तक ArrayUtils.contains

— mjohnsonengr

जो भी कारण हो :)

— रेइमुस 19

यह ध्यान देने योग्य है कि पुस्तकालय ArrayUtils.contains()का हिस्सा है Apache Commons Lang। भले ही यह एक महान काम है, लेकिन यह अभी भी एक अच्छा विचार नहीं है कि बाहरी निर्भरता को जोड़ने के लिए सिर्फ यह देखने के लिए कि क्या सरणी में एक तत्व शामिल है: D

— Krzysiek

ArrayUtils अतीत की बात है। जावा 8+ और अमरूद में बहुत ही बढ़िया गुडाई है !!

— त्रिकोणीय

Answer 3

यह इसलिए है क्योंकि Arrays.asList(array)वापसी List<int[]>। arrayतर्क को एक मान के रूप में माना जाता है जिसे आप लपेटना चाहते हैं (आपको किलों की सरणियों की सूची मिलती है), वैरग के रूप में नहीं।

ध्यान दें कि यह ऑब्जेक्ट प्रकारों के साथ काम करता है (आदिम नहीं):

public boolean contains(final String[] array, final String key) {
    return Arrays.asList(array).contains(key);
}

या और भी:

public <T>  boolean contains(final T[] array, final T key) {
    return Arrays.asList(array).contains(key);
}

लेकिन आपके पास नहीं हो सकता है List<int>और ऑटोबॉक्सिंग यहां काम नहीं कर रहा है।

Comments

ऑटोबॉक्सिंग क्यों काम नहीं करता है, क्या यह इसलिए है क्योंकि इसे अंतिम घोषित किया गया है?

— सुभाषी २५'१६ को १०:५

Answer 4

अमरूद आदिम प्रकारों के लिए अतिरिक्त तरीके प्रदान करता है। उनमें एक विधि शामिल है जो आपके जैसे ही तर्क देती है।

public boolean contains(final int[] array, final int key) {
    return Ints.contains(array, key);
}

आप अमरूद संस्करण को वैधानिक रूप से आयात कर सकते हैं।

देखें अमरुद आदिम व्याख्या

Answer 5

एक अलग तरीका:

public boolean contains(final int[] array, final int key) {  
     Arrays.sort(array);  
     return Arrays.binarySearch(array, key) >= 0;  
}  

यह पारित-सरणी को संशोधित करता है। आपके पास सरणी को कॉपी करने और मूल सरणी पर काम करने का विकल्प होगा, int[] sorted = array.clone();
लेकिन यह केवल संक्षिप्त कोड का एक उदाहरण है। रनटाइम है O(NlogN)जबकि आपका रास्ता हैO(N)

Comments

मुझे लगता है कि अगर कोई containsविधि मेरे सरणी को संशोधित करती है तो मुझे आश्चर्य होगा ।

— ज़ोंग

@ZongLi: ओपी के लिए यह सिर्फ एक उदाहरण है। यदि हम नाइटपैक कर रहे हैं तो ओपी का उपयोग करें

— क्रेटाइलस

बाइनरीसर्च के javadoc से (): "वापसी मान होगा = = 0 यदि और केवल यदि कुंजी मिली है।" इसलिए Arrays.binarySearch (सरणी, कुंजी)> = 0 लौटाया जाना चाहिए!

— icza

अनुपूरक: बाइनरीसर्च का वापसी मूल्य () (- (प्रविष्टि बिंदु) - 1) है यदि कुंजी समाहित नहीं है जो संभवतः -1 के अलावा एक मान हो सकता है।

— इक्जा

यह नहीं हो सकता है -1अगर यह सच होने का इरादा है। "सम्मिलन बिंदु को उस बिंदु के रूप में परिभाषित किया जाता है जिस पर कुंजी को सूची में डाला जाएगा: कुंजी से अधिक पहले तत्व का सूचकांक, या लिस्ट। () (यदि सूची में सभी तत्व निर्दिष्ट कुंजी से कम हैं। "। कहने की जरूरत है >= 0।

— ब्रायन

Answer 6

मुझे पता है कि यह सुपर लेट है, लेकिन Integer[]इसके बजाय कोशिश करें int[]।

Comments

यह उपाय है।

— atheesh27

काम के जवाब के लिए

— अपवित्र

Answer 7

1. एक बंद का उपयोग करता है

List<T> list=Arrays.asList(...)
list.contains(...)

2. यदि आप एक से अधिक बार उपयोग करते हैं, तो प्रदर्शन पर विचार के लिए हैशसेट।

Set <T>set =new HashSet<T>(Arrays.asList(...));
set.contains(...)

Answer 8

इसे इस्तेमाल करे:

public static void arrayContains(){
    int myArray[]={2,2,5,4,8};

    int length=myArray.length;

    int toFind = 5;
    boolean found = false;

    for(int i = 0; i < length; i++) {
        if(myArray[i]==toFind) {
            found=true;
        }
    }

    System.out.println(myArray.length);
    System.out.println(found); 
}

Answer 9

आप जावा 8 कोड के नीचे अपने आदिम इंट सरणी को इंटिजर्स की एक सरणी में बदल सकते हैं,

List<Integer> arrayElementsList = Arrays.stream(yourArray).boxed().collect(Collectors.toList());

और फिर contains()जाँच करने के लिए विधि का उपयोग करें कि क्या सूची में एक विशेष तत्व है,

boolean containsElement = arrayElementsList.contains(key);

Answer 10

यह जावा 8 में काम किया

public static boolean contains(final int[] array, final int key)
{
return Arrays.stream(array).anyMatch(n->n==key);
}

Comments

इसे तुरंत पहले मैच पर लौटना चाहिए, इसके बजाय यह अभी भी सरणी में सभी वस्तुओं को स्कैन करेगा, भले ही यह मैच मिला हो। (त्रैलियन आइटम की एक सरणी पर विचार करें)

— TriCore

आप सही हैं इस सार्वजनिक स्थिर बूलियन में शामिल हैं (अंतिम int [] सरणी, अंतिम int कुंजी) {वापसी Arrays. (सरणी) .anyMatch (n-> n == कुंजी); }

— फरहाद बाघिरोव

Java 8 स्ट्रीम anyMatch एक शॉर्ट-सर्किट ऑपरेशन है और सरणी में सभी आइटम को स्कैन नहीं करेगा।

— लॉर्डपर्सले

@LordParsley उपरोक्त कोड का लक्ष्य सरणी में चेक तत्व है, सरणी के सभी तत्व को स्कैन नहीं करता है।

— फरहद बाघिरोव

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

— लॉर्डपर्सले

Answer 11

आप किसी ऑब्जेक्ट में java.util.Arraysसरणी को रूपांतरित करने के लिए क्लास का उपयोग कर सकते हैं जैसे कि :T[?]List<T>contains

Arrays.asList(int[] array).contains(int key);

Answer 12

इस बात पर निर्भर करता है कि आपकी सरणी कितनी बड़ी होगी, अगर आप संग्रह का उपयोग करते हैं और .containsएक बार में एक तत्व पर निर्भर होने के बजाय, तो आपको बेहतर प्रदर्शन मिलेगा :

import static org.junit.Assert.assertTrue;
import java.util.HashSet;

import org.junit.Before;
import org.junit.Test;

public class IntLookupTest {

int numberOfInts = 500000;
int toFind = 200000;
int[] array;

HashSet<Integer> intSet;

@Before
public void initializeArrayAndSet() {
    array = new int[numberOfInts];
    intSet = new HashSet<Integer>();
    for(int i = 0; i < numberOfInts; i++) {
        array[i] = i;
        intSet.add(i);
    }
}

@Test
public void lookupUsingCollections() {
    assertTrue(intSet.contains(toFind));
}

@Test
public void iterateArray() {
    assertTrue(contains(array, toFind));

}

public boolean contains(final int[] array, final int key) {
    for (final int i : array) {
        if (i == key) {
            return true;
        }
    }
    return false;
}
}

Answer 13

समाधान # 1

चूंकि मूल प्रश्न केवल एक सरलीकृत समाधान चाहता है (और तेज़ नहीं), यहाँ एक-पंक्ति समाधान है:

public boolean contains(int[] array, int key) {
    return Arrays.toString(array).matches(".*[\\[ ]" + key + "[\\],].*");
}

स्पष्टीकरण:Arrays.toString() राज्यों के Javadoc का परिणाम वर्ग कोष्ठक में संलग्न होता है और आसन्न तत्वों को वर्णों द्वारा अलग किया जाता है "," (एक अल्पविराम के बाद एक स्थान)। तो हम इस पर भरोसा कर सकते हैं। पहले हम arrayएक स्ट्रिंग में कनवर्ट करते हैं, और फिर हम जांचते हैं कि keyक्या इस स्ट्रिंग में निहित है। बेशक हम "उप-संख्या" को स्वीकार नहीं कर सकते हैं (उदाहरण के लिए "1234" में "23" शामिल हैं), इसलिए हमें उन पैटर्नों की तलाश करनी होगी जहां keyएक उद्घाटन ब्रैकेट या एक स्थान है, और एक समापन ब्रैकेट या अल्पविराम के साथ।

नोट: उपयोग किया गया regexp पैटर्न नकारात्मक संख्याओं को भी ठीक से संभालता है (जिसका स्ट्रिंग प्रतिनिधित्व माइनस साइन से शुरू होता है)।

समाधान # 2

यह समाधान पहले से ही पोस्ट किया गया है, लेकिन इसमें गलतियाँ हैं, इसलिए मैं सही समाधान पोस्ट करता हूं:

public boolean contains(int[] array, int key) {
    Arrays.sort(array);
    return Arrays.binarySearch(array, key) >= 0;
}

इसके अलावा इस समाधान का एक साइड इफेक्ट है: यह संशोधित करता है array( इसे टाइप करें )।

Comments

स्ट्रिंग हैंडलिग आम तौर पर महंगा होता है, किसी को स्ट्रीट्स के रूप में क्यों इलाज करना चाहिए?

— विटाली

@DenysVitali क्योंकि op में पहले से ही एक कार्यशील, कुशल समाधान है, और वह एक छोटे समाधान की तलाश में है। और ये छोटे हैं। यह सवाल प्रदर्शन के बारे में नहीं है।

— आईसीजे

मुझे इस प्रश्न को गलत समझ लेना चाहिए, पूछने के लिए खेद है

— डेनिस विटाली

Answer 14

Integer.parseInt()ऐसा करने की कोशिश करो .....

public boolean chkInt(final int[] array){
    int key = false;

    for (Integer i : array){


          try{

                   Integer.parseInt(i);
                   key = true;
                   return key;

             }catch(NumberFormatException ex){

                   key = false;

                   return key;

              }


     }
}