Java 循环的第二个条件选择

是否可以向Java的应用程序添加第二个条件

我有一个在

do while

循环结束时更新的集合。在这个

do while循环中

，有一个

for循环

例如：（这不起作用，但说明了我正在努力实现的目标）

---

不能将二进制测试与增强的

for

循环合并；语法不允许这样做。您需要使用传统的

for

循环语法，或者将布尔测试放在循环中，然后将其中断

for (String string : list) {
   if (counter >= 5) break;
   System.out.println(string);
   counter++;
}

---

我不确定有什么不适合增强的

for

循环的传统语法；他们基本上做同样的事情。（事实上，由于增强型

for

循环使用迭代器，如果异步更新列表，则可能出现并发修改异常。）

不能将二进制测试与增强型

for

循环合并；语法不允许这样做。您需要使用传统的

for

循环语法，或者将布尔测试放在循环中，然后将其中断

for (String string : list) {
   if (counter >= 5) break;
   System.out.println(string);
   counter++;
}

---

我不确定有什么不适合增强的

for

循环的传统语法；他们基本上做同样的事情。（事实上，由于增强的

for

循环使用迭代器，如果异步更新列表，则可能会出现并发修改异常。）

默认情况下不是这样，但您可以创建类似以下内容的酷炫内容：

public class ForEachCondition
{

    public static void main(String[] args)
    {
        List<Integer> ints = new ArrayList<Integer>();
        ints.add(1);
        ints.add(3);
        ints.add(100);
        ints.add(200);

        for (Integer i : new ConditionalIterator<Integer>(ints, new ConditionalIterator.Condition<Integer>()
        {
            @Override
            public boolean next(Integer t)
            {
                return t < 130;
            }
        }))
        {
            System.out.println(i);
        }
    }
}

class ConditionalIterator<T> implements Iterable<T>, Iterator<T>
{

    private Condition<T> condition;
    private Iterator<T> iterator;
    private T next;

    public ConditionalIterator(Iterable<T> it, Condition<T> cond)
    {
        this.iterator = it.iterator();
        this.condition = cond;
    }

    @Override
    public Iterator<T> iterator()
    {
        return this;
    }

    @Override
    public boolean hasNext()
    {
        if (iterator.hasNext())
        {
            next = iterator.next();
            return condition.next(next);
        }
        return false;
    }

    @Override
    public T next()
    {
        return next;
    }

    @Override
    public void remove()
    {
        iterator.remove();
    }

    public static interface Condition<T>
    {
        public boolean next(T t);
    }
}

for (Integer i : new ConditionalIterator<Integer>(ints, (Integer t) -> t < 130)
{
    System.out.println(i);
}

公共类ForEachCondition
{
公共静态void main（字符串[]args）
{
List ints=new ArrayList（）；
加入（1）；
加入（3）；
内加（100）；
内加（200）；
for（整数i:new ConditionalIterator（int，new ConditionalIterator.Condition（））
{
@凌驾
公共布尔next（整数t）
{
返回t<130；
}
}))
{
系统输出打印LN（i）；
}
}
}
类条件运算符实现Iterable、迭代器
{
私人条件；
私有迭代器；
私人T next；
公共条件运算符（Iterable it，cond条件）
{
this.iterator=it.iterator（）；
这个条件=cond；
}
@凌驾
公共迭代器迭代器（）
{
归还这个；
}
@凌驾
公共布尔hasNext（）
{
if（iterator.hasNext（））
{
next=迭代器.next（）；
返回条件。下一个（下一个）；
}
返回false；
}
@凌驾
公共交通工具
{
下一步返回；
}
@凌驾
公共空间删除（）
{
iterator.remove（）；
}
公共静态接口条件
{
公共布尔下一步（T）；
}
}

使用新的Java 8，for的外观可能如下所示：

public class ForEachCondition
{

    public static void main(String[] args)
    {
        List<Integer> ints = new ArrayList<Integer>();
        ints.add(1);
        ints.add(3);
        ints.add(100);
        ints.add(200);

        for (Integer i : new ConditionalIterator<Integer>(ints, new ConditionalIterator.Condition<Integer>()
        {
            @Override
            public boolean next(Integer t)
            {
                return t < 130;
            }
        }))
        {
            System.out.println(i);
        }
    }
}

class ConditionalIterator<T> implements Iterable<T>, Iterator<T>
{

    private Condition<T> condition;
    private Iterator<T> iterator;
    private T next;

    public ConditionalIterator(Iterable<T> it, Condition<T> cond)
    {
        this.iterator = it.iterator();
        this.condition = cond;
    }

    @Override
    public Iterator<T> iterator()
    {
        return this;
    }

    @Override
    public boolean hasNext()
    {
        if (iterator.hasNext())
        {
            next = iterator.next();
            return condition.next(next);
        }
        return false;
    }

    @Override
    public T next()
    {
        return next;
    }

    @Override
    public void remove()
    {
        iterator.remove();
    }

    public static interface Condition<T>
    {
        public boolean next(T t);
    }
}

for (Integer i : new ConditionalIterator<Integer>(ints, (Integer t) -> t < 130)
{
    System.out.println(i);
}

for（整数i：新的条件运算符（ints，（整数t）->t<130）
{
系统输出打印LN（i）；
}

默认情况下不是这样，但您可以创建一些很酷的东西，比如：

public class ForEachCondition
{

    public static void main(String[] args)
    {
        List<Integer> ints = new ArrayList<Integer>();
        ints.add(1);
        ints.add(3);
        ints.add(100);
        ints.add(200);

        for (Integer i : new ConditionalIterator<Integer>(ints, new ConditionalIterator.Condition<Integer>()
        {
            @Override
            public boolean next(Integer t)
            {
                return t < 130;
            }
        }))
        {
            System.out.println(i);
        }
    }
}

class ConditionalIterator<T> implements Iterable<T>, Iterator<T>
{

    private Condition<T> condition;
    private Iterator<T> iterator;
    private T next;

    public ConditionalIterator(Iterable<T> it, Condition<T> cond)
    {
        this.iterator = it.iterator();
        this.condition = cond;
    }

    @Override
    public Iterator<T> iterator()
    {
        return this;
    }

    @Override
    public boolean hasNext()
    {
        if (iterator.hasNext())
        {
            next = iterator.next();
            return condition.next(next);
        }
        return false;
    }

    @Override
    public T next()
    {
        return next;
    }

    @Override
    public void remove()
    {
        iterator.remove();
    }

    public static interface Condition<T>
    {
        public boolean next(T t);
    }
}

for (Integer i : new ConditionalIterator<Integer>(ints, (Integer t) -> t < 130)
{
    System.out.println(i);
}

公共类ForEachCondition
{
公共静态void main（字符串[]args）
{
List ints=new ArrayList（）；
加入（1）；
加入（3）；
内加（100）；
内加（200）；
for（整数i:new ConditionalIterator（int，new ConditionalIterator.Condition（））
{
@凌驾
公共布尔next（整数t）
{
返回t<130；
}
}))
{
系统输出打印LN（i）；
}
}
}
类条件运算符实现Iterable、迭代器
{
私人条件；
私有迭代器；
私人T next；
公共条件运算符（Iterable it，cond条件）
{
this.iterator=it.iterator（）；
这个条件=cond；
}
@凌驾
公共迭代器迭代器（）
{
归还这个；
}
@凌驾
公共布尔hasNext（）
{
if（iterator.hasNext（））
{
next=迭代器.next（）；
返回条件。下一个（下一个）；
}
返回false；
}
@凌驾
公共交通工具
{
下一步返回；
}
@凌驾
公共空间删除（）
{
iterator.remove（）；
}
公共静态接口条件
{
公共布尔下一步（T）；
}
}

使用新的Java 8，for的外观可能如下所示：

public class ForEachCondition
{

    public static void main(String[] args)
    {
        List<Integer> ints = new ArrayList<Integer>();
        ints.add(1);
        ints.add(3);
        ints.add(100);
        ints.add(200);

        for (Integer i : new ConditionalIterator<Integer>(ints, new ConditionalIterator.Condition<Integer>()
        {
            @Override
            public boolean next(Integer t)
            {
                return t < 130;
            }
        }))
        {
            System.out.println(i);
        }
    }
}

class ConditionalIterator<T> implements Iterable<T>, Iterator<T>
{

    private Condition<T> condition;
    private Iterator<T> iterator;
    private T next;

    public ConditionalIterator(Iterable<T> it, Condition<T> cond)
    {
        this.iterator = it.iterator();
        this.condition = cond;
    }

    @Override
    public Iterator<T> iterator()
    {
        return this;
    }

    @Override
    public boolean hasNext()
    {
        if (iterator.hasNext())
        {
            next = iterator.next();
            return condition.next(next);
        }
        return false;
    }

    @Override
    public T next()
    {
        return next;
    }

    @Override
    public void remove()
    {
        iterator.remove();
    }

    public static interface Condition<T>
    {
        public boolean next(T t);
    }
}

for (Integer i : new ConditionalIterator<Integer>(ints, (Integer t) -> t < 130)
{
    System.out.println(i);
}

for（整数i：新的条件运算符（ints，（整数t）->t<130）
{
系统输出打印LN（i）；
}

更新的集合..是您正在迭代的列表吗？我认为您不允许在迭代列表时修改列表。它会导致@Adarsh：您是对的，我的构造有点不同。让我更新我的问题。更新的集合..是您正在迭代的列表吗？我不认为您你是对的，我的结构有点不同。让我更新我的问题。这解决了它。谢谢。我已经用

break

语句试过了，但我的条件错了。这澄清了它。这解决了它。谢谢。我已经用

break语句试过了声明，但我的条件错了。这就清楚了。这太棒了，非常有创意！谢谢！这太棒了，非常有创意！谢谢！