Question

当我在编写代码时遇到问题时，我通常会像故事一样处理它。每个命令都是故事中的一个句子。句子需要有意义才能使故事完整/正确。

所以我现在用赫尔辛基大学的MOOC课程从零开始学习java。我有点卡在练习68.该程序假设将列表（数组）的整数值与用户输入进行比较。我编写的是一个方法，如果用户输入的数字已经在列表中，则返回true，如果不是，则返回false。

我在开始时谈到的故事：注释掉的代码是我的初始代码。这并没有超过最后一次测试，但在我脑海中，注释掉的代码和其他代码基本上都是相同的

错误消息（来自上次测试）： ＆＃34;当参数列表[0,7,9，-1,13,8，-1]和预期值8时回答错误：错误但是： true ＆＃34;

public static boolean moreThanOnce(ArrayList<Integer> list, int searched) 
//        if (list.size()==1) {return false;}
//        
//        for (int i = 0; i < list.size();i++  ){
//          if (list.contains(searched)) 
//          
//          {
//          
//              return true; }
//          
//        }
//return false;
//   
        int counter = 0;
        for (int num : list) {
            if (searched == num) {
                counter++;
            }
        }
        if (counter >= 2){
            return true;
        } else {
            return false;
        }
    }

我知道有些不对劲，似乎无法弄明白。你明白为什么最后一个代码会被接受，但不是第一个（注释掉的）？

如果有任何用途，其余代码（不是我的工作）是这样的：

 public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(3);
        list.add(2);
        list.add(7);
        list.add(2);

        System.out.println("Type a number: ");
        int number = Integer.parseInt(reader.nextLine());
        if (moreThanOnce(list, number)) {
            System.out.println(number + " appears more than once.");
        } else {
            System.out.println(number + " does not appear more than once. ");
        }
    }
}

Answer 1

仅仅保证注释掉的代码如果为真，则数组中至少有一个出现，也许有更多但不保证。如果函数返回false，则可能是1或没有出现。

原因：如果arrary os大于1，则并不意味着您搜索的值有2个或更多。

可行的解决方案：像未注释的代码一样添加计数器。

Answer 2

你的第一个算法有一些缺陷，首先你要明确测试一个长度。不是null，而不是空List。其次，您应该更喜欢List显式类型的ArrayList接口。最后，当你调用contains时，你需要考虑当前位置之一的子列表偏移量（显然列表包含至少当前值）。

我觉得你想要像

这样的东西

public static boolean moreThanOnce(List<Integer> list, int searched) {
    if (list == null || list.size() < 2) {
        return false;
    }

    int len = list.size();
    for (int i = 0; i < len - 1; i++) {
        if (list.get(i).equals(searched) 
                    && list.subList(i + 1, list.size()).contains(searched)) {
            return true;
        }
    }
    return false;
}

，我们可以将其表示为泛型方法。像，

public static <T> boolean moreThanOnce(List<T> list, T searched) {
    if (list == null || list.size() < 2) {
        return false;
    }

    int len = list.size();
    for (int i = 0; i < len - 1; i++) {
        if (list.get(i).equals(searched) 
                    && list.subList(i + 1, list.size()).contains(searched)) {
            return true;
        }
    }
    return false;
}

或，如果您使用的是Java 8+，请使用Stream和filter，然后使用count

public static <T> boolean moreThanOnce(List<T> list, T searched) {
    if (list == null || list.size() < 2) {
        return false;
    }
    return list.stream().filter(v -> v.equals(searched)).count() > 1;
}

返回不同的返回值

2 个答案: