Java ตรวจสอบแบบง่ายว่า int array มี int หรือไม่

โดยทั่วไปเพื่อนของฉันบอกว่าฉันสามารถทำให้โค้ดสั้นลงได้โดยใช้วิธีอื่นในการตรวจสอบว่าอาร์เรย์ int มี int หรือไม่แม้ว่าเขาจะไม่บอกฉันว่ามันคืออะไร: 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);
}

มีใครช่วยฉันได้ไหม

ขอขอบคุณ.

นี่คือโซลูชัน Java 8

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

คุณสามารถใช้ArrayUtils.containsจากApache Commons Lang library.

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

มันเป็นเพราะผลตอบแทนArrays.asList(array) อาร์กิวเมนต์จะถือว่าเป็นค่าเดียวที่คุณต้องการตัด (คุณจะได้รับรายการอาร์เรย์ของ ints) ไม่ใช่เป็น varargList<int[]>array

หมายเหตุว่ามันจะทำงานร่วมกับวัตถุประเภท (ไม่ primitives):

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>และการทำกล่องอัตโนมัติไม่ทำงานที่นี่

ฝรั่งเสนอวิธีเสริมประเภทดึกดำบรรพ์ ในหมู่พวกเขามีวิธีการที่ใช้อาร์กิวเมนต์เดียวกับของคุณ

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

คุณอาจนำเข้าเวอร์ชัน guava แบบคงที่ได้เช่นกัน

ดูคำอธิบายของ Guava Primitives

วิธีอื่น:

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)

ฉันรู้ว่ามันสุดปลาย แต่ลองแทนInteger[]int[]

คุณสามารถแปลงอาร์เรย์ int ดั้งเดิมของคุณเป็นอาร์เรย์ของจำนวนเต็มโดยใช้โค้ด Java 8 ด้านล่าง

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

จากนั้นใช้contains()วิธีตรวจสอบว่ารายการมีองค์ประกอบเฉพาะหรือไม่

boolean containsElement = arrayElementsList.contains(key);

1. การใช้งานเพียงครั้งเดียว

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

2. ใช้ HashSet เพื่อพิจารณาประสิทธิภาพหากคุณใช้มากกว่าหนึ่งครั้ง

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

ลองสิ่งนี้:

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

สิ่งนี้ใช้ได้ใน java 8

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

คุณสามารถใช้java.util.Arraysคลาสเพื่อเปลี่ยนอาร์เรย์T[?]ในList<T>วัตถุด้วยวิธีการเช่นcontains:

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

ขึ้นอยู่กับว่าอาร์เรย์ของ int ของคุณมีขนาดใหญ่เพียงใดคุณจะได้รับประสิทธิภาพที่ดีขึ้นมากหากคุณใช้คอลเลกชันและ.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;
}
}

โซลูชัน # 1

เนื่องจากคำถามเดิมต้องการเพียงวิธีแก้ปัญหาที่เรียบง่าย (ไม่ใช่คำถามที่เร็วกว่า) นี่คือคำตอบแบบบรรทัดเดียว

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

คำอธิบาย: Javadoc ของArrays.toString()สถานะผลลัพธ์จะอยู่ในวงเล็บเหลี่ยมและองค์ประกอบที่อยู่ติดกันจะถูกคั่นด้วยอักขระ "," (เครื่องหมายจุลภาคตามด้วยช่องว่าง) เราจึงสามารถนับสิ่งนี้ได้ ก่อนอื่นเราแปลงarrayเป็นสตริงจากนั้นตรวจสอบว่าkeyมีอยู่ในสตริงนี้หรือไม่ แน่นอนว่าเราไม่สามารถยอมรับ "ตัวเลขย่อย" ได้ (เช่น "1234" มี "23") ดังนั้นเราต้องมองหารูปแบบที่keyนำหน้าด้วยวงเล็บเปิดหรือช่องว่างและตามด้วยวงเล็บปิดหรือลูกน้ำ

หมายเหตุ:รูปแบบ regexp ที่ใช้ยังจัดการกับตัวเลขเชิงลบอย่างเหมาะสม (ซึ่งการแทนค่าสตริงเริ่มต้นด้วยเครื่องหมายลบ)

โซลูชัน # 2

มีการโพสต์โซลูชันนี้แล้ว แต่มีข้อผิดพลาดดังนั้นฉันจึงโพสต์วิธีแก้ไขที่ถูกต้อง:

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

นอกจากนี้วิธีการแก้ปัญหานี้ยังมีผลข้างเคียง: มันปรับเปลี่ยนarray(เรียงลำดับ)

ลอง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;

              }


     }
}