溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章將為大家詳細講解有關foreach循環怎么在java8項目中使用，文章內容質量較高，因此小編分享給大家做個參考，希望大家閱讀完這篇文章后對相關知識有一定的了解。
1.首先遍歷一個List
方式1.一開始是這樣的：
public static void test1(List<String> list) {
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}方式2.當然稍微高級一點的是這樣：
public static void test2(List<String> list) {
for (int i = 0,lengh=list.size(); i < lengh; i++) {
System.out.println(list.get(i));
}
}方式3.還有就是Iterator遍歷：
public static void test3(List<String> list) {
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}方式4.后來有了增強for循環：
public static void test4(List<String> list) {
for(String str:list){
System.out.println(str);
}
}方式5.java8以后新增的方式：
public static void test5(List<String> list) {
//list.forEach(System.out::println);和下面的寫法等價
list.forEach(str->{
System.out.println(str);
});
}方式6.還有另一種：
public static void test6(List<String> list) {
list.iterator().forEachRemaining(str->{
System.out.println(str);
});
}應該沒有其他的了吧，上面六中方法，按我的使用習慣5最常用，4偶爾使用，其他的基本就不怎么用了，使用5的原因是因為方便書寫，提示就可以寫出來，偶爾使用4的原因是，5不方便計數用，下面進行性能測試，String不具備代表性，決定使用對象，簡單的一個測試類如下：
一個簡單的測試，內容不要太在意，簡單計算hashCode：
package test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test8 {
public static void main(String[] args) {
List<Dog> list=new ArrayList<>();
for(int i=0;i<10;i++){
list.add(new Dog(i,"dog"+i));
}
long nanoTime = System.nanoTime();
test1(list);
long nanoTime1 = System.nanoTime();
test2(list);
long nanoTime2 = System.nanoTime();
test3(list);
long nanoTime3 = System.nanoTime();
test4(list);
long nanoTime4 = System.nanoTime();
test5(list);
long nanoTime5 = System.nanoTime();
test6(list);
long nanoTime6 = System.nanoTime();
System.out.println((nanoTime1-nanoTime)/1000000.0);
System.out.println((nanoTime2-nanoTime1)/1000000.0);
System.out.println((nanoTime3-nanoTime2)/1000000.0);
System.out.println((nanoTime4-nanoTime3)/1000000.0);
System.out.println((nanoTime5-nanoTime4)/1000000.0);
System.out.println((nanoTime6-nanoTime5)/1000000.0);
}
public static void test1(List<Dog> list) {
for (int i = 0; i < list.size(); i++) {
list.get(i).hashCode();
}
}
public static void test2(List<Dog> list) {
for (int i = 0,lengh=list.size(); i < lengh; i++) {
list.get(i).hashCode();
}
}
public static void test3(List<Dog> list) {
Iterator<Dog> iterator = list.iterator();
while(iterator.hasNext()){
iterator.next().hashCode();
}
}
public static void test4(List<Dog> list) {
for(Dog dog:list){
dog.hashCode();
}
}
public static void test5(List<Dog> list) {
//list.forEach(System.out::println);和下面的寫法等價
list.forEach(dog->{
dog.hashCode();
});
}
public static void test6(List<Dog> list) {
list.iterator().forEachRemaining(dog->{
dog.hashCode();
});
}
}
class Dog{
private int age;
private String name;
public Dog(int age, String name) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Dog [age=" + age + ", name=" + name + "]";
}
}運行三次取平均值，機器配置就不說了，因為我不是比較的絕對值，我是比較的這幾種方式的相對值，數據結果，趨勢圖如下：
然后去掉表現一直很穩定的方式5和百萬級數據量以上的數據，來分析結果：
可以得出一個非常嚇人的結果，java8的foreach每次循環的耗時竟然高達100毫秒以上，雖然它比較穩定（算是優點吧）。所以得出以下結論：
在正常使用（數據量少于百萬以下），正常（非并行）遍歷一個集合的時候：
•不要使用java8的foreach，每次耗時高達100毫秒以上
•提前計算出大小的普通for循環，耗時最小，但是書寫麻煩
•增強for循環表現良好
2.再次遍歷一個Set
使用以相同的方式測試HashSet，測試方法如下：
package test;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Test9 {
public static void main(String[] args) {
Set<Dog> set = new HashSet<>();
for (int i = 0; i < 10_000_000; i++) {
set.add(new Dog(i, "dog" + i));
}
long nanoTime = System.nanoTime();
test1(set);
long nanoTime1 = System.nanoTime();
test2(set);
long nanoTime2 = System.nanoTime();
test3(set);
long nanoTime3 = System.nanoTime();
test4(set);
long nanoTime4 = System.nanoTime();
System.out.println((nanoTime1 - nanoTime) / 1000000.0);
System.out.println((nanoTime2 - nanoTime1) / 1000000.0);
System.out.println((nanoTime3 - nanoTime2) / 1000000.0);
System.out.println((nanoTime4 - nanoTime3) / 1000000.0);
}
public static void test1(Set<Dog> list) {
Iterator<Dog> iterator = list.iterator();
while (iterator.hasNext()) {
iterator.next().hashCode();
}
}
public static void test2(Set<Dog> list) {
for (Dog dog : list) {
dog.hashCode();
}
}
public static void test3(Set<Dog> list) {
list.forEach(dog -> {
dog.hashCode();
});
}
public static void test4(Set<Dog> list) {
list.iterator().forEachRemaining(dog -> {
dog.hashCode();
});
}
}經過計算得出如下結果：
不難發現，java8的foreach依然每次耗時100ms以上，最快的變成了增強for循環，Iterator遍歷和java8的iterator().forEachRemaining差不多。
3.最后遍歷Map
依然使用相同的方式測試Map集合遍歷，測試類如下：
package test;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Test10 {
public static void main(String[] args) {
Map<String, Dog> map = new HashMap<>();
for (int i = 0; i < 1000_000; i++) {
map.put("dog" + i, new Dog(i, "dog" + i));
}
long nanoTime = System.nanoTime();
test1(map);
long nanoTime1 = System.nanoTime();
test2(map);
long nanoTime2 = System.nanoTime();
test3(map);
long nanoTime3 = System.nanoTime();
test4(map);
long nanoTime4 = System.nanoTime();
System.out.println((nanoTime1 - nanoTime) / 1000000.0);
System.out.println((nanoTime2 - nanoTime1) / 1000000.0);
System.out.println((nanoTime3 - nanoTime2) / 1000000.0);
System.out.println((nanoTime4 - nanoTime3) / 1000000.0);
}
public static void test1(Map<String, Dog> map) {
Iterator<Map.Entry<String, Dog>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry<String, Dog> entry = entries.next();
int code=entry.getKey().hashCode()+entry.getValue().hashCode();
}
}
public static void test2(Map<String, Dog> map) {
for (Map.Entry<String, Dog> entry : map.entrySet()) {
int code=entry.getKey().hashCode()+entry.getValue().hashCode();
}
}
public static void test3(Map<String, Dog> map) {
for (String key : map.keySet()) {
int code=key.hashCode()+map.get(key).hashCode();
}
}
public static void test4(Map<String, Dog> map) {
map.forEach((key, value) -> {
int code=key.hashCode()+value.hashCode();
});
}
}結果如下：
java8的foreach依然不負眾望，最快的是增強for循環。
關于foreach循環怎么在java8項目中使用就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
