java - For 表达式中的 Java ":" 运算符

Question

在为其他人的代码编写单元测试时，我遇到了“：”运算符的一个有趣用法。它看起来像这样：

for(Class classInstance : instanceOfOtherClass){

//Do some irrelevant stuff

}

我从未见过没有“？”而单独使用“：”运算符，就像编写三元语句时一样。我已经做了相当多的谷歌搜索，但似乎找不到任何关于我应该如何阅读这篇文章的明智答案......

我是否过于复杂了？有人见过吗？

Answer 1

为了将来参考，您是否输入了：

java 7 for 循环：

进入谷歌，第二个结果会对你有所帮助。为了您的辩护，如果您不将“7”放在那里，那么找到解决方案会更加困难（不是因为它是在 java 7 中引入的，而是在 java 5 中，而是因为如果它当前受支持，那么把 7 给你找到最新文档的可能性更高）。这是增强的 for 循环或for-each 循环的示例。

简而言之：

增强的For语句：

for ( FormalParameter : Expression ) Statement

其中Expression必须是iterable 或数组类型。

用更简单的术语（数组示例，但请注意implements Iterable可以使用的任何内容）：

String[] words = new String[]{"This","is","the","end"};

for (int i = 0; i < words.length; i++)
{
      System.out.println(words[i]);
}

用 for-each 循环编写的是：

for (String s : words)
{
      System.out.println(s);
}

如果您想知道效率，请查看此帖子。

Answer 2

它被称为for each

for(Class object : Objects){
    //it will iterate through all the objects contained in Objects
    //Objects can be an array, a list, etc.
    //object Class/Type must match the class of the objects contained in Objects

}

例如，这将迭代字符串中的字符

for(char c : string.toCharArray()){
    System.out.println(c);
}

在这里，您将找到这款 for 和经典版之间的比较：

在 Java 中迭代数组的最快方法：循环变量与增强的 for 语句

Answer 3

// Infinite
 for ( ; ; ) {

   // Code
 }

//Array<Object>
 int[] numbers = 
         {1,3,6,9,12,15,18};
     for (int item : numbers) {
         System.out.println("Count is: " + item);
     }

//List<Object>
  ArrayList<Object> objectList ;//I assume it's perfectly initialized and filled

  for (Object temp : objectList) {
    System.out.println(temp);
}

Answer 4

使用示例：

String[] words = {"one", "two", "three", "one", "two", "three"};
for(String one : words){
System.out.println("found it");
}

现在，我敢打赌你认为当你运行它时，它会在屏幕上打印两次“找到它”。一次，对于 String = "one" 的每个实例......但你错了。这将打印六次“找到它”！原因是它正在搜索另一个实例的一个对象！因为 String Array 中有六个 String 对象实例，所以它会多次执行增强 for 循环内的语句。希望这个丰富多彩的解释能让你更容易理解。

Answer 5

首先，它可以与数组一起使用。考虑一个类型为 的对象数组MyClass：

MyClass[] objects = new MyClass[SIZE];

像这样迭代：

for(MyClass object : objects) {
  // do something with the individual object.
}

其次，您可以将它与可迭代的集合一起使用。考虑一个MyClass单独的元素类，并通过定义一个子类来收集它们Iterable：

class MyClassList implements Iterable<MyClass> {
  // define necessary methods to implement the Iterable interface!
}

现在我们可以制作一个集合：

MyClassList objects = new MyClassList();
// fill the collection somehow.

并迭代：

for(MyClass object : objects) {
  // do something with the individual object
}

最后，请注意此构造的主要缺点是您无法访问元素在迭代中的位置。对于object您正在处理的给定，如果您想知道它的位置，您应该使用 for 循环：

for(int i = 0; i < objects.size(); i++) {
  // Here we have access to the position i
}

或使用临时索引：

int i = 0;
for(MyClass object : objects) {
  // do something with access to position i
  i++;
}

我个人不喜欢最后的 hack，只会退回到经典for循环。希望这可以帮助！