java新特性之for循环最全的用法总结-java教程-PHP中文网

1. 增强for概述

增强for循环，也叫Foreach循环，用于数组和容器（集合类）的遍历。使用foreach循环遍历数组和集合元素时，无需获得数组和集合长度，无需根据索引来访问数组元素和集合元素，大大提高的效率，代码也简洁不少。

2. Oracle官网的解释

所以你应该什么时候使用for-each循环？任何时候都可以。这真的美化你的代码。不幸的是，你不能在任何地方使用它。考虑这些情况，例如，删除方法。为了移除当前的元素，该程序需要访问迭代器。for-each循环隐藏了迭代器，所以你不能调用删除功能。因此，for-each循环不适用于过滤元素。同样当遍历集合或数组时需要替换元素的循环也是不适用的。最后，它不适用于多个集合迭代中并行循环使用。设计师应该了解这些缺陷，有意识地设计一个干净，简单的构造，来避免这些情况。有兴趣的可以查看官网的API，如果不知道怎么在官网找到API，请点击打开官网查看API方法。

3. 增强for格式

立即学习“Java免费学习笔记（深入）”；

for(集合或者数组元素的类型 变量名 ： 集合对象或者数组对象){
 
引用变量名的java语句;
 
}

登录后复制

当你看到冒号(:),它读作“进来。”上述循环读作“把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;
        for (Iterator iterator = array.iterator(); iterator.hasNext(); System.out.println(string)) {
            string = (String) iterator.next();
 
        }
 
        // 迭代器实现
        System.out.println("------Iterator------");
        for (Iterator<String> i = array.iterator(); i.hasNext(); System.out.println(i.next())) {
 
        }
 
        // 普通for实现
        System.out.println("-----general for-----");
        for (int x = 0; x < array.size(); x++) {
            System.out.println(array.get(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 (array.contains("java"))
 array.add(1, "love");
 }
 
 }

登录后复制

3.泛型与增强for完美结合

注意：必须要与泛型完美结合，不然还得手动向下转型

1.没有泛型效果，不能使用增强for

BibiGPT-哔哔终结者

B站视频总结器-一键总结音视频内容

查看详情

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.println(i.next());
 String s = (String) i.next();
 for (Iterator j = list2.iterator(); j.hasNext();) {
 // list2.add(new Student(s,j.next()));
 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().append(st.getName1()).append(st.getName2()))) {
 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().append(st.getName1()).append(st.getName2()));
 }
 }
}

登录后复制

4.List集合遍历四种方法

Collection接口中有iterator()方法，返回的是Iterator类型，有一个迭代器为Iterator。List中有listIterator()方法，所以多了一个集合器ListIterator，其子类LinkedList、ArrayList、Vector都实现了List和Collection接口，所以都可以用两个迭代器遍历。

代码测试

package cn.jason05;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
 
/**
 * 这是List集合遍历四种方法
 *
 * @author cassandra
 */
 
public class ForDemo01 {
 public static void main(String[] args) {
 // 创建集合
 List<String> list = new ArrayList<String>();
 list.add("hello");
 list.add("world");
 list.add("java");
 
 // 方法1，Iterator迭代器遍历
 Iterator<String> i = list.iterator();
 while (i.hasNext()) {
 String s = i.next();
 System.out.println(s);
 }
 
 // 方法2，ListIterator迭代器遍历集合
 ListIterator<String> lt = list.listIterator();
 while (lt.hasNext()) {
 String ss = lt.next();
 System.out.println(ss);
 }
 
 // 方法3，普通for遍历集合
 for (int x = 0; x < list.size(); x++) {
 String sss = list.get(x);
 System.out.println(sss);
 }
 
 // 方法4，增强for遍历集合
 for (String ssss : list) {
 System.out.println(ssss);
 }
 
 }
}

登录后复制

5.Set集合遍历2中方法

由于Set集合没有get(int index)方法，所以没有普通for循环，Set中没有listIterator()方法，所以没有ListIterator迭代器。所以只有两种遍历方式。

代码测试

package cn.jason05;
 
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
 
public class ForTest03 {
 public static void main(String[] args) {
 Set<String> set = new HashSet<String>();
 set.add("hello");
 set.add("world");
 set.add("java");
 
 // 方法1，Iterator迭代器遍历集合
 Iterator<String> it = set.iterator();
 while (it.hasNext()) {
 System.out.println(it.next());
 }
 
 // 方法2，增强for遍历集合
 for (String s : set) {
 System.out.println(s);
 }
 
 }
}

登录后复制

7.归纳总结

1.增强for的适用性以及局限性

适用性：适用于集合和数组的遍历。

局限性：

①集合不能为null，因为底层是迭代器。

②不能设置角标。

③隐藏了迭代器，所以在遍历集合时不能对集合进行修改(增删)。

2.在集合中增强for与泛型结合，才能发挥新特性的作用。

3.查看官网新特性挺重要的，要知其然还要知其所以然，了如心中，才能运用自如。

以上这篇java新特性之for循环最全的用法总结就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持PHP中文网。

更多java新特性之for循环最全的用法总结相关文章请关注PHP中文网！