java - array in c++




একটি অ্যারের জাভা একটি নির্দিষ্ট মান রয়েছে কি না তা নির্ধারণ কিভাবে? (17)

আমার কাছে একটি String[] আছে যেমন:

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

প্রদত্ত String s , VALUES s আছে কিনা পরীক্ষা করার একটি ভাল উপায় আছে?


  1. সীমিত দৈর্ঘ্য অ্যারে জন্য নিম্নলিখিত ব্যবহার ( ক্যামিকার দ্বারা প্রদত্ত )। এটি পুনরাবৃত্তি চেকগুলির জন্য ধীর, বিশেষ করে আর অ্যারের জন্য (রৈখিক অনুসন্ধান)।

     Arrays.asList(...).contains(...)
  2. দ্রুত কর্মক্ষমতা জন্য আপনি বার বার বড় উপাদান সেট বিরুদ্ধে চেক

    • একটি অ্যারের ভুল গঠন। একটি TreeSet ব্যবহার করুন এবং এটি প্রতিটি উপাদান যোগ করুন। এটি উপাদানগুলিকে সাজায় এবং দ্রুত exist() পদ্ধতি (বাইনারি অনুসন্ধান)।

    • যদি উপাদান Comparable প্রয়োগ করে এবং আপনি TreeSet অনুসারে TreeSet চান:

      ElementClass.compareTo() পদ্ধতিটি ElementClass.compareTo() সাথে সামঞ্জস্যপূর্ণ হওয়া আবশ্যক: Triads দেখানোর জন্য আপ দেখাচ্ছে না? (জাভা সেট একটি আইটেম অনুপস্থিত)

      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);

Arrays.asList () -> তারপরে রয়েছে () পদ্ধতিটি কল করা সর্বদা কাজ করবে, তবে একটি অনুসন্ধান অ্যালগরিদমটি অনেক ভাল, যেহেতু আপনাকে অ্যারের চারপাশে লাইটওয়েট তালিকা wrapper তৈরি করতে হবে না, যা 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.
}

অ্যারে সাজানো হয় না, আপনি সবকিছু উপর পুনরাবৃত্তি এবং প্রতিটি উপর সমান একটি কল করতে হবে।

অ্যারে সাজানো হয়, আপনি একটি বাইনারি অনুসন্ধান করতে পারেন, Arrays ক্লাসে একটি আছে।

সাধারণভাবে বলতে গেলে, যদি আপনি অনেক সদস্যের চেক পরীক্ষা করতে যাচ্ছেন তবে আপনি একটি সেটে সবকিছু সঞ্চয় করতে চান, একটি অ্যারের মধ্যে নয়।


আপনি Apache Commons Lang থেকে ArrayUtils.contains ব্যবহার করতে পারেন

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

উল্লেখিত অ্যারে null যদি এই পদ্ধতি false ফেরত।

সব ধরনের আদিম অ্যারে জন্য উপলব্ধ পদ্ধতি আছে।

উদাহরণ:

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

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

আমি এই আলোচনায় যোগ দেয়ার জন্য দেরিতে আছি, কিন্তু এই সমস্যার সমাধান করার ক্ষেত্রে আমার দৃষ্টিভঙ্গির পরে, যখন আমি কয়েক বছর আগে এটির মুখোমুখি হয়েছিলাম, এখানে ইতিমধ্যে পোস্ট করা অন্যান্য উত্তরগুলির তুলনায় কিছুটা ভিন্ন ছিল, আমি যে সমাধানটি ব্যবহার করেছি সেটি পোস্ট করছি, এখানে, যদি কেউ এটি দরকারী খুঁজে পায়: (এই ArrayUtils.in() 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()এটি অন্যান্য স্থানেও ব্যবহৃত হয়।


আমি শুধু হাত দ্বারা এটি বাস্তবায়ন করার জন্য সুপারিশ কোন এক বিস্মিত:

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 বড় হয় তবে এটি শুধুমাত্র একবারের জন্য এই শর্তটির মূল্যায়ন করার জন্য আরও কার্যকর এবং ফলাফলের ভিত্তিতে আমরা লুপের ভিতরে একটি সরলীকৃত / দ্রুত অবস্থা ব্যবহার করতে পারি। উন্নত 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;
}

একটি সহজ লুপ ব্যবহার করে এটি করার সবচেয়ে কার্যকর উপায়।

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

Programcreek সৌজন্যে


এটা চেষ্টা কর:

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");
}

তার মূল্যের জন্য আমি গতির জন্য 3 টি পরামর্শ তুলনা করে একটি পরীক্ষা চালাচ্ছিলাম। আমি র্যান্ডম পূর্ণসংখ্যা উত্পন্ন, তাদের একটি স্ট্রিং রূপান্তর এবং একটি অ্যারে তাদের যোগ করা। আমি তখন সর্বাধিক সম্ভাব্য নম্বর / স্ট্রিং অনুসন্ধান করেছি, যা asList () এর জন্য সবচেয়ে খারাপ কেস দৃশ্যকল্প হবে।

10K অ্যারের আকার ব্যবহার করার সময় ফলাফলগুলি কোথায়:

Sort & Search   : 15
Binary Search   : 0
asList.contains : 0

একটি 100K অ্যারে ব্যবহার করার সময় ফলাফল যেখানে:

Sort & Search   : 156
Binary Search   : 0
asList.contains : 32

সুতরাং অ্যারে সাজানো ক্রম তৈরি করা হয় তাহলে বাইনারি অনুসন্ধান দ্রুততম হয়, অন্যথায় asList ()। যেতে হবে উপায়। যদি আপনার অনেক অনুসন্ধান থাকে তবে অ্যারের সাজানোর জন্য এটি উপযুক্ত হতে পারে যাতে আপনি বাইনারি অনুসন্ধানটি ব্যবহার করতে পারেন। এটা সব আপনার আবেদন উপর নির্ভর করে।

আমি মনে করি যারা ফলাফল অধিকাংশ মানুষ আশা করবে। এখানে পরীক্ষা কোড:

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));
    }
}

দ্রুত অ্যারে প্রাথমিকীকরণ স্যাটাক্স ব্যবহার করার পরিবর্তে এটি অ্যারে.এল্যাস্ট পদ্ধতি ব্যবহার করে সরাসরি একটি তালিকা হিসাবে এটি শুরু করতে পারে যেমন:

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

তারপরে আপনি (উপরে মত) করতে পারেন: STRINGS.contains("the string you want to find");


বিকাশকারী প্রায়ই কাজ করে:

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;

প্রথম এক দ্বিতীয় চেয়ে আরও পঠনযোগ্য।


যদি আপনার Google সংগ্রহ লাইব্রেরি থাকে তবে টম এর উত্তরটি ইমিউটেবলসেট (http://google-collections.googlecode.com/svn/trunk/javadoc/com/google/common/collect/ImmutableSet.html) ব্যবহার করে অনেক সহজ করা যেতে পারে।

এই সত্যিই শুরু সূচনা থেকে ক্লাস্টার অনেক মুছে ফেলা

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

একটি অ্যারে একটি মান রয়েছে কিনা তা পরীক্ষা করার জন্য চারটি ভিন্ন উপায়

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

Array.BinarySearch(array,obj) মধ্যে প্রদত্ত বস্তু খুঁজে বের করার জন্য অ্যারে বা Array.BinarySearch(array,obj) ব্যবহার করুন। উদা:

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

মিথ্যা - বিদ্যমান নেই


এটা যাচাই কর

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
    }
}

যদি আপনি এটি কেস সংবেদনশীল হতে চান না

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

Arrays.asList(yourArray).contains(yourValue)

সতর্কতা: এই primitives অ্যারের জন্য কাজ করে না (মন্তব্য দেখুন)।

java-8 থেকে এখন আপনি স্ট্রিম ব্যবহার করতে পারেন।

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

IntStream একটি অ্যারে, double বা LongStream যথাক্রমে IntStream , IntStream বা long IntStream একটি মান ব্যবহার রয়েছে কিনা তা পরীক্ষা করতে।

উদাহরণ

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






arrays