Java 对于每个未执行的循环

由于某种原因，我的方法中每个的所有

循环都被完全忽略了，我也不知道为什么。这是我的密码：

private static boolean notUsed(ArrayList<Integer> check, ArrayList<ArrayList<Integer>> used)
  {
    boolean c1 = false;
    boolean c2 = true;
    for (ArrayList<Integer> item : used) // Not executed
    {
      System.out.println("It works!");
      Collections.sort(item);
      Collections.sort(check);
      if (check.equals(item)) c1 = true;
    }
    ArrayList<Integer> existing = new ArrayList<Integer>();
    for (int item : check)
    {
      for (int exists : existing) // Not executed
      {
        if (exists == item) 
        {
          c2 = false;
          break;
        }
        else existing.add(item);
      }
      if (c2 == false) break;
    }
    if (c1 && c2) return true;
    else return false;
  }

私有静态布尔值未使用（ArrayList检查，ArrayList已使用）
{
布尔c1=假；
布尔c2=真；
for（ArrayList项：已使用）//未执行
{
System.out.println（“它起作用了！”）；
集合。排序（项目）；
集合。排序（检查）；
如果（检查等于（项目））c1=真；
}
ArrayList existing=新的ArrayList（）；
对于（整数项：检查）
{
for（int exists:existing）//未执行
{
如果（存在==项）
{
c2=假；
打破
}
其他存在。添加（项目）；
}
如果（c2==假）中断；
}
如果（c1和c2）返回true；
否则返回false；
}

在过去的15分钟里，我一直在检查它，但不明白为什么代码拒绝处理循环的内容。事实上，我以前甚至不知道java可以避免执行循环。我是否遗漏了一些明显的内容？
您创建了一个新的ArrayList

ArrayList<Integer> existing = new ArrayList<Integer>();

ArrayList existing=new ArrayList（）；

它是空的

当foreach运行时，它没有可迭代的内容。因此，您的“未执行”注释是完全有效的

然而，第一个循环取决于传递的确切内容。放置一些打印状态，计算列表的大小。最有可能的情况是，也就是0，这再次导致循环被“跳过”。
您创建了一个新的ArrayList

ArrayList<Integer> existing = new ArrayList<Integer>();

ArrayList existing=new ArrayList（）；

它是空的

当foreach运行时，它没有可迭代的内容。因此，您的“未执行”注释是完全有效的

然而，第一个循环取决于传递的确切内容。放置一些打印状态，计算列表的大小。最有可能的是，也就是0，这再次导致循环被“跳过”。
是的，您缺少了一些明显的内容

如果这些循环没有执行，那么传递给例程的参数中就没有元素。
是的，您缺少了一些明显的东西

如果这些循环没有执行，然后在传递给例程的参数中没有任何元素。
使用的
大小必须为0，第二个循环没有执行，因为
现有的
是一个新的数组列表，其大小肯定为0
使用的
大小必须为0，第二个循环没有执行，因为
现有的
是一个新的数组列表ArrayList和它的大小肯定是0
这里是工作代码。这会给你一个想法。正如其他人提到的…不会有任何元素需要迭代…因为我运行了下面的代码，每个循环都可以工作

import java.util.ArrayList;
import java.util.Collections;


public class Test1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        ArrayList<ArrayList<Integer>> used = new ArrayList<ArrayList<Integer>>();
        ArrayList<Integer>item = new ArrayList<Integer>();
        item.add(1);
        used.add(item);
        notUsed(item,used );
    }

    private static boolean notUsed(ArrayList<Integer> check, ArrayList<ArrayList<Integer>> used)
      {
        boolean c1 = false;
        boolean c2 = true;
        for (ArrayList<Integer> item : used) // Not executed
        {
          System.out.println("It works!");
          Collections.sort(item);
          Collections.sort(check);
          if (check.equals(item)) c1 = true;
        }
        ArrayList<Integer> existing = new ArrayList<Integer>();
        for (int item : check)
        {
          for (int exists : existing) // Not executed
          {
            if (exists == item) 
            {
              c2 = false;
              break;
            }
            else existing.add(item);
          }
          if (c2 == false) break;
        }
        if (c1 && c2) return true;
        else return false;
      }

}

import java.util.ArrayList；
导入java.util.Collections；
公共类Test1{
/**
*@param args
*/
公共静态void main（字符串[]args）{
ArrayList used=新的ArrayList（）；
ArrayListitem=新的ArrayList（）；
增加第（1）项；
使用。添加（项目）；
未使用（项目，已使用）；
}
私有静态布尔值未使用（ArrayList检查，ArrayList已使用）
{
布尔c1=假；
布尔c2=真；
for（ArrayList项：已使用）//未执行
{
System.out.println（“它起作用了！”）；
集合。排序（项目）；
集合。排序（检查）；
如果（检查等于（项目））c1=真；
}
ArrayList existing=新的ArrayList（）；
对于（整数项：检查）
{
for（int exists:existing）//未执行
{
如果（存在==项）
{
c2=假；
打破
}
其他存在。添加（项目）；
}
如果（c2==假）中断；
}
如果（c1和c2）返回true；
否则返回false；
}
}
这是工作代码..这会给你一些想法。正如其他人提到的…不会有任何元素需要迭代…因为我运行了下面的代码，每个循环都可以工作

import java.util.ArrayList;
import java.util.Collections;


public class Test1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        ArrayList<ArrayList<Integer>> used = new ArrayList<ArrayList<Integer>>();
        ArrayList<Integer>item = new ArrayList<Integer>();
        item.add(1);
        used.add(item);
        notUsed(item,used );
    }

    private static boolean notUsed(ArrayList<Integer> check, ArrayList<ArrayList<Integer>> used)
      {
        boolean c1 = false;
        boolean c2 = true;
        for (ArrayList<Integer> item : used) // Not executed
        {
          System.out.println("It works!");
          Collections.sort(item);
          Collections.sort(check);
          if (check.equals(item)) c1 = true;
        }
        ArrayList<Integer> existing = new ArrayList<Integer>();
        for (int item : check)
        {
          for (int exists : existing) // Not executed
          {
            if (exists == item) 
            {
              c2 = false;
              break;
            }
            else existing.add(item);
          }
          if (c2 == false) break;
        }
        if (c1 && c2) return true;
        else return false;
      }

}

import java.util.ArrayList；
导入java.util.Collections；
公共类Test1{
/**
*@param args
*/
公共静态void main（字符串[]args）{
ArrayList used=新的ArrayList（）；
ArrayListitem=新的ArrayList（）；
增加第（1）项；
使用。添加（项目）；
未使用（项目，已使用）；
}
私有静态布尔值未使用（ArrayList检查，ArrayList已使用）
{
布尔c1=假；
布尔c2=真；
for（ArrayList项：已使用）//未执行
{
System.out.println（“它起作用了！”）；
集合。排序（项目）；
集合。排序（检查）；
如果（检查等于（项目））c1=真；
}
ArrayList existing=新的ArrayList（）；
对于（整数项：检查）
{
for（int exists:existing）//未执行
{
如果（存在==项）
{
c2=假；
打破
}
其他存在。添加（项目）；
}
如果（c2==假）中断；
}
如果（c1和c2）返回true；
否则返回false；
}
}
您是否尝试过在Foreach循环中将int改为整数？这是有区别的。一个是基元，一个是对象，这可能是您的问题。ArrayList的大小是多少？当您说for（ArrayList项：已使用）//未执行时，您是否尝试在Foreach循环中将int更改为整数？这是有区别的。一个是原语，一个是对象，这可能是你的问题。你的ArrayList的大小是多少？当你说for（ArrayList项：used）//Not executed啊，那么问题就来了。。。让我把它修好，看看它是否有效。啊，那么问题就来了。。。让我来修一下，看看能不能用。