java新特性之for循环最全的⽤法总结
1. 增强for概述
增强for循环，也叫Foreach循环，⽤于数组和容器（集合类）的遍历。使⽤foreach循环遍历数组和集合元素时，⽆需获得数组和集合长度，⽆需根据索引来访问数组元素和集合元素，⼤⼤提⾼的效率，代码也简洁不少。
2. Oracle官⽹的解释
So when should you use the for-each loop? Any time you can. It really beautifies your code. Unfortunately, you cannot use it everywhere. Consider, for example, the expurgate method. The program needs access to the iterator in order to remove the current element. The for-each loop hides the iterator, so you cannot call remove. Therefore, the for-each loop is not usable for filtering. Similarly it is not usable for loops where you need to replace elements in a list or array as you traverse it. Finally, it is not usable for loops that must iterate over multiple collections in parallel. These shortcomings were known by the designers, who made a conscious decision to go with a clean, simple construct that would cover the great majority of cases.
所以你应该什么时候使⽤for-each循环？任何时候都可以。这真的美化你的代码。不幸的是，你不能在任何地⽅使⽤它。考虑这些情况，例如，删除⽅法。为了移除当前的元素，该程序需要访问迭代器。for-each循环隐藏了迭代器，所以你不能调⽤删除功能。因此，for-each循环不适⽤于过滤元素。同样当遍历集合或数组时需要替换元素的循环也是不适⽤的。最后，它不适⽤于多个集合迭代中并⾏循环使⽤。设计师应该了解这些缺陷，有意识地设计⼀个⼲净，简单的构造，来避免这些情况。有兴趣的可以查看官⽹的API，如果不知道怎么在官⽹到API，请点击打开官⽹查看API⽅法。
3. 增强for格式
for(集合或者数组元素的类型变量名：集合对象或者数组对象){
引⽤变量名的java语句;
}
官⽹解释：
for (TimerTask t : c)
t.cancel();
When you see the colon (:) read it as “in.” The loop above reads as “for each TimerTask t in c.” As you can see, the for-each construct combines beautifully with generics. It preserves all of the type safety, while removing the remaining clutter. Because you don't have to declare the iterator, you don't have to provide a generic declaration for it. (The compiler does this for you behind your back, but you need not concern yourself with it.)
⼤意为：
当你看到冒号(:)，它读作“进来。”上述循环读作“把c中的每个TimerTask元素进⾏遍历。”正如你所看到的，for-each结构完美的与泛型结合。它保留了所有类型的安全性，同时去除剩余的混乱。因为你不必声明迭代器，你不必为它提供⼀个泛型的声明。（编译器在你背后已经做了，你不需要关⼼它。）
简单体验下：
1. 增强for遍历数组
package cn.jason01;
//增强for遍历数组
public class ForTest01 {
public static void main(String[] args) {
int[] array={1,2,3};
for(int element: array){
System.out.println(element);
}
}
}
2.增强for遍历集合
package cn.jason01;
import java.util.ArrayList;
public class ForTest {
public static void main(String[] args) {
// 泛型推断，后⾯可以写可以不写String
ArrayList<String> array = new ArrayList();
array.add("a");
array.add("b");
array.add("c");
for (String string : array) {
System.out.println(string);
}
}
}
4. 增强for底层原理
先看代码
package cn.jason01;
import java.util.ArrayList;
import java.util.Iterator;
/**
* 增强for底层原理
*
* @author cassandra
* @version 1.1
*/
public class ForTest {
public static void main(String[] args) {
// 泛型推断，后⾯可以写可以不写String.规范⼀些是要写上的。
ArrayList<String> array = new ArrayList();
// 添加元素
array.add("a");
array.add("b");
array.add("c");
// 增强for实现
System.out.println("----enhanced for----");
for (String string : array) {
System.out.println(string);
}
// 反编译之后的效果，也就是底层实现原理
System.out.println("---reverse compile---");
String string;
construct用法for (Iterator iterator = array.iterator(); iterator.hasNext(); System.out.println(string)) {
string = (String) ();
}
// 迭代器实现
System.out.println("------Iterator------");
for (Iterator<String> i = array.iterator(); i.hasNext(); System.out.())) {
}
// 普通for实现
System.out.println("-----general for-----");
for (int x = 0; x < array.size(); x++) {
System.out.(x));
}
}
}
从上⾯代码可以看出，底层是由迭代器实现的，增强for实际上是隐藏了迭代器，所以不⽤创建迭代器⾃然代码简洁不少。这也是增强for推出的原因，就是为了减少代码，⽅便遍历集合和数组，提⾼效率。
注意：正因为增强for隐藏了迭代器，所以⽤增强for遍历集合和数组时，要先判断是否为null，否则会抛出空指针异常。原因很简单，底层需要⽤数组或者集合对象去调⽤iterator()⽅法去创建迭代器(Iterator迭
代器是⼀个接⼝，所以要⽤⼦类来实现)，如
果是null，肯定抛出异常。
5. 增强for的适⽤性以及局限性
1.适⽤性
适⽤于集合和数组的遍历。
2.局限性：
①集合不能为null，因为底层是迭代器。
②隐藏了迭代器，所以在遍历集合时不能对集合进⾏修改(增删)。
③不能设置⾓标。
6.增强for⽤法详解
1.增强for在数组中⽤法
package cn.jason05;
import java.util.ArrayList;
import java.util.List;
/**
* 增强for⽤法
*
* @author cassandra
*/
public class ForDemo {
public static void main(String[] args) {
// 遍历数组
int[] arr = { 1, 2, 3, 4, 5 };
for (int x : arr) {
System.out.println(x);
}
}
}
2.增强for在集合中⽤法
package cn.jason05;
import java.util.ArrayList;
import java.util.List;
/**
* 增强for⽤法
*
* @author cassandra
*/
public class ForDemo {
public static void main(String[] args) {
// 遍历集合
ArrayList<String> array = new ArrayList<String>();
array.add("hello");
array.add("world");
array.add("java");
for (String s : array) {
System.out.println(s);
}
// 集合为null，抛出NullPointerException空指针异常
List<String> list = null;
if (list != null) {
for (String s : list) {
System.out.println(s);
}
}
// 增强for中添加或修改元素，抛出ConcurrentModificationException并发修改异常 for (String x : array) {
if (ains("java"))
array.add(1, "love");
}
}
3.泛型与增强for完美结合
注意：必须要与泛型完美结合，不然还得⼿动向下转型
1.没有泛型效果，不能使⽤增强for
Student类
package cn.jason01;
public class Student {
private String name1;
private String name2;
public Student() {
super();
}
public Student(String name1, String name2) {
super();
this.name1 = name1;
this.name2 = name2;
}
public String getName1() {
return name1;
}
public void setName1(String name1) {
this.name1 = name1;
}
public String getName2() {
return name2;
}
public void setName2(String name2) {
this.name2 = name2;
}
}
测试代码
package cn.jason01;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test02 {
public static void main(String[] args) {
// 创建集合1
List list1 = new ArrayList();
list1.add("a");
list1.add("b");
list1.add("c");
// 创建集合2
List list2 = new ArrayList();
list2.add("d");
list2.add("e");
list2.add("f");
// 创建集合三
List list3 = new ArrayList();
// 遍历第⼀和第⼆个集合，并添加元素到集合三
for (Iterator i = list1.iterator(); i.hasNext();) {
// System.out.());
String s = (String) i.next();
for (Iterator j = list2.iterator(); j.hasNext();) {
// list2.add(new Student(()));
String ss = (String) j.next();
list3.add(new Student(s, ss));
}
}
// 遍历集合三，并输出元素
Student st;
for (Iterator k = list3.iterator(); k.hasNext(); System.out
.println(new StringBuilder().Name1()).Name2()))) {
st = (Student) k.next();
}
}
}
上⾯的代码如果去掉注释的两⾏代码，程序就会报错，因为集合没有声明元素是什么类型，迭代器⾃然也不知道是什么类型。所以没有泛型，那么就要向下转型，只能⽤迭代器，不能⽤增强for。
2.泛型与增强for
泛型修改上⾯代码
package cn.jason01;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* 增强for和泛型完美结合
*
* @author cassandra
*/
public class Test03 {
public static void main(String[] args) {
// 创建集合1
List<String> list1 = new ArrayList<String>();
list1.add("a");
list1.add("b");
list1.add("c");
// 创建集合2
List<String> list2 = new ArrayList<String>();
list2.add("d");
list2.add("e");
list2.add("f");
// 创建集合三
List<Student> list3 = new ArrayList<Student>();
//// 遍历第⼀和第⼆个集合，并添加元素到集合三
for (String s1 : list1) {
for (String s2 : list2) {
list3.add(new Student(s1, s2));
}
}
// 遍历集合三，并输出元素
for (Student st : list3) {
System.out.println(new StringBuilder().Name1()).Name2()));
}
}
}
4.List集合遍历四种⽅法
Collection接⼝中有iterator()⽅法，返回的是Iterator类型，有⼀个迭代器为Iterator。List中有listIterator()
⽅法，所以多了⼀个集合器ListIterator，其⼦类LinkedList、ArrayList、Vector都实现了List和Collection接⼝，所以都可以⽤两个迭代器遍历。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。