Java, Simplified memeriksa apakah int array berisi int

Pada dasarnya teman saya telah mengatakan bahwa saya dapat membuat kode saya lebih pendek dengan menggunakan cara yang berbeda untuk memeriksa apakah sebuah array int berisi int, meskipun dia tidak akan memberi tahu saya apa itu: P.

Arus:

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

Saya juga mencoba ini, meskipun selalu mengembalikan false karena beberapa alasan.

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

Adakah yang dapat membantu saya?

Terima kasih.

Inilah solusi Java 8

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

Anda bisa menggunakan ArrayUtils.containsdari Apache Commons Lang library.

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

Itu karena Arrays.asList(array)pengembalian List<int[]>. arrayargumen diperlakukan sebagai satu nilai yang ingin Anda bungkus (Anda mendapatkan daftar array int), bukan sebagai vararg.

Perhatikan bahwa ini berfungsi dengan tipe objek (bukan primitif):

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

atau bahkan:

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

Tetapi Anda tidak dapat melakukannya List<int>dan autoboxing tidak berfungsi di sini.

Jambu biji menawarkan metode tambahan untuk tipe primitif. Di antara mereka, metode berisi yang mengambil argumen yang sama seperti milik Anda.

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

Anda mungkin juga mengimpor versi jambu biji secara statis.

Lihat Dijelaskan Primitif Jambu Biji

Cara berbeda:

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

Ini mengubah larik yang diteruskan. Anda akan memiliki opsi untuk menyalin larik dan mengerjakan larik asli, yaitu. int[] sorted = array.clone();
Tapi ini hanyalah contoh kode singkat. Runtime adalah O(NlogN)sementara cara AndaO(N)

Aku tahu ini sudah sangat larut, tapi coba Integer[]saja int[].

1. penggunaan satu kali

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

2. Gunakan HashSet untuk pertimbangan kinerja jika Anda menggunakan lebih dari sekali.

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

Coba ini:

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

Anda dapat mengonversi larik int primitif Anda ke dalam daftar larik Integer menggunakan kode Java 8 di bawah ini,

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

Dan kemudian gunakan contains()metode untuk memeriksa apakah daftar berisi elemen tertentu,

boolean containsElement = arrayElementsList.contains(key);

ini bekerja di java 8

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

Anda dapat menggunakan java.util.Arrayskelas untuk mengubah array T[?]dalam List<T>objek dengan metode seperti contains:

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

Bergantung pada seberapa besar array int Anda, Anda akan mendapatkan kinerja yang jauh lebih baik jika Anda menggunakan koleksi dan .containsdaripada melakukan iterasi pada array satu elemen pada satu waktu:

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

Solusi # 1

Karena pertanyaan awal hanya menginginkan solusi yang disederhanakan (dan bukan yang lebih cepat), berikut adalah solusi satu baris:

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

Penjelasan: Javadoc Arrays.toString()menyatakan hasil diapit tanda kurung siku dan elemen yang berdekatan dipisahkan oleh karakter "," (koma diikuti oleh spasi). Jadi kita bisa mengandalkan ini. Pertama kami mengonversi arraymenjadi string, dan kemudian kami memeriksa apakah keyada dalam string ini. Tentu saja kami tidak dapat menerima "sub-angka" (misalnya "1234" berisi "23"), jadi kami harus mencari pola di manakey diawali dengan kurung buka atau spasi, dan diikuti dengan tanda kurung tutup atau koma.

catatan: Pola regexp yang digunakan juga menangani angka negatif dengan benar (yang representasi stringnya dimulai dengan tanda minus).

Solusi # 2

Solusi ini sudah diposting tetapi berisi kesalahan, jadi saya memposting solusi yang benar:

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

Juga solusi ini memiliki efek samping: ia memodifikasi array(mengurutkannya).

Coba Integer.parseInt()lakukan ini .....

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;

              }


     }
}