访问 int 或 Integer 数组时,索引比迭代器快23-40% . 这是本文底部测试类的输出,它将100个元素的原始数组中的数字相加(A是迭代器,B是索引):
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 358,597,622 nanoseconds
Test B: 269,167,681 nanoseconds
B faster by 89,429,941 nanoseconds (24.438799231635727% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 377,461,823 nanoseconds
Test B: 278,694,271 nanoseconds
B faster by 98,767,552 nanoseconds (25.666236154695838% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 288,953,495 nanoseconds
Test B: 207,050,523 nanoseconds
B faster by 81,902,972 nanoseconds (27.844689860906513% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,373,765 nanoseconds
Test B: 283,813,875 nanoseconds
B faster by 91,559,890 nanoseconds (23.891659337194227% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,790,818 nanoseconds
Test B: 220,770,915 nanoseconds
B faster by 155,019,903 nanoseconds (40.75164734599769% faster)
[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 326,373,762 nanoseconds
Test B: 202,555,566 nanoseconds
B faster by 123,818,196 nanoseconds (37.437545972215744% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,429,929,976 nanoseconds
Test B: 5,262,782,488 nanoseconds
A faster by 1,832,852,512 nanoseconds (34.326681820485675% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,907,391,427 nanoseconds
Test B: 3,957,718,459 nanoseconds
A faster by 1,050,327,032 nanoseconds (26.038700083921256% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,566,004,688 nanoseconds
Test B: 4,221,746,521 nanoseconds
A faster by 1,655,741,833 nanoseconds (38.71935684115413% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,770,945,276 nanoseconds
Test B: 3,829,077,158 nanoseconds
A faster by 1,058,131,882 nanoseconds (27.134122749113843% faster)
[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,467,474,055 nanoseconds
Test B: 5,183,149,104 nanoseconds
A faster by 1,715,675,049 nanoseconds (32.60101667104192% faster)
[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,439,983,933 nanoseconds
Test B: 3,509,530,312 nanoseconds
A faster by 69,546,379 nanoseconds (1.4816434912159906% faster)
[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,451,101,466 nanoseconds
Test B: 5,057,979,210 nanoseconds
A faster by 1,606,877,744 nanoseconds (31.269164666060377% faster)
import java.text.NumberFormat;
import java.util.Locale;
/**
<P>{@code java TimeIteratorVsIndexIntArray 1000000}</P>
@see <CODE><A HREF="https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java">https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java</A></CODE>
**/
public class TimeIteratorVsIndexIntArray {
public static final NumberFormat nf = NumberFormat.getNumberInstance(Locale.US);
public static final void main(String[] tryCount_inParamIdx0) {
int testCount;
// Get try-count from a command-line parameter
try {
testCount = Integer.parseInt(tryCount_inParamIdx0[0]);
}
catch(ArrayIndexOutOfBoundsException | NumberFormatException x) {
throw new IllegalArgumentException("Missing or invalid command line parameter: The number of testCount for each test. " + x);
}
//Test proper...START
int[] intArray = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100};
long lStart = System.nanoTime();
for(int i = 0; i < testCount; i++) {
testIterator(intArray);
}
long lADuration = outputGetNanoDuration("A", lStart);
lStart = System.nanoTime();
for(int i = 0; i < testCount; i++) {
testFor(intArray);
}
long lBDuration = outputGetNanoDuration("B", lStart);
outputGetABTestNanoDifference(lADuration, lBDuration, "A", "B");
}
private static final void testIterator(int[] int_array) {
int total = 0;
for(int i = 0; i < int_array.length; i++) {
total += int_array[i];
}
}
private static final void testFor(int[] int_array) {
int total = 0;
for(int i : int_array) {
total += i;
}
}
//Test proper...END
//Timer testing utilities...START
public static final long outputGetNanoDuration(String s_testName, long l_nanoStart) {
long lDuration = System.nanoTime() - l_nanoStart;
System.out.println("Test " + s_testName + ": " + nf.format(lDuration) + " nanoseconds");
return lDuration;
}
public static final long outputGetABTestNanoDifference(long l_aDuration, long l_bDuration, String s_aTestName, String s_bTestName) {
long lDiff = -1;
double dPct = -1.0;
String sFaster = null;
if(l_aDuration > l_bDuration) {
lDiff = l_aDuration - l_bDuration;
dPct = 100.00 - (l_bDuration * 100.0 / l_aDuration + 0.5);
sFaster = "B";
}
else {
lDiff = l_bDuration - l_aDuration;
dPct = 100.00 - (l_aDuration * 100.0 / l_bDuration + 0.5);
sFaster = "A";
}
System.out.println(sFaster + " faster by " + nf.format(lDiff) + " nanoseconds (" + dPct + "% faster)");
return lDiff;
}
//Timer testing utilities...END
}
443
public static Boolean Add_Tag(int totalsize)
{ List<String> fullst = new ArrayList<String>();
for(int k=0;k<totalsize;k++)
{
fullst.addAll();
}
}
126
每个构造对数组也有效 . 例如
String[] fruits = new String[] { "Orange", "Apple", "Pear", "Strawberry" };
for (String fruit : fruits) {
// fruit is an element of the `fruits` array.
}
这基本上相当于
for (int i = 0; i < fruits.length; i++) {
String fruit = fruits[i];
// fruit is an element of the `fruits` array.
}
public class ForEachTest {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("111");
list.add("222");
for (String str : list) {
System.out.println(str);
}
}
}
String[] s = {"Java", "Coffe", "Is", "Cool"};
for (String str:s /*s is the array*/) {
System.out.println(str);
}
输出:
Java
Coffe
Is
Cool
警告:您可以使用foreach循环访问数组元素,但不能初始化它们 . 使用原始的 for 循环 .
警告:您必须将数组的类型与其他对象匹配 .
for (double b:s) // Invalid-double is not String
如果要编辑元素,请使用原始 for 循环,如下所示:
for (int i = 0; i < s.length-1 /*-1 because of the 0 index */; i++) {
if (i==1) //1 because once again I say the 0 index
s[i]="2 is cool";
else
s[i] = "hello";
}
26 回答
这是一个等价的表达式 .
它是_135762的答案,但是当"someList"是实现java.lang.Iterable的任何东西时,'s worth noting that the OP' for(..)语法将起作用 - 它不必是一个列表,也不一定是java.util中的一些集合 . 因此,即使您自己的类型也可以使用此语法 .
forEach的替代方案,以避免您的“为每个人”:
变式1(普通):
变体2(并行执行(更快)):
这看起来很疯狂,但嘿它有效
这很有效 . Magic
Java for-each习惯用法只能应用于 *Iterable 类型的数组或对象 . 这个成语是 implicit ,因为它真的得到了迭代器的支持 . 迭代器由程序员编程,通常使用整数索引或节点(取决于数据结构)来跟踪其位置 . 在纸面上它比常规for循环慢,至少对于像数组和列表这样的结构,但它提供了更大的抽象 .
迭代Items表中的所有对象 .
如_135779中所定义的for-each循环可以有两种形式:
Iterable
的子类型,那么翻译如下:T[]
,则:Java 8引入了通常表现更好的流 . 我们可以将它们用作:
Java中的for-each循环使用底层迭代器机制 . 所以它与以下内容相同:
使用包含
Java 7
的旧Java版本,您可以使用foreach
循环,如下所示 .以下是在
Java 8
中使用foreach
循环的最新方法(使用
forEach
lambda表达式或方法引用循环List有关更多信息,请参阅此链接 .
https://www.mkyong.com/java8/java-8-foreach-examples/
在Java 8中,他们介绍了forEach . 使用它List,可以循环 Map .
Loop a List using for each
要么
Loop a Map using for each
要么
维基百科中提到的foreach循环的概念如下所示:
所以foreach循环的概念描述了循环不使用任何显式计数器,这意味着不需要使用索引遍历列表,因此它可以使用户免于一个错误 . 为了描述这个逐个错误的一般概念,让我们举一个循环的例子来使用索引在列表中遍历 .
但是假设如果列表以索引1开始,则此循环将抛出异常,因为它将在索引0处找不到任何元素,并且此错误称为逐个错误 . 因此,为了避免这种逐个错误,使用了foreach循环的概念 . 也可能有其他优点,但我认为这是使用foreach循环的主要概念和优势 .
在Java 8之前,您需要使用以下内容:
但是,随着Java 8中Streams的引入,你可以用更少的语法做同样的事情 . 例如,对于
someList
,你可以这样做:你可以找到更多关于stream here的信息 .
在Java 5(也称为"enhanced for loop")中添加的foreach loop等同于使用java.util.Iterator - 的语法糖同样的东西 . 因此,当逐个读取每个元素并按顺序时,应始终在迭代器上选择
foreach
,因为它更方便和简洁 .foreach
迭代器
在某些情况下,您必须直接使用
Iterator
. 例如,在使用foreach
can(将?)时尝试删除元素会导致ConcurrentModificationException
.foreach vs.for:基本差异
for
和foreach
之间唯一的实际区别在于,对于可索引对象,您无权访问索引 . 需要基本for
循环的示例:虽然您可以使用
foreach
手动创建单独的索引int-variable,不建议这样做,因为variable-scope并不理想,基本的
for
循环只是这个用例的标准和预期格式 .foreach vs.for:性能
访问集合时,
foreach
比for
循环的基本数组访问significantly faster . 然而,当访问数组时 - 至少使用原始数据包和包装器数组 - 通过索引进行访问的速度要快得多 .定时原始int数组的迭代器和索引访问之间的区别
访问
int
或Integer
数组时,索引比迭代器快23-40% . 这是本文底部测试类的输出,它将100个元素的原始数组中的数字相加(A是迭代器,B是索引):我也为一个
Integer
阵列运行了这个,索引仍然是明显的赢家,但速度只有18%到25% .对于集合,迭代器比索引更快
然而,对于
Integers
来说,迭代器是明显的赢家 . 只需将测试类中的int数组更改为:并对测试函数进行必要的更改(
int[]
到List<Integer>
,length
到size()
等):在一次测试中,它们几乎相同,但是使用集合,迭代器获胜 .
*这篇文章基于我在Stack Overflow上写的两个答案:
Uses and syntax for for-each loop in Java
Should I use an Iterator or a forloop to iterate?
更多信息:Which is more efficient, a for-each loop, or an iterator?
完整的测试类
一世在Stack Overflow上阅读this question之后,创建了这个比较 - 时间 - 任意两件事的类:
每个构造对数组也有效 . 例如
这基本上相当于
所以,总体总结:
[nsayer]以下是发生的事情的较长形式:
[Denis Bueno]
正如许多好的答案所说,如果一个对象想要使用
for-each
循环,它必须实现Iterable interface
.我将发布一个简单的示例,并尝试以不同的方式解释
for-each
循环的工作原理 .for-each
循环示例:然后,如果我们使用
javap
来反编译这个类,我们将得到这个字节码样本:正如我们从示例的最后一行所看到的,编译器将自动将
for-each
关键字的使用转换为在编译时使用Iterator
. 这可以解释为什么没有实现Iterable interface
的对象在尝试使用for-each
循环时会抛出Exception
.在Java 8功能中,您可以使用:
输出
Java“for-each”循环结构将允许迭代两种类型的对象:
T[]
(任何类型的数组)java.lang.Iterable<T>
Iterable<T>
接口只有一个方法:Iterator<T> iterator()
. 这适用于Collection<T>
类型的对象,因为Collection<T>
接口扩展Iterable<T>
.它通过删除所有基本的循环混乱为您的代码增添了美感 . 它为您的代码提供了一个干净的外观,下面证明了这一点 .
Normal for loop:
Using for-each:
for-each 是实现 Iterator 的集合上的构造 . 请记住,您的收藏应该实施 Iterator ;否则你不能将它与for-each一起使用 .
以下行读作“列表中的每个TimerTask t” .
在for-each的情况下出错的可能性较小 . 您不必担心初始化迭代器或初始化循环计数器并终止它(存在错误的范围) .
这是一个不承担Java迭代器知识的答案 . 它不太精确,但对教育很有用 .
在编程时,我们经常编写如下代码:
foreach语法允许以更自然且更少语法噪声的方式编写此常见模式 .
此外,此语法对于不支持数组索引但实现Java Iterable接口的Lists或Sets等对象有效 .
它看起来像这样 . 非常苛刻 .
Sun documentation中的每个都有一个很好的写法 .
foreach循环语法是:
例:
输出:
警告:您可以使用foreach循环访问数组元素,但不能初始化它们 . 使用原始的
for
循环 .警告:您必须将数组的类型与其他对象匹配 .
如果要编辑元素,请使用原始
for
循环,如下所示:现在,如果我们将s转储到控制台,我们得到:
另请注意,在原始问题中使用“foreach”方法确实存在一些限制,例如在迭代期间无法从列表中删除项目 .
新的for循环更容易阅读,并且不需要单独的迭代器,但只能在只读迭代过程中使用 .
请注意,如果您需要在循环中使用
i.remove();
,或以某种方式访问实际的迭代器,则无法使用for ( : )
成语,因为实际的迭代器只是推断出来的 .正如Denis Bueno所指出的,此代码适用于实现Iterable interface的任何对象 .
此外,如果
for (:)
成语的右侧是array
而不是Iterable
对象,则内部代码使用int索引计数器并检查array.length
. 见Java Language Specification .Java for each loop(也称为增强型for循环)是for循环的简化版本 . 优点是编写的代码更少,管理的变量更少 . 缺点是您无法控制步长值,也无法访问循环体内的循环索引 .
当步长值是1的简单增量并且只需要访问当前循环元素时,最好使用它们 . 例如,如果需要循环遍历数组或Collection中的每个元素,而不在当前元素的前面或后面偷看 .
没有循环初始化,没有布尔条件,步骤值是隐式的,是一个简单的增量 . 这就是为什么它们被认为比循环的常规简单得多 .
增强的for循环遵循以下执行顺序:
1)循环体
2)从步骤1开始重复,直到遍历整个数组或集合
Example – Integer Array
currentValue变量保存在intArray数组中循环的当前值 . 请注意,没有明确的步骤值 - 它总是增加1 .
结肠可以被认为是指“在”中 . 因此增强的for循环声明表明:循环遍历intArray并将当前数组存储为int值 in currentValue变量 .
输出:
Example – String Array
我们可以使用for-each循环迭代一个字符串数组 . 循环声明声明:遍历myStrings String数组并存储当前String值 in currentString变量 .
输出:
Example – List
增强的for循环也可用于迭代java.util.List,如下所示:
循环声明声明:遍历myList字符串列表并存储当前List值 in currentItem变量 .
输出:
Example – Set
增强的for循环也可用于迭代java.util.Set,如下所示:
循环声明声明:循环遍历mySet字符串集并存储当前Set值 in currentItem变量 . 请注意,由于这是一个Set,因此不会存储重复的String值 .
输出:
资料来源:Loops in Java – Ultimate Guide