मैं यह कैसे निर्धारित करूं कि किसी सरणी में जावा में कोई विशेष मान है?

Question

मेरे पास String[]मूल्यों के साथ ऐसा है:

public static final String[] VALUES = new String[] {"AB","BC","CD","AE"};

यह देखते हुए String sकि क्या VALUESइसमें परीक्षण का एक अच्छा तरीका है s?

Comments

इसके चारों ओर लंबा रास्ता, लेकिन आप लूप के लिए उपयोग कर सकते हैं: "के लिए (स्ट्रिंग s: VALUES) यदि (s.equals (" MYVALUE ")) वापस लौटें;

— Zack

@camickr। आपके प्रश्न के लिए, मैंने इस प्रश्न को और आपके उत्तर को अनजाना बना दिया, क्योंकि इसने मुझे 30 मिनट और कोड की 20 पंक्तियों को लूप के लिए बदसूरत लिखने से बचाया, -ओन-। तीन साल पहले इसे नहीं पढ़ा था। (बीटीडब्लू, धन्यवाद :))

— परसेंट

@ Camickr - मेरे पास इसके साथ लगभग एक जैसी स्थिति है: stackoverflow.com/a/223929/12943 यह सिर्फ वोट प्राप्त करता रहता है अभी तक सूरज के प्रलेखन से एक कॉपी / पेस्ट था। मुझे लगता है कि स्कोर इस बात पर आधारित है कि आपने कितनी सहायता प्रदान की है और न कि आपने इसमें कितना प्रयास किया है - और अधिकतर आप इसे कितनी तेजी से पोस्ट करते हैं! शायद हम जॉन स्कीट के रहस्य पर ठोकर खा चुके हैं! अच्छा जवाब, आपके लिए +1।

— बिल के

यदि आप Apache Commons का उपयोग कर रहे हैं, तो org.apache.commons.lang.ArrayUtils.contains () आपके लिए ऐसा करता है।

— मिस्टर ब्वॉय

@camickr क्योंकि मेरे जैसे लोग, एक सवाल, एसओ रिजल्ट पर क्लिक करते हैं, अपना उत्तर देखते हैं, उसका परीक्षण करते हैं, यह काम करता है, उत्तर को बढ़ाता है और फिर छोड़ देता है।

— असॉल्ट्स

Answer 1

Arrays.asList(yourArray).contains(yourValue)

चेतावनी: यह प्राथमिकताओं के सरणियों के लिए काम नहीं करता है (टिप्पणियों को देखें)।

---

जबसे जावा-8 अब आप स्ट्रीम का उपयोग कर सकते हैं।

String[] values = {"AB","BC","CD","AE"};
boolean contains = Arrays.stream(values).anyMatch("s"::equals);

जानने के लिए कि की एक सरणी int, doubleया longएक मूल्य उपयोग किया गया है IntStream, DoubleStreamया LongStreamक्रमशः।

उदाहरण

int[] a = {1,2,3,4};
boolean contains = IntStream.of(a).anyMatch(x -> x == 4);

Comments

मैं कुछ हद तक इस बात के लिए उत्सुक हूं कि एरेस वर्ग में खोज फ़ंक्शन बनाम एरे पर काम करना और आदिम के लिए एक बराबर () फ़ंक्शन या == का उपयोग करना।

— थॉमस ओवेन्स

आप बहुत कुछ नहीं खोते हैं, क्योंकि asList () एक ArrayList देता है जिसके दिल में एक सरणी होती है। कंस्ट्रक्टर सिर्फ एक संदर्भ को बदल देगा ताकि वहां बहुत काम न हो। और सम्‍मिलित है () / indexOf () बराबर होगा और बराबर () का उपयोग करेगा। आदिम के लिए आपको इसे स्वयं कोड करना बेहतर होना चाहिए, हालांकि। स्ट्रिंग्स या अन्य वर्गों के लिए, अंतर ध्यान देने योग्य नहीं होगा।

— जॉय

Odd, NetBeans का दावा है कि 'int [] छुट्टियों के लिए' Arrays.asList (छुट्टियां) 'एक' सूची <int []> लौटाता है, न कि 'सूची <int>'। इसमें सिर्फ एक ही तत्व होता है। मतलब यह है कि इसमें काम नहीं करता है क्योंकि इसमें सिर्फ एक तत्व है; int सरणी।

— Nyerguds

Nyerguds: वास्तव में, यह आदिम के लिए काम नहीं करता है। जावा में आदिम प्रकार सामान्य नहीं हो सकते। asList को <T> सूची <T> asList (T ...) के रूप में घोषित किया गया है। जब आप इसमें एक int [] पास करते हैं, तो कंपाइलर T = int [] को संक्रमित कर देता है क्योंकि यह T = int को अवरूद्ध नहीं कर सकता, क्योंकि प्राइमेटिव जेनरिक नहीं हो सकते।

— CromTheDestroyer

@ जॉय सिर्फ एक साइड नोट है, यह एक है ArrayList, लेकिन java.util.ArrayListजैसा कि आप उम्मीद नहीं करते हैं, असली वर्ग वापस आ गया है: के java.util.Arrays.ArrayList<E>रूप में परिभाषित किया गया है public class java.util.Arrays {private static class ArrayList<E> ... {}}:।

— ट्वीस्टरेब

Answer 2

जावा एसई 9 के लिए संक्षिप्त अपडेट

संदर्भ सरणियाँ खराब हैं। इस मामले के लिए हम एक सेट के बाद हैं। जावा एसई 9 के बाद से हमारे पास है Set.of।

private static final Set<String> VALUES = Set.of(
    "AB","BC","CD","AE"
);

"स्ट्रिंग स्टिंग को देखते हुए, क्या परीक्षण का एक अच्छा तरीका है कि क्या वैल्यू में एस शामिल हैं?"

VALUES.contains(s)

हे (1)।

सही प्रकार , अपरिवर्तनीय , हे (1) और संक्षिप्त । सुंदर।*

मूल उत्तर विवरण

बस शुरू करने के लिए कोड को साफ़ करने के लिए। हमने (सुधारा):

public static final String[] VALUES = new String[] {"AB","BC","CD","AE"};

यह एक उत्परिवर्ती स्थैतिक है जो फाइंडबग्स आपको बताएगा कि आप बहुत शरारती हैं। स्टैटिक्स को संशोधित न करें और अन्य कोड को भी ऐसा करने की अनुमति न दें। पूर्ण न्यूनतम पर, क्षेत्र निजी होना चाहिए:

private static final String[] VALUES = new String[] {"AB","BC","CD","AE"};

(ध्यान दें, आप वास्तव में new String[];बिट ड्रॉप कर सकते हैं ।)

संदर्भ सरणियाँ अभी भी खराब हैं और हम एक सेट चाहते हैं:

private static final Set<String> VALUES = new HashSet<String>(Arrays.asList(
     new String[] {"AB","BC","CD","AE"}
));

(स्वयं के रूप में पागल लोग, यदि यह लिपटे हुए हों, तो यह और भी अधिक आसान लग सकता है Collections.unmodifiableSet- फिर इसे सार्वजनिक भी किया जा सकता है।)

(* ब्रांड पर थोड़ा और अधिक होने के लिए, संग्रह एपीआई अभी भी अपरिवर्तनीय संग्रह प्रकारों को याद कर रहा है और मेरे स्वाद के लिए वाक्य रचना अभी भी बहुत अधिक क्रियात्मक है।)

Comments

सिवाय इसके पहले स्थान पर संग्रह बनाने के लिए O (N) :)

— ड्रू नोक

यदि यह स्थिर है, तो यह संभवत: कई बार उपयोग होने वाला है। इसलिए, सेट को इनिशियलाइज़ करने में लगने वाले समय में बहुत सी लीनियर खोजों की लागत की तुलना में काफी छोटा होने की संभावना है।

— एक्सआर।

तब कलेक्शन कोड लोडिंग टाइम (जो तकनीकी रूप से O (n) लेकिन व्यावहारिक रूप से स्थिर है) पर हावी हो रहा है।

— टॉम हॉल्टिन -

@ TomHawtin-tackline तुम क्यों कहते हो "विशेष रूप से यहाँ हम एक सेट चाहते हैं"? इस मामले में एक सेट (हैशसेट) का क्या फायदा है? क्यों एक "संदर्भ सरणी" खराब है ("संदर्भ सरणी" से क्या आपका मतलब है कि एक सरणी एक सरणी द्वारा समर्थित के रूप में एक सरणी द्वारा समर्थित है Arrays.asList)?

— बेसिल बोर्के

@ आरएनआर ए TreeSetहोगा O(log n)। HashSets को ऐसे स्केल किया गया है कि बाल्टी में तत्वों की औसत संख्या लगभग स्थिर है। कम से कम 2 ^ 30 तक सरणियों के लिए। कहते हैं, हार्डवेयर कैश से प्रभावित हो सकता है जो बड़े-ओ विश्लेषण की उपेक्षा करता है। यह भी मानता है कि हैश फ़ंक्शन प्रभावी रूप से काम कर रहा है।

— टॉम हॉकिन -

Answer 3

आप अपाचे कॉमन्स लैंगArrayUtils.contains से उपयोग कर सकते हैं

public static boolean contains(Object[] array, Object objectToFind)

ध्यान दें कि falseयदि पारित सरणी है तो यह विधि वापस आती है null।

सभी प्रकार की आदिम सरणियों के लिए भी विधियाँ उपलब्ध हैं।

उदाहरण:

String[] fieldsToInclude = { "id", "name", "location" };

if ( ArrayUtils.contains( fieldsToInclude, "id" ) ) {
    // Do some stuff.
}

Comments

@ max4ever मैं सहमत हूँ, लेकिन यह अभी भी बेहतर है "अपना खुद का रोल करना" और पढ़ने के लिए आसान फिर कच्चा जावा तरीका।

— जेसन

पैकेज: org.apache.commons.lang.ArrayUtils

— slamborne

@ max4ever कभी-कभी आपके पास पहले से ही यह लाइब्रेरी शामिल है (अन्य कारणों के लिए) और यह पूरी तरह से मान्य उत्तर है। मुझे इसकी तलाश थी और मैं पहले से ही अपाचे कॉमन्स लैंग पर निर्भर हूं। इस उत्तर के लिए धन्यवाद।

— गुइसिम

या आप सिर्फ विधि की नकल कर सकते हैं (और यदि कोई हो तो प्रतिनियुक्ति)।

— बफेलो

@ max4ever अधिकांश एंड्रॉइड ऐप्स को प्रागार्ड द्वारा कम से कम किया जाता है, केवल आपके एप्लिकेशन में आपके लिए आवश्यक कक्षाएं और फ़ंक्शन डालते हैं। यह आपके स्वयं के रोल के बराबर है, या अपाचे चीज़ के स्रोत की प्रतिलिपि बनाता है। और जो कोई भी कम से कम उपयोग नहीं करता है उसे

— 700kb

Answer 4

बस इसे हाथ से लागू करें:

public static <T> boolean contains(final T[] array, final T v) {
    for (final T e : array)
        if (e == v || v != null && v.equals(e))
            return true;

    return false;
}

सुधार की:

v != nullहालत विधि अंदर निरंतर है। यह हमेशा विधि कॉल के दौरान उसी बूलियन मान का मूल्यांकन करता है। इसलिए यदि इनपुट arrayबड़ा है, तो केवल एक बार इस स्थिति का मूल्यांकन करना अधिक कुशल है, और हम forपरिणाम के आधार पर लूप के अंदर एक सरलीकृत / तेज स्थिति का उपयोग कर सकते हैं । बेहतर contains()तरीका:

public static <T> boolean contains2(final T[] array, final T v) {
    if (v == null) {
        for (final T e : array)
            if (e == null)
                return true;
    } 
    else {
        for (final T e : array)
            if (e == v || v.equals(e))
                return true;
    }

    return false;
}

Comments

@Phoexo यह समाधान स्पष्ट रूप से तेज़ है क्योंकि स्वीकृत उत्तर किसी सूची में सरणी को लपेटता है, और उस सूची में शामिल () विधि को कॉल करता है जबकि मेरा समाधान मूल रूप से वही होता है जिसमें () केवल होता है।

— आईसीजे

@AlastorMoody e == v एक संदर्भ समानता की जाँच करता है जो बहुत तेज़ है। यदि समान ऑब्जेक्ट (संदर्भ के अनुसार) सरणी में है, तो यह तेज़ी से मिल जाएगा। यदि यह एक ही उदाहरण नहीं है, तो यह अभी भी समान (दावा) विधि द्वारा दावा किया जा सकता है, यदि संदर्भ समान नहीं हैं, तो यह जांचा जाता है।

— आईसीजे

यह फ़ंक्शन जावा का हिस्सा क्यों नहीं है? कोई आश्चर्य नहीं कि लोग कहते हैं कि जावा फूला हुआ है ... ऊपर दिए गए सभी उत्तरों को देखें जो पुस्तकालयों के एक समूह का उपयोग करते हैं जब आपको सभी आवश्यक लूप के लिए होता है। आज के बच्चे!

— 19

@ एफ्रकहेड यह जावा का हिस्सा है, देखेंCollection.contains(Object)

— स्टीव

@icza यदि आप के स्रोत को देखते हैं Arraysऔर ArrayListयह पता चला है कि यह आवश्यक रूप से उपयोग किए जाने वाले संस्करण की तुलना में तेज़ नहीं है Arrays.asList(...).contains(...)। एक बनाने का ओवरहेड एक ArrayListबहुत छोटा है, और ArrayList.contains()ऊपर दिखाए गए (जेडीके 7) की तुलना में एक स्मार्ट लूप (वास्तव में यह दो अलग-अलग छोरों का उपयोग करता है) का उपयोग करता है।

— एक्सल

Answer 5

चार अलग-अलग तरीकों की जाँच करें कि क्या एक सरणी में एक मान होता है

1) सूची का उपयोग करना:

public static boolean useList(String[] arr, String targetValue) {
    return Arrays.asList(arr).contains(targetValue);
}

2) सेट का उपयोग:

public static boolean useSet(String[] arr, String targetValue) {
    Set<String> set = new HashSet<String>(Arrays.asList(arr));
    return set.contains(targetValue);
}

3) एक साधारण लूप का उपयोग करना:

public static boolean useLoop(String[] arr, String targetValue) {
    for (String s: arr) {
        if (s.equals(targetValue))
            return true;
    }
    return false;
}

4) Arrays.binarySearch () का उपयोग करना:

नीचे दिया गया कोड गलत है, इसे पूर्णता के लिए यहां सूचीबद्ध किया गया है। बाइनरीसर्च () केवल सॉर्ट किए गए सरणियों पर उपयोग किया जा सकता है। आप पाएंगे कि परिणाम नीचे अजीब है। यह सबसे अच्छा विकल्प है जब सरणी को सॉर्ट किया जाता है।

public static boolean binarySearch(String[] arr, String targetValue) {  
            int a = Arrays.binarySearch(arr, targetValue);
            return a > 0;
        }

त्वरित उदाहरण:

String testValue="test";
String newValueNotInList="newValue";
String[] valueArray = { "this", "is", "java" , "test" };
Arrays.asList(valueArray).contains(testValue); // returns true
Arrays.asList(valueArray).contains(newValueNotInList); // returns false

Comments

आपके द्विआधारी खोज उदाहरण को एक> 0 वापस करना चाहिए;

— शेरवुड

क्यों? मुझे लगता है कि इसे ए -1 लौटा देना चाहिए, क्योंकि 0 संकेत करेगा कि यह सरणी के प्रमुख में निहित है।

— मेबेल

पहले संस्करण के साथ (a >= 0)सही था, बस डॉक्स की जांच करें , वे कहते हैं "ध्यान दें कि यह गारंटी देता है कि वापसी मूल्य> = 0 होगा यदि और केवल यदि कुंजी मिली है"।

— योओरी एन।

क्यों स्ट्रिंग करने के लिए काम करता है और नहीं int? स्थिर बूलियन मौजूद है (int [] ints, int k) {वापसी Arrays.asList (ints) .contains (k); }

— विलियन मार्टिंस

Answer 6

यदि सरणी को क्रमबद्ध नहीं किया गया है, तो आपको हर चीज पर पुनरावृत्त करना होगा और प्रत्येक पर एक समान कॉल करना होगा।

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

सामान्यतया, यदि आप बहुत अधिक सदस्यता जाँच करने जा रहे हैं, तो आप एक सेट में सब कुछ स्टोर करना चाहते हैं, न कि किसी सरणी में।

Comments

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

— थॉमस ओवेन्स

@ थोमस: मैं सहमत हूं। या आप बस एक ट्रीसेट में सब कुछ जोड़ सकते हैं; एक ही जटिलता। अगर यह नहीं बदलता है तो मैं एरे का उपयोग करूंगा (शायद संदर्भों के संदर्भ में थोड़े स्मृति क्षेत्र को बचाने के कारण, हालांकि तार नहीं हैं)। अगर यह समय के साथ बदल जाएगा तो मैं सेट का उपयोग करूंगा।

— उरी

Answer 7

इसके लायक मैं गति के लिए 3 सुझावों की तुलना में एक परीक्षण भागा। मैंने यादृच्छिक पूर्णांक उत्पन्न किए, उन्हें स्ट्रिंग में परिवर्तित किया और उन्हें एक सरणी में जोड़ा। मैंने तब उच्चतम संभव संख्या / स्ट्रिंग की खोज की, जो इसके लिए सबसे खराब स्थिति होगी asList().contains()।

10K सरणी आकार का उपयोग करते समय परिणाम थे:

क्रमबद्ध करें और खोजें: 15
बाइनरी खोज: 0
asList.contains: 0

100K सरणी का उपयोग करते समय परिणाम थे:

क्रमबद्ध करें और खोजें: 156
बाइनरी खोज: 0
asList.contains: 32

तो अगर सरणी को क्रमबद्ध क्रम में बनाया गया है तो द्विआधारी खोज सबसे तेज़ है, अन्यथा asList().containsजाने का रास्ता होगा। यदि आपके पास कई खोज हैं, तो यह सरणी को क्रमबद्ध करने के लिए सार्थक हो सकता है ताकि आप द्विआधारी खोज का उपयोग कर सकें। यह सब आपके आवेदन पर निर्भर करता है।

मुझे लगता है कि वे परिणाम हैं जो ज्यादातर लोग उम्मीद करेंगे। यहाँ परीक्षण कोड है:

import java.util.*;

public class Test
{
    public static void main(String args[])
    {
        long start = 0;
        int size = 100000;
        String[] strings = new String[size];
        Random random = new Random();


        for (int i = 0; i < size; i++)
            strings[i] = "" + random.nextInt( size );

        start = System.currentTimeMillis();
        Arrays.sort(strings);
        System.out.println(Arrays.binarySearch(strings, "" + (size - 1) ));
        System.out.println("Sort & Search : " + (System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        System.out.println(Arrays.binarySearch(strings, "" + (size - 1) ));
        System.out.println("Search        : " + (System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        System.out.println(Arrays.asList(strings).contains( "" + (size - 1) ));
        System.out.println("Contains      : " + (System.currentTimeMillis() - start));
    }
}

Comments

मुझे यह कोड समझ नहीं आ रहा है। आप सरणी 'स्ट्रिंग्स' को क्रमबद्ध करते हैं और बाइनरीसर्च में दोनों कॉल में समान (सॉर्ट किए गए) सरणी का उपयोग करते हैं। हॉटस्पॉट रनटाइम ऑप्टिमाइज़ेशन के अलावा वह कुछ भी कैसे दिखा सकता है? AsList.contains कॉल के साथ भी ऐसा ही है। आप सॉर्ट किए गए सरणी से एक सूची बनाते हैं और फिर उस पर उच्चतम मान के साथ शामिल होते हैं। बेशक इसमें समय लगने वाला है। इस परीक्षण का अर्थ क्या है? नहीं लिखा जा रहा है एक अनुचित ढंग से लिखा microbenchmark

— एरिक

इसके अलावा, चूंकि बाइनरी खोज केवल एक सॉर्ट किए गए सेट पर लागू की जा सकती है, बाइनरी खोज का उपयोग करने के लिए सॉर्ट और खोज एकमात्र संभव तरीका है।

— एरिक

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

— Thor84no

यह परीक्षण त्रुटिपूर्ण है क्योंकि यह एक ही JVM उदाहरण में सभी 3 परीक्षण चलाता है । बाद के परीक्षणों से कैश, जेआईटी, आदि को गर्म करने वाले लोगों को फायदा हो सकता है

— स्टीव कूओ

यह परीक्षण वास्तव में पूरी तरह से असंबंधित है। सॉर्ट एंड सर्च लीनियरथमिक (एन * लॉग (एन)) जटिलता है, द्विआधारी खोज लॉगरिदमिक है और अर्रे यूटिल्स। कॉन्सेप्ट स्पष्ट रूप से रैखिक है। इस समाधान की तुलना करने के लिए इसका कोई उपयोग नहीं है क्योंकि वे पूरी तरह से विभिन्न जटिलता वर्गों में हैं।

— बजे

Answer 8

त्वरित सरणी आरंभीकरण सिंटैक्स का भी उपयोग करने के बजाय, आप इसे Arrays.asList पद्धति, जैसे:

public static final List<String> STRINGS = Arrays.asList("firstString", "secondString" ...., "lastString");

तब आप कर सकते हैं (ऊपर की तरह):

STRINGS.contains("the string you want to find");

Answer 9

Java 8 के साथ आप एक स्ट्रीम बना सकते हैं और चेक कर सकते हैं कि स्ट्रीम में कोई एंट्री मेल खाती है या नहीं "s":

String[] values = {"AB","BC","CD","AE"};
boolean sInArray = Arrays.stream(values).anyMatch("s"::equals);

या एक सामान्य विधि के रूप में:

public static <T> boolean arrayContains(T[] array, T value) {
    return Arrays.stream(array).anyMatch(value::equals);
}

Comments

यह भी आदिम विशेषज्ञता पर ध्यान देने योग्य है।

— स्किवि

जोड़ने के लिए, anyMatchजावाडॉक कहता है कि यह "...May not evaluate the predicate on all elements if not necessary for determining the result.", इसलिए उसे एक मैच खोजने के बाद प्रसंस्करण जारी रखने की आवश्यकता नहीं हो सकती है।

— mkobit

Answer 10

मान के लिए बाइनरी खोज करने के लिए आप Arrays वर्ग का उपयोग कर सकते हैं । यदि आपकी सरणी सॉर्ट नहीं की गई है, तो आपको सरणी को सॉर्ट करने के लिए उसी वर्ग में सॉर्ट फ़ंक्शंस का उपयोग करना होगा, फिर इसके माध्यम से खोजें।

Comments

आप इसे पूरा करने के लिए एक ही कक्षा में सॉर्ट फ़ंक्शंस का उपयोग कर सकते हैं ... मुझे इसे अपने उत्तर में जोड़ना चाहिए।

— थॉमस ओवेन्स

शायद एशलिस्ट () की तुलना में अधिक खर्च होंगे। () दृष्टिकोण, फिर, मुझे लगता है। जब तक आपको उस चेक को बहुत बार करने की आवश्यकता नहीं है (लेकिन यदि यह उन मूल्यों की एक स्थिर सूची है, जिन्हें निष्पक्ष होने के लिए शुरू किया जा सकता है)।

— जॉय

सच। वहाँ बहुत सारे चर हैं जो सबसे प्रभावी होंगे। हालांकि विकल्प होना अच्छा है।

— थॉमस ओवेन्स

कुछ कोड जो यहाँ ऐसा करते हैं: stackoverflow.com/a/48242328/9131078

— OOBalance

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

— arunwithasmile

Answer 11

ObStupidAnswer (लेकिन मुझे लगता है कि इसमें कहीं न कहीं एक सबक है):

enum Values {
    AB, BC, CD, AE
}

try {
    Values.valueOf(s);
    return true;
} catch (IllegalArgumentException exc) {
    return false;
}

Comments

अपवाद फेंकना जाहिरा तौर पर भारी है, लेकिन अगर यह काम करता है तो एक मूल्य का परीक्षण करने का यह एक नया तरीका होगा। नकारात्मक पक्ष यह है कि एनम को पहले से परिभाषित किया जाना है।

— जेम्स पी।

Answer 12

वास्तव में, यदि आप टॉम के बारे में हैशसेट <स्ट्रिंग> का उपयोग करते हैं, तो प्रस्तावित किया गया है कि आपको छंटाई के बारे में चिंता करने की आवश्यकता नहीं है, और आपकी गति एक समान सरणी पर बाइनरी खोज के साथ भी संभव है।

यह सब इस बात पर निर्भर करता है कि आपका कोड कैसे सेट किया गया है, जाहिर है, लेकिन जहां से मैं खड़ा हूं, वह क्रम होगा:

एक अनसुलझी सरणी पर:

1. HashSet
2. asList
3. सॉर्ट और बाइनरी

एक क्रमबद्ध सरणी पर:

1. HashSet
2. बाइनरी
3. asList

तो या तो, जीत के लिए हैशसेट।

Comments

हैशसेट सदस्यता O (1) होनी चाहिए और एक सॉर्ट किए गए संग्रह पर बाइनरी सर्च O (लॉग एन) है।

— स्काईलार सैवलैंड

Answer 13

यदि आपके पास Google संग्रह लाइब्रेरी है, तो ImmutableSet (http://google-collections.googlecode.com/svn/trunk/javadoc/com/google/common/collect/IntutableSet.html) का उपयोग करके टॉम के उत्तर को बहुत सरल बनाया जा सकता है

यह वास्तव में प्रस्तावित इनिशियलाइज़ेशन से बहुत अधिक अव्यवस्था को हटाता है

private static final Set<String> VALUES =  ImmutableSet.of("AB","BC","CD","AE");

Answer 14

एक संभव समाधान:

import java.util.Arrays;
import java.util.List;

public class ArrayContainsElement {
  public static final List<String> VALUES = Arrays.asList("AB", "BC", "CD", "AE");

  public static void main(String args[]) {

      if (VALUES.contains("AB")) {
          System.out.println("Contains");
      } else {
          System.out.println("Not contains");
      }
  }
}

Answer 15

डेवलपर्स अक्सर करते हैं:

Set<String> set = new HashSet<String>(Arrays.asList(arr));
return set.contains(targetValue);

उपरोक्त कोड काम करता है, लेकिन पहले सेट करने के लिए एक सूची को बदलने की आवश्यकता नहीं है। सूची को सेट पर बदलने के लिए अतिरिक्त समय की आवश्यकता होती है। यह सरल हो सकता है:

Arrays.asList(arr).contains(targetValue);

या

   for(String s: arr){
        if(s.equals(targetValue))
            return true;
    }

return false;

पहला वाला दूसरे की तुलना में अधिक पठनीय है।

Answer 16

एक सरल लूप का उपयोग करना ऐसा करने का सबसे कुशल तरीका है।

boolean useLoop(String[] arr, String targetValue) {
    for(String s: arr){
        if(s.equals(targetValue))
            return true;
    }
    return false;
}

सौजन्य से प्रोग्रामक्रिक

Comments

यदि लक्ष्य मान से पहले सरणी में शून्य संदर्भ है, तो यह एक शून्य सूचक अपवाद को फेंक देगा।

— शमूएल एडविन वार्ड

यदि कथन होना चाहिए: if (targetValue.equals (s)) क्योंकि स्ट्रिंग इक्वल्स के पास एक इंस्टॉफ़र चेकर है।

— एरचोन

ऑब्जेक्ट को सुरक्षित रखने के बजाय Objects.equals (obj1, obj2) का उपयोग करें।

— त्रयी

Answer 17

में जावा 8 स्ट्रीम का उपयोग करें।

List<String> myList =
Arrays.asList("a1", "a2", "b1", "c2", "c1");

myList
.stream()
.filter(s -> s.startsWith("c"))
.map(String::toUpperCase)
.sorted()
.forEach(System.out::println);

Comments

क्या इस दृष्टिकोण के साथ कोई लाभ हैं?

— जोहान्स स्टैडलर

यह प्रश्न का उत्तर नहीं देता है।

— फ्लोरियन एफ

Answer 18

1. सीमित लंबाई के सरणियों के लिए निम्नलिखित का उपयोग करें (जैसा कि कैमिक्र द्वारा दिया गया है )। यह बार-बार होने वाली जाँचों के लिए धीमा है, विशेष रूप से लंबी सरणियों (रैखिक खोज) के लिए।

    Arrays.asList(...).contains(...)

2. तेज प्रदर्शन के लिए यदि आप बार-बार तत्वों के एक बड़े समूह के खिलाफ जांच करते हैं

   • एक सरणी गलत संरचना है। एक का उपयोग करें TreeSetऔर इसमें प्रत्येक तत्व जोड़ें। यह तत्वों को क्रमबद्ध करता है और इसकी एक तेज़ exist()विधि (बाइनरी खोज) होती है।

   • यदि तत्व लागू होते हैं Comparableऔर आप उसके TreeSetअनुसार क्रमबद्ध करना चाहते हैं :

     ElementClass.compareTo()विधि के साथ अनुकूल होना चाहिए ElementClass.equals(): देखें कि त्रय युद्ध करने के लिए दिखाई नहीं दे रहे हैं? (जावा सेट एक आइटम गायब है)

     TreeSet myElements = new TreeSet();
     
     // Do this for each element (implementing *Comparable*)
     myElements.add(nextElement);
     
     // *Alternatively*, if an array is forceably provided from other code:
     myElements.addAll(Arrays.asList(myArray));

   • अन्यथा, अपना खुद का उपयोग करें Comparator:

     class MyComparator implements Comparator<ElementClass> {
          int compareTo(ElementClass element1; ElementClass element2) {
               // Your comparison of elements
               // Should be consistent with object equality
          }
     
          boolean equals(Object otherComparator) {
               // Your equality of comparators
          }
     }
     
     
     // construct TreeSet with the comparator
     TreeSet myElements = new TreeSet(new MyComparator());
     
     // Do this for each element (implementing *Comparable*)
     myElements.add(nextElement);

   • अदायगी: कुछ तत्व के अस्तित्व की जाँच करें:

     // Fast binary search through sorted elements (performance ~ log(size)):
     boolean containsElement = myElements.exists(someElement);

Comments

क्यों परेशान TreeSet? HashSetतेज़ है (O (1)) और ऑर्डर करने की आवश्यकता नहीं है।

— सीन ओवेन

Answer 19

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

ArrayList<Integer> arrlist = new ArrayList<Integer>(8);

// use add() method to add elements in the list
arrlist.add(20);
arrlist.add(25);
arrlist.add(10);
arrlist.add(15);

boolean retval = arrlist.contains(10);
if (retval == true) {
    System.out.println("10 is contained in the list");
}
else {
    System.out.println("10 is not contained in the list");
}

Answer 20

निम्नलिखित का उपयोग करें ( contains()विधि ArrayUtils.in()इस कोड में है):

ObjectUtils.java

public class ObjectUtils{

    /**
     * A null safe method to detect if two objects are equal.
     * @param object1
     * @param object2
     * @return true if either both objects are null, or equal, else returns false.
     */
    public static boolean equals(Object object1, Object object2){
        return object1==null ? object2==null : object1.equals(object2);
    }

}

ArrayUtils.java

public class ArrayUtils{

    /**
     * Find the index of of an object is in given array, starting from given inclusive index.
     * @param ts  Array to be searched in.
     * @param t  Object to be searched.
     * @param start  The index from where the search must start.
     * @return Index of the given object in the array if it is there, else -1.
     */
    public static <T> int indexOf(final T[] ts, final T t, int start){
        for(int i = start; i < ts.length; ++i)
            if(ObjectUtils.equals(ts[i], t))
                return i;
        return -1;
    }

    /**
     * Find the index of of an object is in given array, starting from 0;
     * @param ts  Array to be searched in.
     * @param t  Object to be searched.
     * @return  indexOf(ts, t, 0)
     */
    public static <T> int indexOf(final T[] ts, final T t){
        return indexOf(ts, t, 0);
    }

    /**
     * Detect if the given object is in the given array.
     * @param ts  Array to be searched in.
     * @param t  Object to be searched.
     * @return  If indexOf(ts, t) is greater than -1.
     */
    public static <T> boolean in(final T[] ts, final T t){
        return indexOf(ts, t) > -1 ;
    }

}

जैसा कि आप ऊपर दिए गए कोड में देख सकते हैं, कि अन्य उपयोगिता विधियां हैं ObjectUtils.equals()और ArrayUtils.indexOf(), जिनका उपयोग अन्य स्थानों पर भी किया गया था।

Comments

मुझे इस चर्चा में शामिल होने के लिए बहुत देर हो गई है, लेकिन इस समस्या को हल करने में मेरे दृष्टिकोण के बाद, जब मैंने कुछ साल पहले इसका सामना किया था, तो पहले से ही यहां पोस्ट किए गए अन्य उत्तरों की तुलना में थोड़ा अलग था, मैं उस समय उस समाधान को पोस्ट कर रहा हूं जिसका मैंने उपयोग किया था। यहाँ पर, यदि किसी को यह उपयोगी लगता है।

— अभिषेक ओझा

Answer 21

इसे देखो

String[] VALUES = new String[] {"AB","BC","CD","AE"};
String s;

for(int i=0; i< VALUES.length ; i++)
{
    if ( VALUES[i].equals(s) )
    { 
        // do your stuff
    } 
    else{    
        //do your stuff
    }
}

Comments

यह काम नहीं करता है - यह उस प्रत्येक आइटम के elseलिए दर्ज होगा जो मेल नहीं खाता है (इसलिए यदि आप उस सरणी में "एबी" की तलाश कर रहे हैं, तो यह 3 बार वहां जाएगा, क्योंकि मानों में से 3 "एबी" नहीं हैं। ")।

— बर्नहार्ड बार्कर

Answer 22

Arrays.asList () -> तब इसमें कॉलिंग () विधि हमेशा काम करेगी, लेकिन एक खोज एल्गोरिथ्म बहुत बेहतर है क्योंकि आपको सरणी के चारों ओर एक हल्के सूची आवरण बनाने की आवश्यकता नहीं है, जो कि Arrays.asList () करता है। ।

public boolean findString(String[] strings, String desired){
   for (String str : strings){
       if (desired.equals(str)) {
           return true;
       }
   }
   return false; //if we get here… there is no desired String, return false.
}

Comments

Arrays.asListO (n) नहीं है। यह सिर्फ एक हल्का आवरण है। कार्यान्वयन पर एक नजर है।

— पैट्रिक पार्कर

Answer 23

यदि आप इसे संवेदनशील नहीं बनाना चाहते हैं

Arrays.stream(VALUES).anyMatch(s::equalsIgnoreCase);

Answer 24

उपयोग Array.BinarySearch(array,obj)दिए गए ऑब्जेक्ट को सरणी में या नहीं खोजने के लिए ।

उदाहरण:

if (Array.BinarySearch(str, i) > -1)` → true --exists

असत्य नहीं है

Comments

Array.BinarySearchऔर Array.FindIndex.NET विधियाँ हैं और जावा में मौजूद नहीं हैं।

— ataylor

@ataylor जावा में Arrays.binarySearch है। लेकिन आप सही हैं, कोई Arrays.findIndex

— mente नहीं है

यह ध्यान दिया जाना चाहिए: The array must be sorted prior to making this call. If it is not sorted, the results are undefined.

— डोरियन ग्रे

Answer 25

शुरू में असत्य पर सेट एक बूलियन बनाएँ। सरणी में प्रत्येक मान की जाँच करने के लिए एक लूप चलाएं और उस मान की तुलना करें जिसकी आप जाँच कर रहे हैं। यदि आपको कभी कोई मेल मिलता है, तो बूलियन को सही पर सेट करें और लूपिंग बंद करें। फिर दावा करते हैं कि बूलियन सच है।

Answer 26

जावा 8 विधेय परीक्षण विधि का उपयोग करने का प्रयास करें

इसका पूरा उदाहरण यहां दिया जा रहा है।

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class Test {
 public static final List<String> VALUES = Arrays.asList("AA", "AB", "BC", "CD", "AE");

 public static void main(String args[]) {
  Predicate<String> containsLetterA = VALUES -> VALUES.contains("AB");
  for (String i : VALUES) {

   System.out.println(containsLetterA.test(i));
  } 
 }
}

http://mytechnologythought.blogspot.com/2019/10/java-8-predicate-test-method-example.html

https://github.com/VipulGulhane1/java8/blob/master/Test.java

Answer 27

का उपयोग Spliterator अनावश्यक पीढ़ी को रोकता है List

boolean found = false;  // class variable

String search = "AB";
Spliterator<String> spl = Arrays.spliterator( VALUES, 0, VALUES.length );
while( (! found) && spl.tryAdvance(o -> found = o.equals( search )) );

found == trueअगर searchसरणी में समाहित है

यह आदिम के सरणियों के लिए काम करता है

public static final int[] VALUES = new int[] {1, 2, 3, 4};
boolean found = false;  // class variable

int search = 2;
Spliterator<Integer> spl = Arrays.spliterator( VALUES, 0, VALUES.length );
…

Answer 28

जैसा कि मैंने आदिम प्रकार बाइट और बाइट [] का उपयोग कर निम्न स्तर जावा के साथ काम कर रहा हूँ, सबसे अच्छा अब तक मुझे मिल से है बाइट्स-जावा https://github.com/patrickfav/bytes-java काम का जुर्माना टुकड़ा लगता है

Answer 29

आप इसे दो तरीकों से जांच सकते हैं

ए) सरणी को स्ट्रिंग में परिवर्तित करके और फिर आवश्यक स्ट्रिंग को .contains विधि द्वारा जांचें

 String a=Arrays.toString(VALUES);
    System.out.println(a.contains("AB"));
    System.out.println(a.contains("BC"));
    System.out.println(a.contains("CD"));
    System.out.println(a.contains("AE"));

बी) यह एक अधिक प्रभावी विधि है

 Scanner s=new Scanner(System.in);


   String u=s.next();
   boolean d=true;
    for(int i=0;i<VAL.length;i++)
    {
        if(VAL[i].equals(u)==d)
            System.out.println(VAL[i] +" "+u+VAL[i].equals(u));  

    }

Comments

स्ट्रिंग रूपांतरण बेतुका रूप से अक्षम है और समाधान गलत है, उदाहरण के लिए (",") सही है।

— एटूस