问题
Basically my mate has been saying that I could make my code shorter by using a different way of checking if an int array contains an int, although he won't tell me what it is :P.
Current:
public boolean contains(final int[] array, final int key) {
for (final int i : array) {
if (i == key) {
return true;
}
}
return false;
}
Have also tried this, although it always returns false for some reason.
public boolean contains(final int[] array, final int key) {
return Arrays.asList(array).contains(key);
}
Could anyone help me out?
Thank you.
回答1:
Here is Java 8 solution
public static boolean contains(final int[] arr, final int key) {
return Arrays.stream(arr).anyMatch(i -> i == key);
}
回答2:
You could simply use ArrayUtils.contains from Apache Commons Lang library.
public boolean contains(final int[] array, final int key) {
return ArrayUtils.contains(array, key);
}
回答3:
It's because Arrays.asList(array) return List<int[]>. array argument is treated as one value you want to wrap (you get list of arrays of ints), not as vararg.
Note that it does work with object types (not primitives):
public boolean contains(final String[] array, final String key) {
return Arrays.asList(array).contains(key);
}
or even:
public <T> boolean contains(final T[] array, final T key) {
return Arrays.asList(array).contains(key);
}
But you cannot have List<int> and autoboxing is not working here.
回答4:
Guava offers additional methods for primitive types. Among them a contains method which takes the same arguments as yours.
public boolean contains(final int[] array, final int key) {
return Ints.contains(array, key);
}
You might as well statically import the guava version.
See Guava Primitives Explained
回答5:
I know it's super late, but try Integer[] instead of int[].
回答6:
A different way:
public boolean contains(final int[] array, final int key) {
Arrays.sort(array);
return Arrays.binarySearch(array, key) >= 0;
}
This modifies the passed-in array. You would have the option to copy the array and work on the original array i.e. int[] sorted = array.clone();
But this is just an example of short code. The runtime is O(NlogN) while your way is O(N)
回答7:
1.one-off uses
List<T> list=Arrays.asList(...)
list.contains(...)
2.use HashSet for performance consideration if you use more than once.
Set <T>set =new HashSet<T>(Arrays.asList(...));
set.contains(...)
回答8:
this worked in java 8
public static boolean contains(final int[] array, final int key)
{
return Arrays.stream(array).anyMatch(n->n==key);
}
回答9:
You can use java.util.Arrays class to transform the array T[?] in a List<T> object with methods like contains:
Arrays.asList(int[] array).contains(int key);
回答10:
Try this:
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);
}
回答11:
You can convert your primitive int array into an arraylist of Integers using below Java 8 code,
List<Integer> arrayElementsList = Arrays.stream(yourArray).boxed().collect(Collectors.toList());
And then use contains() method to check if the list contains a particular element,
boolean containsElement = arrayElementsList.contains(key);
回答12:
Depending on how large your array of int will be, you will get much better performance if you use collections and .contains rather than iterating over the array one element at a time:
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;
}
}
回答13:
Solution #1
Since the original question only wants a simplified solution (and not a faster one), here is a one-line solution:
public boolean contains(int[] array, int key) {
return Arrays.toString(array).matches(".*[\\[ ]" + key + "[\\],].*");
}
Explanation: Javadoc of Arrays.toString() states the result is enclosed in square brackets and adjacent elements are separated by the characters ", " (a comma followed by a space). So we can count on this. First we convert array to a string, and then we check if key is contained in this string. Of course we cannot accept "sub-numbers" (e.g. "1234" contains "23"), so we have to look for patterns where the key is preceded with an opening bracket or a space, and followed by a closing bracket or a comma.
Note: The used regexp pattern also handles negative numbers properly (whose string representation starts with a minus sign).
Solution #2
This solution is already posted but it contains mistakes, so I post the correct solution:
public boolean contains(int[] array, int key) {
Arrays.sort(array);
return Arrays.binarySearch(array, key) >= 0;
}
Also this solution has a side effect: it modifies the array (sorts it).
回答14:
Try Integer.parseInt() to do this.....
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;
}
}
}
来源：https://stackoverflow.com/questions/12020361/java-simplified-check-if-int-array-contains-int