Question

我有一个具有以下值的数组[1,2,3,4,5]

我希望在数组保持值1,2,3时打印一条消息。我该怎么做呢？：）

int[] myarray = new int[] {1,2,3,4,5};
if ( ... ) {
    System.out.println("This array is on fire!");

我想你可以这样做：

if (myarray[0]==1 && myarray[1]==2 && myarray[2]==3) {
     .....
    }

但如果可能的话，我会避免这种情况。我希望避免数组中的位置成为一个因素。

Answer 1

不幸的是Arrays.asList(myarray) int不适用Integer，如评论中所述，我忘了...... 因此，请使用Integer-List作为数组类型或首先转换为List<Integer> intList = new ArrayList<Integer>(); for (int index = 0; index < myarray.length; index++) { intList.add(myarray[index]); }：

if (intList.contains(1)  && intList.contains(2) && intList.contains(3)) {
...
}

指出here，然后按照此列表的旧解决方案：

{{1}}

Answer 2

您可以按如下方式编写实用程序方法（假设数组已预先排序，如果不是这样，请查看更新）：

public static boolean checkIfOnFire(int[] arr, int... nums) {
    for(int n : nums) {
        if(Arrays.binarySearch(arr, n) < 0) {
            return false;
        }
    }
    return true;
}

测试：

int[] myarray = new int[] {1,2,3,4,5};

System.out.println(checkIfOnFire(myarray, 1, 2, 3));
System.out.println(checkIfOnFire(myarray, 1, 2, 7));

打印：

true
false

<强>更新：

因为我正在使用Arrays.binarySearch。 checkIfOnFire方法的输入数组必须按照您的示例进行排序。

但是如果您的数组可能没有排序，则必须按如下方式修改checkIfOnFire：

public static boolean checkIfOnFire(int[] arr, int... nums) {
    //make a copy of the original array
    int[] copyArr = new int[arr.length];
    System.arraycopy(arr, 0, copyArr, 0, arr.length);
    //sort the copy
    Arrays.sort(copyArr);
    for(int n : nums) {
        if(Arrays.binarySearch(copyArr, n) < 0) {
            return false;
        }
    }
    return true;
}

Answer 3

它不漂亮，但如果你写了这样的东西：

public static boolean containsAll(int[] arrayToTest, int... values) {
    return asList(arrayToTest).containsAll(asList(values));     
}

public static List<Integer> asList(int[] values) {
    List<Integer> asList = new ArrayList<Integer>(values.length);
    for (int intVal : values) {
        asList.add(intVal);
    }
    return asList;
}

然后你可以这样称呼它：

int[] myarray = new int[] {1,2,3,4,5};
boolean result = containsAll(myarray, 1, 2, 3);

Answer 4

更长的解决方案，但只需要一次通过。可以轻松定制以检查任意数量的项目。

public boolean onFire(int array[])
{
    boolean found1 = false;
    boolean found2 = false;
    boolean found3 = false;
    for (int i : array) {
        if(i==1)
        {
            found1= true;
            continue;
        }
        if(i==2)
        {
            found2= true;
            continue;
        }
        if(i==3)
        {
            found3= true;
            continue;
        }
        if(found1&&found2&&found3)
            return true;
    }
    if(found1&&found2&&found3)
         return true;
    return false;       
}

Answer 5

如果你想要的int是非负的，小的，密集的;并且您不关心它们在ints中出现的顺序，然后：

BitSet wanted = new BitSet();
wanted.set(1);
wanted.set(2);
wanted.set(3);

for (int i : ints) {
  wanted.clear(i);
}

boolean hasAll = wanted.cardinality() == 0;

如果您关心订单，那么您可能想测试一个数组是否是另一个数组的子序列：Get the list of index in subsequence matching

Answer 6

要在数组中以任何顺序查找元素，请先将您感兴趣的元素添加到哈希映射中。然后看看它们是否在数组中。

运行时：O（m）添加到map，迭代数组O（n），m＆lt; ñ。总O（n）。

在下面的代码中，调用main（）来运行我写的样本。

 Map<Integer,Boolean> lookFor = new HashMap<Integer,Boolean>();

 void main(){
    int[] array = new int[] {1,2,3,4,5};
    addMeaningfulValues();
    System.out.println( arrayHasValues(lookFor, array) );
 }

 void addMeaningfulValues(){
    lookFor.put(1,false);
    lookFor.put(2,false);
    lookFor.put(3,false);
 }

 boolean arrayHasValues(Map<Integer,Boolean> values, int [] array){
    //mark entries found in array
    for (int i=0; i<array.length; i++){
        if (values.containsKey(array[i])){
            values.put(array[i], true);
        }
    }

    //go over map entries and see if they have all been found in the array
    for (Boolean crtValue: values.values()){
        if (!crtValue){
            return false;
        }
    }

    return true;
 }

Answer 7

将其放入集合或列表中，并为您要查找的每个项目执行包含。

Integer[] myarray = {1,2,3,4,5};
List<Integer> intList = Arrays.asList(myArray);

if (intList.contains(1) && intList.contains(2) && intList.contains(3))
    // print your message

Answer 8

在Collection接口中使用containsAll方法。

Collection<Integer> coll = new ArrayList<Integer>();
Collection<Integer> test = new ArrayList<Integer>();

for( int i=1; i<=5; i++)
    coll.add(i);

test.add(1);
test.add(2);
test.add(3);

System.out.println(coll.containsAll(test));

Answer 9

由于集合的广泛使用，java被视为集合是一个框架，每个由一个方法组成的集合包含（Object o）来检查集合中是否存在元素。

首先我们可以将int []数组转换为List

List<Integer> list=new ArrayList<Integer>();
        int[] myarray = new int[] {1,2,3,4,5};
        for(int i=0;i<myarray.length;i++)
        {
            list.add(myarray[i]);           
        }

请使用list.contains（Object o）检查其是否存在

 for(Integer i:list)
        {
            if(list.contains(1)&&list.contains(2)&&list.contains(3))
            {
                flag=true;
                break;
            }

        }

并查看下面的完整代码

import java.io.IOException;
import java.util.ArrayList;

import java.util.List;



public class Test {


    public static void main(String[] args) throws IOException {
        boolean flag=false;
        List<Integer> list=new ArrayList<Integer>();
        int[] myarray = new int[] {1,2,3,4,5};
        for(int i=0;i<myarray.length;i++)
        {
            list.add(myarray[i]);           
        }
        for(Integer i:list)
        {
            if(list.contains(1)&&list.contains(2)&&list.contains(3))
            {
                flag=true;
                break;
            }

        }

        if(flag)
        {
            System.out.println("yes contain");

        }
        else
            System.out.println("NO");

    }

}

在if语句中添加数组异常

9 个答案: