අරාවෙහි ජාවා හි විශේෂිත අගයක් තිබේද යන්න තීරණය කරන්නේ කෙසේද?

මට එවැනි String[]අගයන් ඇත:

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

ලබා දී String s, එහි යන්න පරීක්ෂා කිරීමේ හොඳ ක්රමයකි VALUESඅඩංගු s?

Arrays.asList(yourArray).contains(yourValue)

අවවාදයයි: මෙය ප්‍රාථමිකයන්ගේ අරා සඳහා ක්‍රියා නොකරයි (අදහස් බලන්න).

සිට java-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);

ජාවා එස්ඊ 9 සඳහා සංක්ෂිප්ත යාවත්කාලීන කිරීම

යොමු අරා නරකයි. මෙම නඩුව සඳහා අපි කට්ටලයකට පසුව සිටිමු. ජාවා එස්ඊ 9 සිට අපට තිබේ Set.of.

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

"නූල් ලබා දී ඇති විට, VALUES හි s අඩංගු දැයි පරීක්ෂා කිරීමට හොඳ ක්‍රමයක් තිබේද?"

VALUES.contains(s)

ඕ (1).

මෙම අයිතිය වර්ගය , හා අණුවල පැවැත්ම , සාමාන්ය (1) හා සංක්ෂිප්ත . ලස්සනයි. *

මුල් පිළිතුරු විස්තර

ආරම්භ කිරීම සඳහා කේතය ඉවත් කිරීමට පමණි. අප සතුව (නිවැරදි කර ඇත):

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

මෙය විකෘති ස්ථිතිකයක් වන අතර එය FindBugs ඔබට ඉතා නරක යැයි කියනු ඇත. සංඛ්‍යාලේඛන වෙනස් නොකරන්න සහ වෙනත් කේත වලටද එසේ කිරීමට ඉඩ නොදෙන්න. අවම වශයෙන්, ක්ෂේත්‍රය පෞද්ගලික විය යුතුය:

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- එය ප්‍රසිද්ධියට පත් කළ හැකිය.)

(* වෙළඳ නාමය ගැන තව ටිකක් කියතොත්, එකතු කිරීමේ API අනාවැකි ලෙස තවමත් වෙනස් කළ නොහැකි එකතු කිරීමේ වර්ග නැතිවී ඇති අතර මගේ රුචි අරුචිකම් සඳහා වාක්‍ය ඛණ්ඩය තවමත් වාචික නොවේ.)

ඔබට Apache Commons LangArrayUtils.contains වෙතින් භාවිතා කළ හැකිය

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

මෙම ක්‍රමය නැවත පැමිණෙන බව සලකන්න falseසම්මත කළ අරාව නම්null .

සියලු වර්ගවල ප්‍රාථමික අරා සඳහා ක්‍රම තිබේ.

උදාහරණයක්:

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

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

එය අතින් ක්‍රියාත්මක කරන්න:

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

අරාවෙහි වටිනාකමක් තිබේදැයි පරීක්ෂා කිරීමට විවිධ ක්‍රම හතරක්

1. භාවිතා කිරීම List:

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

2. භාවිතා කිරීම Set:

   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():

   පහත කේතය වැරදියි, එය සම්පූර්ණත්වය සඳහා මෙහි ලැයිස්තු ගත කර ඇත. binarySearch()වර්ග කළ අරා මත පමණක් භාවිතා කළ හැකිය. ප්‍රති result ලය පහතින් අමුතු බව ඔබට පෙනී යනු ඇත. අරාව වර්ග කළ විට මෙය හොඳම විකල්පයයි.

   public static boolean binarySearch(String[] arr, String targetValue) {  
       return Arrays.binarySearch(arr, targetValue) >= 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

අරාව වර්ග කර නොමැති නම්, ඔබට සෑම දෙයක්ම නැවත කියවීමට සිදු වන අතර ඒ සෑම එකක්ම සමාන කිරීමට ඇමතුමක් ලබා ගත යුතුය.

අරාව වර්ග කර ඇත්නම්, ඔබට ද්විමය සෙවීමක් කළ හැකිය, අරා වල එකක් තිබේ පන්තියේ .

පොදුවේ ගත් කල, ඔබ සාමාජිකත්ව චෙක්පත් විශාල ප්‍රමාණයක් කිරීමට යන්නේ නම්, ඔබට අවශ්‍ය වන්නේ සෑම දෙයක්ම අර්‍ගයක නොව කට්ටලයක ගබඩා කිරීමයි.

එය වටින දේ සඳහා මම වේගය සඳහා යෝජනා 3 සංසන්දනය කරමින් පරීක්ෂණයක් පැවැත්වුවෙමි. මම අහඹු නිඛිල උත්පාදනය කර ඒවා නූල් බවට පරිවර්තනය කර ඒවා අරාවකට එකතු කළෙමි. මම පසුව හැකි උපරිම අංකය / නූලක් සෙව්වෙමි, එය නරකම අවස්ථාවකි asList().contains().

10K අරා ප්‍රමාණයක් භාවිතා කරන විට ප්‍රති results ල වූයේ:

වර්ග කිරීම සහ සෙවීම: 15
ද්විමය සෙවීම: 0
asList.contains: 0

100K අරා භාවිතා කරන විට ප්‍රති results ල වූයේ:

වර්ග කිරීම සහ සෙවීම: 156
ද්විමය සෙවීම: 0
asList.contains: 32

එබැවින් අරාව වර්ග කළ අනුපිළිවෙලින් නිර්මාණය කර ඇත්නම් ද්විමය සෙවීම වේගවත්ම වේ, එසේ නොමැති නම් එය asList().containsයා යුතු මාර්ගය වේ. ඔබට බොහෝ සෙවීම් තිබේ නම්, ඔබට ද්විමය සෙවුම භාවිතා කළ හැකි වන පරිදි අරාව වර්ග කිරීම වටී. ඒ සියල්ල ඔබගේ යෙදුම මත රඳා පවතී.

බොහෝ දෙනා අපේක්ෂා කරන ප්‍රති results ල ඒවා යැයි මම සිතමි. පරීක්ෂණ කේතය මෙන්න:

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

ඉක්මන් අරාව ආරම්භක වාක්‍ය ඛණ්ඩය භාවිතා කරනවා වෙනුවට, ඔබට Arrays.asList ක්‍රමය භාවිතා කරමින් ඒ හා සමාන ආකාරයකින් ලැයිස්තුවක් ලෙස ආරම්භ කළ හැකිය, උදා:

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

එවිට ඔබට කළ හැකිය (ඉහත පරිදි):

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

ජාවා 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);
}

අගය සඳහා ද්විමය සෙවීමක් සිදු කිරීමට ඔබට අරා පන්තිය භාවිතා කළ හැකිය . ඔබේ අරාව වර්ග කර නොමැති නම්, අරාව වර්ග කිරීම සඳහා ඔබට එකම පන්තියේ වර්ග කිරීමේ කාර්යයන් භාවිතා කිරීමට සිදුවේ, ඉන්පසු එය හරහා සොයන්න.

ObStupidAnswer (නමුත් මම හිතන්නේ මෙතන කොහේ හරි පාඩමක් තියෙනවා):

enum Values {
    AB, BC, CD, AE
}

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

ඇත්ත වශයෙන්ම, ටොම් හෝවින් යෝජනා කළ පරිදි ඔබ හැෂ්සෙට් <ස්ට්‍රිං> භාවිතා කරන්නේ නම්, වර්ග කිරීම ගැන කරදර විය යුතු නැත, ඔබේ වේගය කලින් නියම කර ඇති අරාව මත ද්විමය සෙවුමට සමාන වේ, බොහෝ විට ඊටත් වඩා වේගවත් වේ.

ඒ සියල්ල රඳා පවතින්නේ ඔබේ කේතය සකසා ඇති ආකාරය මත ය, පැහැදිලිවම, නමුත් මා සිටින තැන සිට ඇණවුම වනුයේ:

මත unsorted අරා:

1. හැෂ්සෙට්
2. asList
3. වර්ග කිරීම සහ ද්විමය

වර්ග කළ අරාව මත:

1. හැෂ්සෙට්
2. ද්විමය
3. asList

ඉතින් කෙසේ හෝ ජයග්‍රහණය සඳහා හැෂ්සෙට්.

ඔබට ගූගල් එකතු කිරීමේ පුස්තකාලය තිබේ නම්, ටොම්ගේ පිළිතුර ImmutableSet (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");

හැකි එක් විසඳුමක්:

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

සංවර්ධකයින් බොහෝ විට කරන්නේ:

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;

පළමුවැන්න දෙවන එකට වඩා කියවිය හැකි ය.

සරල ලූපයක් භාවිතා කිරීම මෙය කිරීමේ වඩාත් කාර්යක්ෂම ක්‍රමයයි.

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

Programcreek අනුග්‍රහයෙනි

දී ජාවා 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);

1. සීමිත දිගකින් යුත් අරා සඳහා පහත සඳහන් දෑ භාවිතා කරන්න ( කැමරර් විසින් ලබා දී ඇති පරිදි ). නැවත නැවත පරීක්ෂා කිරීම සඳහා මෙය මන්දගාමී වේ, විශේෂයෙන් දිගු අරා සඳහා (රේඛීය සෙවීම).

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

2. වේගවත් ක්‍රියාකාරිත්වය සඳහා ඔබ විශාල මූලද්‍රව්‍ය සමූහයකට නැවත නැවත පරීක්ෂා කරන්නේ නම්

   • අරාව යනු වැරදි ව්‍යුහයකි. A භාවිතා කර එයට 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);

පහත සඳහන් දෑ භාවිතා කරන්න ( 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(), වෙනත් ස්ථානවල ද භාවිතා කර ඇති බවත්.

මේක උත්සාහ කරන්න:

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

මෙය පරීක්ෂා කරන්න

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

ඔබට එය සංවේදී වීමට අවශ්‍ය නැතිනම්

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

භාවිත Array.BinarySearch(array,obj)ලබා දී ඇති වස්තුව අරාවෙහි සොයා ගැනීමට .

උදාහරණයක්:

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

false --not පවතී

මුලින් අසත්‍ය ලෙස සකසා ඇති බූලියන් සාදන්න. අරාවෙහි ඇති සෑම අගයක්ම පරීක්ෂා කිරීමට ලූපයක් ධාවනය කර ඔබ පරීක්ෂා කරන අගය සමඟ සසඳන්න. ඔබට කවදා හෝ තරඟයක් ලැබුනේ නම්, බූලියන් සත්‍ය ලෙස සකසා ලූප කිරීම නවත්වන්න. එවිට බූලියන් සත්‍ය බව ප්‍රකාශ කරන්න.

ජාවා 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://mytechnology thoughtt.blogspot.com/2019/10/java-8-predicate-test-method-example.html

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

a භාවිතා කිරීම a 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 == truesearchඅරාවෙහි අඩංගු නම්

මෙම කරන්නේ සැලකෙතත් අරා වැඩ

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

මම ප්‍රාථමික මට්ටමේ බයිට් සහ බයිට් භාවිතා කරමින් පහත් මට්ටමේ ජාවා සමඟ ගනුදෙනු කරන විට, මට මෙතෙක් ලැබී ඇති හොඳම දේ බයිට්ස්-ජාවා වෙතින් ලබා ගත හැකිය https://github.com/patrickfav/bytes-java කදිම කෘතියක් ලෙස පෙනේ

ඔබට එය ක්‍රම දෙකකින් පරීක්ෂා කළ හැකිය

අ) අරාව නූල් බවට පරිවර්තනය කිරීමෙන් පසුව .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));  

    }