Java 如何比较两个数组之间的元素，然后打印相等的元素？

我正在编写一个彩票程序，现在我有点被卡住了。我让用户选择七个数字，最后我希望程序告诉用户他回答正确的数字

我在理解数组时遇到了很多困难，以至于我不知道如何在数组中存储正确猜测的数字，然后在最后打印数组中的元素。我尝试过各种各样的变化，但都不适合我

package whatevs;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Random;
import java.util.Scanner;

public class lottery {

public static void main(String[] args) {
    Scanner reader = new Scanner(System.in);

    int[] userNumbers = new int[7];
    int[] winningNumbers = new int[7];
    int guesses;
    int i;
    int counter = 0;
    int[]correctGuessed=new int[8];
    int x;

    ArrayList<Integer> list = new ArrayList<Integer>();
        for (x=1; x<40; x++) {
            list.add(new Integer(x));
        }
        Collections.shuffle(list);
        for (x=0; x<7;x++) {
           winningNumbers[x] = list.get(x);
        }

    System.out.println("Pick 7 numbers between 1 and 39: ");
    for(i = 0; i < 7; i++){
        guesses = reader.nextInt();
        userNumbers[i] = guesses;
       // System.out.println(userNumbers[i]);
        for(x = 0; x<7;x++){
            if(winningNumbers[x] == userNumbers[i]){    
                correctGuessed[x] = userNumbers[i];
                counter+=1;
            }
    }

    if (counter == 7){
        System.out.println("You won!");
    }
    else
        System.out.println("You had " + counter + " numbers correct: " + correctGuessed[x]  );
    }
}

packagewhatevs；
导入java.util.ArrayList；
导入java.util.array；
导入java.util.Collections；
导入java.util.Random；
导入java.util.Scanner；
公共类彩票{
公共静态void main（字符串[]args）{
扫描仪阅读器=新扫描仪（System.in）；
int[]userNumbers=新int[7]；
int[]winningNumbers=新int[7]；
智力猜测；
int i；
int计数器=0；
int[]correctGuessed=新int[8]；
int x；
ArrayList=新建ArrayList（）；
对于（x=1；x我将使用集合而不是数组。集合比数组有两个优点：


它们确保集合中没有重复（这是您想要的，因为您有不同的40个数字，并且希望用户选择7个不同的数字）
它们的级别更高，因此有许多裸阵列所没有的有用方法

因此，以下是您应该具备的逻辑：

用40个数字填写一个列表
洗牌
创建一个
HashSet
并添加列表的前7个元素。这些是中奖号码
创建一个新的空
Hashset
请用户输入数字。将每个数字添加到此新哈希集，并继续询问，直到该集有7个数字
使用HashSet的retainAll（）方法可以知道哪些猜测的数字也是中奖数字的一部分。javadoc是您了解此方法的朋友
使用list.contains（v）检查wining值是否在猜测值中。
大概是这样的：

public static void main(String[] args) {
    Scanner reader = new Scanner(System.in);

    Integer[] userNumbers = new Integer[7];
    Integer[] winningNumbers = new Integer[7];
    int guesses;
    int i;
    int counter = 0;
    int[] correctGuessed = new int[8];
    int x;

    ArrayList<Integer> list = new ArrayList<Integer>();
    for (x = 1; x < 40; x++) {
        list.add(Integer.valueOf(x));
    }
    Collections.shuffle(list);
    for (x = 0; x < 7; x++) {
        winningNumbers[x] = list.get(x);
    }

    System.out.println("Pick 7 numbers between 1 and 39: ");
    for (i = 0; i < 7; i++) {
        guesses = reader.nextInt();
        userNumbers[i] = guesses;
    }

    List<Integer> winList = Arrays.asList(winningNumbers);
    List<Integer> guessList = Arrays.asList(userNumbers);
    List<Integer> matchList = new ArrayList<Integer>();
    for (Integer guess : guessList) {
        if (winList.contains(guess)) {
            matchList.add(guess);
        }

    }
    counter = matchList.size();

    if (counter == 7) {
        System.out.println("You won!");
    } else {
        System.out.println("You had " + counter + " numbers correct: " + Arrays.toString(matchList.toArray()));
    }
}// main

    System.out.println("Pick 7 numbers between 1 and 39: ");
    for(i = 0; i < 7; i++) {
        guesses = reader.nextInt();
        userNumbers[i] = guesses;
        // System.out.println(userNumbers[i]);
        for (x = 0; x < 7; x++) {
            if (winningNumbers[x] == userNumbers[i]) {
                correctGuessed[counter] = userNumbers[i];
                counter += 1;
            }
        }
    }

        if (counter == 7){
            System.out.println("You won!");
        }
        else
            System.out.println("You had " + counter + " numbers correct: " + Arrays.toString(correctGuessed));

while (guessedNumbers.size() < 7){
        int currentGuess = reader.nextInt();
        guessedNumbers.add(currentGuess);
        if (winningNumbers.contains(currentGuess)) {
            correctGuesses.add(currentGuess);
        }
 }

publicstaticvoidmain（字符串[]args）{
扫描仪阅读器=新扫描仪（System.in）；
整数[]userNumbers=新整数[7]；
整数[]winningNumbers=新整数[7]；
智力猜测；
int i；
int计数器=0；
int[]correctGuessed=新int[8]；
int x；
ArrayList=新建ArrayList（）；
对于（x=1；x<40；x++）{
list.add（整数.valueOf（x））；
}
集合。洗牌（列表）；
对于（x=0；x<7；x++）{
winningNumbers[x]=list.get（x）；
}
System.out.println（“选择1到39之间的7个数字：”；
对于（i=0；i<7；i++）{
猜测=reader.nextInt（）；
用户编号[i]=猜测；
}
List winList=Arrays.asList（winningNumbers）；
List-guessList=Arrays.asList（usernumber）；
列表匹配列表=新的ArrayList（）；
for（整数猜测：猜测列表）{
if（winList.contains（guess））{
匹配列表。添加（猜测）；
}
}
计数器=matchList.size（）；
如果（计数器==7）{
System.out.println（“你赢了！”）；
}否则{
System.out.println（“您的“+计数器+”数字正确：”+Arrays.toString（matchList.toArray（））；
}
}//主要
您的代码有点复杂，但几乎可以正常工作。

一些评论：


包含猜测数字的对象不应该是由7个元素组成的数组：
int[7]
，因为否则它总是包含7个元素，而用户可能会发现少于7个数字。在这种情况下，其他值将为0（int的默认值），并且使用整数[7]，将设置为
NULL
。这可能不是一个合适的选择。您应该声明：

Set correctGuessed=new HashSet（）；
而不是
int[]correctGuessed=new int[8]

猜测一个数字时，您可以这样分配找到的数字：
correctGuessed[x]=userNumbers[i]；
您现在可以用以下内容替换：
更正猜测。添加（用户编号[i]）；

最后，在输出中写入：

`System.out.println("You had " + counter + " numbers correct: " + correctGuessed[x]  );`



这是不正确的，原因有二：
-
x
在循环后始终作为值
7
。因此，它不一定是您刚才填充的数组的索引值。在原始解决方案中，如果您想在猜测数字时保留
x
的值，则应使用
break
：

for(x = 0; x<7;x++){
            if(winningNumbers[x] == userNumbers[i]){    
                correctGuessed[x] = userNumbers[i];
                counter+=1;
                break;
            }
    }

快速修复的代码如下所示：

public static void main(String[] args) {
    Scanner reader = new Scanner(System.in);

    Integer[] userNumbers = new Integer[7];
    Integer[] winningNumbers = new Integer[7];
    int guesses;
    int i;
    int counter = 0;
    int[] correctGuessed = new int[8];
    int x;

    ArrayList<Integer> list = new ArrayList<Integer>();
    for (x = 1; x < 40; x++) {
        list.add(Integer.valueOf(x));
    }
    Collections.shuffle(list);
    for (x = 0; x < 7; x++) {
        winningNumbers[x] = list.get(x);
    }

    System.out.println("Pick 7 numbers between 1 and 39: ");
    for (i = 0; i < 7; i++) {
        guesses = reader.nextInt();
        userNumbers[i] = guesses;
    }

    List<Integer> winList = Arrays.asList(winningNumbers);
    List<Integer> guessList = Arrays.asList(userNumbers);
    List<Integer> matchList = new ArrayList<Integer>();
    for (Integer guess : guessList) {
        if (winList.contains(guess)) {
            matchList.add(guess);
        }

    }
    counter = matchList.size();

    if (counter == 7) {
        System.out.println("You won!");
    } else {
        System.out.println("You had " + counter + " numbers correct: " + Arrays.toString(matchList.toArray()));
    }
}// main

    System.out.println("Pick 7 numbers between 1 and 39: ");
    for(i = 0; i < 7; i++) {
        guesses = reader.nextInt();
        userNumbers[i] = guesses;
        // System.out.println(userNumbers[i]);
        for (x = 0; x < 7; x++) {
            if (winningNumbers[x] == userNumbers[i]) {
                correctGuessed[counter] = userNumbers[i];
                counter += 1;
            }
        }
    }

        if (counter == 7){
            System.out.println("You won!");
        }
        else
            System.out.println("You had " + counter + " numbers correct: " + Arrays.toString(correctGuessed));

while (guessedNumbers.size() < 7){
        int currentGuess = reader.nextInt();
        guessedNumbers.add(currentGuess);
        if (winningNumbers.contains(currentGuess)) {
            correctGuesses.add(currentGuess);
        }
 }

但是，如果您想确保用户在您的彩票中使用了不同的号码，则需要保存用户的猜测。这样，您可以再次使用集合，并在用户每次猜测时添加猜测。您可以使用
while
循环不断询问号码，直到用户给您7个唯一的号码。类似于以下内容：

public static void main(String[] args) {
    Scanner reader = new Scanner(System.in);

    Integer[] userNumbers = new Integer[7];
    Integer[] winningNumbers = new Integer[7];
    int guesses;
    int i;
    int counter = 0;
    int[] correctGuessed = new int[8];
    int x;

    ArrayList<Integer> list = new ArrayList<Integer>();
    for (x = 1; x < 40; x++) {
        list.add(Integer.valueOf(x));
    }
    Collections.shuffle(list);
    for (x = 0; x < 7; x++) {
        winningNumbers[x] = list.get(x);
    }

    System.out.println("Pick 7 numbers between 1 and 39: ");
    for (i = 0; i < 7; i++) {
        guesses = reader.nextInt();
        userNumbers[i] = guesses;
    }

    List<Integer> winList = Arrays.asList(winningNumbers);
    List<Integer> guessList = Arrays.asList(userNumbers);
    List<Integer> matchList = new ArrayList<Integer>();
    for (Integer guess : guessList) {
        if (winList.contains(guess)) {
            matchList.add(guess);
        }

    }
    counter = matchList.size();

    if (counter == 7) {
        System.out.println("You won!");
    } else {
        System.out.println("You had " + counter + " numbers correct: " + Arrays.toString(matchList.toArray()));
    }
}// main

    System.out.println("Pick 7 numbers between 1 and 39: ");
    for(i = 0; i < 7; i++) {
        guesses = reader.nextInt();
        userNumbers[i] = guesses;
        // System.out.println(userNumbers[i]);
        for (x = 0; x < 7; x++) {
            if (winningNumbers[x] == userNumbers[i]) {
                correctGuessed[counter] = userNumbers[i];
                counter += 1;
            }
        }
    }

        if (counter == 7){
            System.out.println("You won!");
        }
        else
            System.out.println("You had " + counter + " numbers correct: " + Arrays.toString(correctGuessed));

while (guessedNumbers.size() < 7){
        int currentGuess = reader.nextInt();
        guessedNumbers.add(currentGuess);
        if (winningNumbers.contains(currentGuess)) {
            correctGuesses.add(currentGuess);
        }
 }

while（guessedNumbers.size（）<7）{
int currentGuess=reader.nextInt（）；
猜测的数字。添加（currentGuess）；
if（winningNumbers.contains（currentGuess））{
更正猜测。添加（currentGuess）；
}
}

这将为您提供足够的材料，以使用JB Nizet和Alex的所有提示重构其他代码

请允许我再提一件事：尝试使用具有意图揭示名称的方法和变量。您已经做得很好了，但请尽量具体，如果int包含1个猜测，请将其命名为
guessedNumber
，而不是
guesses
。或者如果用户在计数器为7时获胜，您可以引入布尔赢作为示例le，或者一个额外的方法。考虑到您正在与数组作斗争的事实，我必须说代码看起来已经相当不错了。
您真的想使用数组来实现这一点吗？因为使用集合是一个更简单、更符合逻辑的解决方案。JB是对的：我可能对数组知之甚少，但对集合却一无所知。这是否意味着我必须要重写整个程序吗？不，不是整个程序。但是整个程序只有几行