Java 两个边做边循环

这两个do-while循环真让我困惑

我创建了一个函数，用于与sql中的数字进行匹配。如果用户输入值存在，它将添加1。

（Object[]数组）

保存用户输入值并与sql中的值进行比较。sql中有两行。 该程序的工作原理如下：

(Object[] array) // assuming it holds
[2,3]

Object[] array1 // holding 
[1,2,3,0,0] and [2,5,6,0,0]

Output : 2 1

但是我不能得到任何输出…我的代码怎么了

我很确定错误来自CountMatching（Object[]array，Object[]array1）

public void ComparePre（对象[]数组）引发异常{
String sql=“从首选项中选择Pre1、Pre2、Pre3、Pre4、Pre5”；
DatabaseConnection db=新建DatabaseConnection（）；
连接conn=db.getConnection（）；
PreparedStatement ps=conn.prepareStatement（sql）；
结果集rs=ps.executeQuery（）；
Object[]b=新对象[5]；
while（rs.next（））{
Vector r=new Vector（）；//将sql数据转换为Vector
r、 添加（rs.getInt（“Pre1”）；
r、 添加（rs.getInt（“Pre2”）；
r、 添加（rs.getInt（“Pre3”）；
r、 添加（rs.getInt（“Pre4”）；
r、 添加（rs.getInt（“Pre5”）；
系统输出println（r）；
Object[]array1=新对象[5]；
r、 抄袭（b）；
}
计数匹配（数组，b）；
ps.close（）；
rs.close（）；
康涅狄格州关闭（）；
}
私有void CountMatching（对象[]数组，对象[]数组1）{
整数计数=0；
int a=0；
做{
int b=0；
做{
if（数组[a]==array1[b]）{
计数++；
}else if（数组[a]！=array1[b]）{
b++；
}
}而（b我发现这种方法至少有两个问题：

两个嵌套的
do{…}while（）
循环可能以无限循环结束。也就是说，如果
array[a]==array1[b]
在任何时候都为true，则内部计数器
b
将永远不会增加（即永远不会调用
b++
）
如果其中一个数组的长度为
0
，则此方法将抛出
索引AutofBoundsException
在其当前形式中，如果两个数组都不是空的（长度>0），并且没有找到实际匹配，则该方法将只执行它应该执行的操作

显式
for
循环可能会阻止这种情况，如果您需要：

private void CountMatching(Object[] array, Object[] array1) {
    int count = 0;
    for (int a = 0; a < array.length; a++) {
        for (int b = 0; b < array1.length; b++) {
            if (array[a] == array1[b]) {
                count++;
            }
        }
    }
    System.out.println(count);
}


在当前代码中，
r.copyInto（b）
总是覆盖之前数组中的任何内容，因此您只能得到最后一个结果行：

Object[] b=new Object[5];
while (rs.next()) {
    Vector r = new Vector();   // sql data to vector
    r.add(rs.getInt("Pre1"));
    r.add(rs.getInt("Pre2"));
    r.add(rs.getInt("Pre3"));
    r.add(rs.getInt("Pre4"));
    r.add(rs.getInt("Pre5"));
    System.out.println(r);
    Object[] array1 = new Object[5];
    r.copyInto(b);
}
CountMatching(array,b);

最简单的方法是将CountMatching（array，b）

上移一行（即进入while循环）。

我发现这种方法至少有两个问题：

两个嵌套的

do{…}while（）

循环可能以无限循环结束。也就是说，如果

array[a]==array1[b]

在任何时候都为true，则内部计数器

b

将永远不会增加（即永远不会调用

b++

）

如果其中一个数组的长度为

0

，则此方法将抛出

索引AutofBoundsException

在其当前形式中，如果两个数组都不是空的（长度>0），并且没有找到实际匹配，则该方法将只执行它应该执行的操作

显式

for

循环可能会阻止这种情况，如果您需要：

private void CountMatching(Object[] array, Object[] array1) {
    int count = 0;
    for (int a = 0; a < array.length; a++) {
        for (int b = 0; b < array1.length; b++) {
            if (array[a] == array1[b]) {
                count++;
            }
        }
    }
    System.out.println(count);
}

---

在当前代码中，

r.copyInto（b）

总是覆盖之前数组中的任何内容，因此您只能得到最后一个结果行：

Object[] b=new Object[5];
while (rs.next()) {
    Vector r = new Vector();   // sql data to vector
    r.add(rs.getInt("Pre1"));
    r.add(rs.getInt("Pre2"));
    r.add(rs.getInt("Pre3"));
    r.add(rs.getInt("Pre4"));
    r.add(rs.getInt("Pre5"));
    System.out.println(r);
    Object[] array1 = new Object[5];
    r.copyInto(b);
}
CountMatching(array,b);

---

最简单的解决方法是将

CountMatching（array，b）

向上移动一行（即进入while循环）。

如果我理解你的问题，你可以使用

int[]

（避免使用

向量）。另外，我建议使用和。类似

static void countMatching(int[] a, int[] b) {
    int count = 0;
    for (int i : a) {
        for (int j : b) {
            if (i == j) {
                count++;
            }
        }
    }
    System.out.printf("The matching count is %d%n", count);
}

public void comparePre(int[] array) throws Exception {
    String sql = "Select Pre1,Pre2,Pre3,Pre4,Pre5 from preferences";
    DatabaseConnection db = new DatabaseConnection();
    try (Connection conn = db.getConnection();
            PreparedStatement ps = conn.prepareStatement(sql);
            ResultSet rs = ps.executeQuery()) {
        while (rs.next()) {
            int[] array1 = new int[] { rs.getInt("Pre1"),
                    rs.getInt("Pre2"), rs.getInt("Pre3"),
                    rs.getInt("Pre4"), rs.getInt("Pre5") };
            countMatching(array, array1);
        }
    }
}

如果我理解您的问题，您可以使用
int[]
（并避免使用
向量
）。此外，我建议使用和。类似

static void countMatching(int[] a, int[] b) {
    int count = 0;
    for (int i : a) {
        for (int j : b) {
            if (i == j) {
                count++;
            }
        }
    }
    System.out.printf("The matching count is %d%n", count);
}

public void comparePre(int[] array) throws Exception {
    String sql = "Select Pre1,Pre2,Pre3,Pre4,Pre5 from preferences";
    DatabaseConnection db = new DatabaseConnection();
    try (Connection conn = db.getConnection();
            PreparedStatement ps = conn.prepareStatement(sql);
            ResultSet rs = ps.executeQuery()) {
        while (rs.next()) {
            int[] array1 = new int[] { rs.getInt("Pre1"),
                    rs.getInt("Pre2"), rs.getInt("Pre3"),
                    rs.getInt("Pre4"), rs.getInt("Pre5") };
            countMatching(array, array1);
        }
    }
}

这是在做什么？你在比较什么？我想把数组中的所有值与array1进行比较。例如：array保持[2,3]，array1保持[1,2,3,0,0]。数组中的索引0将比较数组1中的所有索引。比较完成后，它将继续比较数组中的索引1，并再次从数组1中的索引0开始。这是为了做什么？您在比较什么？我想比较数组中的所有值与数组1。示例：数组保留[2,3]，数组保留[1,2,3,0,0]。数组中的索引0将比较数组1中的所有索引。比较完成后，它将继续比较数组中的索引1，并再次从数组1中的索引0开始。我应该得到两个计数作为我的输出，因为我的sql中有两行。但我只得到第二行的计数rows@Seng您正在调用
CountMatching（对象，对象）
在
ComparePre（Object[]）中仅出现一次。
因此您只能得到一个输出。保存用户输入的用于比较sql中的值的ComparePre（Object）。sql中的所有值都存储在ComparePre函数的变量b中。@Seng将
CountMatching（array，b）
移到
while（rs.next（））中
loop。它当前只比较最后一个结果行的值。我应该得到两个计数作为我的输出，因为我的sql中有两行。但我只得到第二行的计数rows@Seng您在
ComparePre（Object[]中只调用了一次
CountMatching（Object，Object）
。因此您只能得到一个输出。保存用户输入的用于比较sql中的值的ComparePre（对象）。sql中的所有值都存储在ComparePre函数的变量b中。@Seng move
CountMatching（array，b）
进入
while（rs.next（））
循环。它当前仅比较最后一个结果行的值。