java新特性之for循环最全的用法总结
增强for循环，也叫Foreach循环，用于数组和容器（集合类）的遍历。使用foreach循环遍历数组和集合元素时，无需获得数组和集合长度，无需根据索引来访问数组元素和集合元素，大大提高的效率，代码也简洁不少。
2. Oracle官网的解释
所以你应该什么时候使用for-each循环？任何时候都可以。这真的美化你的代码。不幸的是，你不能在任何地方使用它。考虑这些情况，例如，删除方法。为了移除当前的元素，该程序需要访问迭代器。for-each循环隐藏了迭代器，所以你不能调用删除功能。因此，for-each循环不适用于过滤元素。同样当遍历集合或数组时需要替换元素的循环也是不适用的。最后，它不适用于多个集合迭代中并行循环使用。设计师应该了解这些缺陷，有意识地设计一个干净，简单的构造，来避免这些情况。有兴趣的可以查看官网的API，如果不知道怎么在官网找到API，请点击打开官网查看API方法。
3. 增强for格式
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
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中文网！