Java 需要在for循环中将变量再次初始化为零

这是我的密码。当从两个字符串中删除特定字符时，我需要将

I

值再次初始化为零。此处，

sb

指用户输入的第一个字符串，

sb1

指用户输入的第二个字符串。比较时，如果两个字符相同，则应从两个字符串中删除字符，并且应将

i

的值重新初始化为零，并开始从第一个字符串的第一个字符与第二个字符串的第一个字符进行比较。一切正常，但

i

的值没有再次初始化为零，而是递增

for (i = 0; i < sb.length(); i++) {
    for (j = 0, d = 0; j < sb1.length(); j++) {
        if (sb.charAt(i) == sb1.charAt(j)) {
            sb.deleteCharAt(i);
            i = 0;
            System.out.println("the buff=" + sb);

            sb1.deleteCharAt(j);
            System.out.println("the buff=" + sb1);

            break;
        }
    }
}

for（i=0；i

将-1设置为i

     for (i = 0; i < sb.length(); i++) {
        for (j = 0, d = 0; j < sb1.length(); j++) {
            if (sb.charAt(i) == sb1.charAt(j)) {
                sb.deleteCharAt(i);                   
                System.out.println("the buff=" + sb);
                sb1.deleteCharAt(j);
                System.out.println("the buff=" + sb1);
                i=-1;
                break;
            }
        }

    }

for（i=0；i

因此，它会递增，并在重新启动时变为零。

将-1设置为i

     for (i = 0; i < sb.length(); i++) {
        for (j = 0, d = 0; j < sb1.length(); j++) {
            if (sb.charAt(i) == sb1.charAt(j)) {
                sb.deleteCharAt(i);                   
                System.out.println("the buff=" + sb);
                sb1.deleteCharAt(j);
                System.out.println("the buff=" + sb1);
                i=-1;
                break;
            }
        }

    }

for（i=0；i

因此，它会递增，并在重新启动时变为零。

将-1设置为i

     for (i = 0; i < sb.length(); i++) {
        for (j = 0, d = 0; j < sb1.length(); j++) {
            if (sb.charAt(i) == sb1.charAt(j)) {
                sb.deleteCharAt(i);                   
                System.out.println("the buff=" + sb);
                sb1.deleteCharAt(j);
                System.out.println("the buff=" + sb1);
                i=-1;
                break;
            }
        }

    }

for（i=0；i

因此，它会递增，并在重新启动时变为零。

将-1设置为i

     for (i = 0; i < sb.length(); i++) {
        for (j = 0, d = 0; j < sb1.length(); j++) {
            if (sb.charAt(i) == sb1.charAt(j)) {
                sb.deleteCharAt(i);                   
                System.out.println("the buff=" + sb);
                sb1.deleteCharAt(j);
                System.out.println("the buff=" + sb1);
                i=-1;
                break;
            }
        }

    }

for（i=0；i

---

因此，它会递增，并在重新启动时变为零。

for

循环有四个部分：

• 初始化

• 试验

• 增量

• 身体

前三个部分是在

if

之后放入

（）

的三个部分，用

分隔，第四个当然是循环中的代码块

它们是这样运行的：初始化、测试、主体、增量、测试、主体

当您的代码在循环体中将
i
设置为
0
时，这是可行的，但随后会发生增量，即递增
i
。因此，如果你打算这样做，在打破
j
循环之前，你需要将
i
设置为一个值，这样当增量发生时，它最终是
0
-在你的例子中是
-1

但是一般来说，如果你在使用索引，
for
可能不是最好的循环结构。例如，在这种情况下，
虽然
可能是一个更好的选择，而且我认为您不必再次从
0
开始，只是当您删除字符时，您不想增加索引：

i = 0;
while (i < sb.length()) {
    j = 0;
    while (j < sb1.length()) {
        if (sb.charAt(i) == sb1.charAt(j)) {
            sb.deleteCharAt(i);
            sb1.deleteCharAt(j);
        }
        else
        {
            ++j;
            ++i;
        }
    }
}

for
循环有四个部分：


初始化

试验

增量

身体


前三个部分是在
if
之后放入
（）
的三个部分，用
分隔，第四个当然是循环中的代码块

它们是这样运行的：初始化、测试、主体、增量、测试、主体

当您的代码在循环体中将
i
设置为
0
时，这是可行的，但随后会发生增量，即递增
i
。因此，如果你打算这样做，在打破
j
循环之前，你需要将
i
设置为一个值，这样当增量发生时，它最终是
0
-在你的例子中是
-1

但是一般来说，如果你在使用索引，
for
可能不是最好的循环结构。例如，在这种情况下，
虽然
可能是一个更好的选择，而且我认为您不必再次从
0
开始，只是当您删除字符时，您不想增加索引：

i = 0;
while (i < sb.length()) {
    j = 0;
    while (j < sb1.length()) {
        if (sb.charAt(i) == sb1.charAt(j)) {
            sb.deleteCharAt(i);
            sb1.deleteCharAt(j);
        }
        else
        {
            ++j;
            ++i;
        }
    }
}

for
循环有四个部分：


初始化

试验

增量

身体


前三个部分是在
if
之后放入
（）
的三个部分，用
分隔，第四个当然是循环中的代码块

它们是这样运行的：初始化、测试、主体、增量、测试、主体

当您的代码在循环体中将
i
设置为
0
时，这会起作用，但随后会发生增量，