Java 如何检查数组中是否已存在元素

我将值从一个页面发送到另一个页面，我想存储我发送的值，然后将我发送的值与我已经发送的值进行比较，即保存的值。在将值存储到持久对象的数组中，然后将值与另一个数组进行比较时，我面临一些问题，谁能告诉我如何检查数组中是否已经存在值，我正在给出代码，请帮助

package com.firstBooks.series.db;

import java.util.Random;

import net.rim.device.api.system.PersistentObject;
import net.rim.device.api.system.PersistentStore;
import net.rim.device.api.util.Arrays;
import net.rim.device.api.util.Persistable;
import com.firstBooks.series.db.parser.XMLParser;
import com.firstBooks.series.ui.managers.TopManager;
import com.firstBooks.series.ui.screens.TestScreen;
public class DBMain implements Persistable{

    public static String answer = "";
    public static String selectedAnswer = "";
    public static Question curQuestion;

    public static int currQuesNumber = 1;
    public static int correctAnswerCount = -1;
    static int curQuesnew;
    static int quesCount=-1;
    static int xyz;
    static int j=0;
    public static int totalNumofQuestions = Question.totques;
    public static int quesNum[] = new int[XMLParser.questionList.size()];
    static PersistentObject qStore;
    static PersistentObject curQues;
    static PersistentObject pQues;
    static PersistentObject curans;
    static PersistentObject disques;
    static PersistentObject restques;
    static int a ;
    static int b;
    static int[] c ;
    static int[] d ;
    static int pques;
    static int cans;
    static int[] dques;
    static int[] rques;

    static {
        qStore = PersistentStore.getPersistentObject(0x33010065d24c7883L);
        curQues = PersistentStore.getPersistentObject(0x33010064d24c7883L);
        pQues   = PersistentStore.getPersistentObject(0xbd7460a5b4f9890aL);
        curans  = PersistentStore.getPersistentObject(0xc5c065a3ae1bec21L);
        disques = PersistentStore.getPersistentObject(0xbf8118045165a07aL);
    }

    static{ 
         initialize();
    }


    public static void initialize() {

        //int quesNum[] = new int[XMLParser.questionList.size()];

        Random rgen = new Random(); // Random number generator
        //int a=Integer.parseInt(TopManager.quesNumber);
        //System.out.println("The value of AAAAAAA is...."+a);
        // --- Initialize the array
        for (int i = 0; i < quesNum.length; i++) {
            quesNum[i] = i;
        }

        // --- Shuffle by exchanging each element randomly
        for (int i=0; i< quesNum.length; i++) {
            int randomPosition = rgen.nextInt(quesNum.length);
            int temp = quesNum[i];
            quesNum[i] = quesNum[randomPosition];
            quesNum[randomPosition] = temp;

        }

            synchronized (qStore) {

            qStore.setContents(quesNum);
        qStore.commit();
        }
        }


    public static int getQuestionNumber() {


        //int quesCount;
           //quesCount++;
        //synchronized (curQues) {
            //quesCount = Integer.parseInt((String)curQues.getContents());
        //}
            quesCount++;
           synchronized (curans) {

                int b=Integer.parseInt(TopManager.corrCount);
                curans.setContents(b+"");
                curans.commit();

            }
    //int quesNum[];

        synchronized (qStore) {
            quesNum=(int[]) qStore.getContents();
            System.out.println("The value of question is ...."+quesNum.length);
    }


        synchronized (pQues) {

            int a=Integer.parseInt(TopManager.quesNumber);
            pQues.setContents(a+"");
            pQues.commit();

        }

        if (quesNum!=null && quesCount < quesNum.length) {

            synchronized (curQues) {

                curQuesnew=quesNum[quesCount];
                curQues.setContents(curQuesnew+"");
                curQues.commit();   
            }

            synchronized (disques) {
             c[j]=TestScreen.quesNumber;
             System.out.println("Astala vistaaaaaaaaaaaaa"+c);
                disques.setContents(c+"");
                disques.commit();
              }
            synchronized (disques) {
                dques[j]=Integer.parseInt((String)disques.getContents());
                System.out.println("valueee is.........."+dques);
             }

        for(int k=0;k<dques.length;k++){
         if(quesNum[quesCount]!=dques[k]){
         System.out.println("ghijyghfhgfhfhgfhgfhgfhgfhgddkjklmn");
          xyz=quesNum[quesCount];
         }
         j++;
        }


         return xyz;


    } else {
            initialize();
            quesCount = -1;
            return getQuestionNumber();
        }

    }


    public  static int getpresentQuestionNumber(){


        synchronized (pQues) {
            pques=Integer.parseInt((String)pQues.getContents());

    }
        return pques;
 }

  public  static int getCorrectanswerNumber(){
     synchronized (curans) {
            cans=Integer.parseInt((String)curans.getContents());
            }
        return cans;
 }



  public static int getCurrQuestionNumber() {
        synchronized (curQues) {
            return Integer.parseInt((String)curQues.getContents());
            //return curQuesnew;
            //curQuesnew=(int[]) curQues.getContents();
            //return curQuesnew[quesCount]; 
        }
    }
}

package com.firstBooks.series.db；
导入java.util.Random；
导入net.rim.device.api.system.PersistentObject；
导入net.rim.device.api.system.PersistentStore；
导入net.rim.device.api.util.array；
导入net.rim.device.api.util.Persistable；
导入com.firstBooks.series.db.parser.XMLParser；
导入com.firstBooks.series.ui.managers.TopManager；
导入com.firstBooks.series.ui.screens.TestScreen；
公共类DBMain实现了持久化{
公共静态字符串answer=“”；
公共静态字符串selectedAnswer=“”；
公共静态问题；
公共静态int currQuesNumber=1；
公共静态int correctAnswerCount=-1；
静态电流；
静态int quescont=-1；
静态int-xyz；
静态int j=0；
公共静态int totalNumofQuestions=Question.totques；
public static int quesNum[]=new int[XMLParser.questionList.size（）]；
静态持久对象qStore；
静态持久对象curQues；
静态持久对象；
静态持久对象库；
静态持久对象研究；
静态持久对象restques；
静态int a；
静态int b；
静态int[]c；
静态int[]d；
静态积分；
静态int罐；
静态int[]dques；
静态int[]rques；
静止的{
qStore=PersistentStore.getPersistentObject（0x33010065d24c7883L）；
curQues=PersistentStore.getPersistentObject（0x3301064D24C7883L）；
pQues=PersistentStore.getPersistentObject（0xbd7460a5b4f9890aL）；
curans=PersistentStore.getPersistentObject（0xc5c065a3ae1bec21L）；
disques=PersistentStore.getPersistentObject（0xbf8118045165a07aL）；
}
静态{
初始化（）；
}
公共静态void initialize（）{
//int quesNum[]=new int[XMLParser.questionList.size（）]；
Random rgen=new Random（）；//随机数生成器
//inta=Integer.parseInt（TopManager.quesNumber）；
//System.out.println（“AAAAA的值为….”+a）；
//---初始化数组
对于（int i=0；i
但是，您应该考虑用各种java集合中的一个替换数组。
根据Michael的评论，Snoracle文档不正确。我已将链接目的地更改为Blackberry文档。谢谢Michael。
你真的必须使用数组吗？如果你真的要检查一个值是否已经存在很多，你最好使用一种结构，使其更快-哈希集、TreeSet、HashMap，等等。
你可以这样写：

   for(int i=0; i< array.length; i++)  {
     if(value.equals(array[i])) {
       return true;
     }
   }

   return false;

for（int i=0；i

但是有另一种方法可以使用
ArrayList或
执行此操作，该方法具有
包含的方法，您可以使用该方法比较任何对象。
检查数组中是否存在值的一种方法：

Arrays.asList(someArray).contains(value);

请记住，这是BlackBerry的东西，因此链接到java文档是没有帮助的。