- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
CFSDN坚持开源创造价值,我们致力于搭建一个资源共享平台,让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章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格式 。
1
2
3
4
5
|
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遍历数组 。
1
2
3
4
5
6
7
8
9
10
|
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遍历集合 。
。
。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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底层原理 。
先看代码 。
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
|
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在数组中用法 。
。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
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在集合中用法 。
。
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
|
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类 。
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
|
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;
}
}
|
测试代码 。
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
|
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 。
泛型修改上面代码 。
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
|
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接口,所以都可以用两个迭代器遍历.
代码测试 。
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
|
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迭代器。所以只有两种遍历方式.
代码测试 。
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
|
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循环最全的用法总结就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我.
最后此篇关于java新特性之for循环最全的用法总结的文章就讲到这里了,如果你想了解更多关于java新特性之for循环最全的用法总结的内容请搜索CFSDN的文章或继续浏览相关文章,希望大家以后支持我的博客! 。
我是 PHP 新手。我一直在脚本中使用 for 循环、while 循环、foreach 循环。我想知道 哪个性能更好? 选择循环的标准是什么? 当我们在另一个循环中循环时应该使用哪个? 我一直想知道要
我在高中的编程课上,我的作业是制作一个基本的小计和顶级计算器,但我在一家餐馆工作,所以制作一个只能让你在一种食物中读到。因此,我尝试让它能够接收多种食品并将它们添加到一个价格变量中。抱歉,如果某些代码
这是我正在学习的一本教科书。 var ingredients = ["eggs", "milk", "flour", "sugar", "baking soda", "baking powder",
我正在从字符串中提取数字并将其传递给函数。我想给它加 1,然后返回字符串,同时保留前导零。我可以使用 while 循环来完成此操作,但不能使用 for 循环。 for 循环只是跳过零。 var add
编辑:我已经在程序的输出中进行了编辑。 该程序要求估计给定值 mu。用户给出一个值 mu,同时还提供了四个不等于 1 的不同数字(称为 w、x、y、z)。然后,程序尝试使用 de Jaeger 公式找
我正在编写一个算法,该算法对一个整数数组从末尾到开头执行一个大循环,其中包含一个 if 条件。第一次条件为假时,循环可以终止。 因此,对于 for 循环,如果条件为假,它会继续迭代并进行简单的变量更改
现在我已经习惯了在内存非常有限的情况下进行编程,但我没有答案的一个问题是:哪个内存效率更高;- for(;;) 或 while() ?还是它们可以平等互换?如果有的话,还要对效率问题发表评论! 最佳答
这个问题已经有答案了: How do I compare strings in Java? (23 个回答) 已关闭 8 年前。 我正在尝试创建一个小程序,我可以在其中读取该程序的单词。如果单词有 6
这个问题在这里已经有了答案: python : list index out of range error while iteratively popping elements (12 个答案) 关
我正在尝试向用户请求 4 到 10 之间的整数。如果他们回答超出该范围,它将进入循环。当用户第一次正确输入数字时,它不会中断并继续执行 else 语句。如果用户在 else 语句中正确输入数字,它将正
我尝试创建一个带有嵌套 foreach 循环的列表。第一个循环是循环一些数字,第二个循环是循环日期。我想给一个日期写一个数字。所以还有另一个功能来检查它。但结果是数字多次写入日期。 Out 是这样的:
我想要做的事情是使用循环创建一个数组,然后在另一个类中调用该数组,这不会做,也可能永远不会做。解决这个问题最好的方法是什么?我已经寻找了所有解决方案,但它们无法编译。感谢您的帮助。 import ja
我尝试创建一个带有嵌套 foreach 循环的列表。第一个循环是循环一些数字,第二个循环是循环日期。我想给一个日期写一个数字。所以还有另一个功能来检查它。但结果是数字多次写入日期。 Out 是这样的:
我正在模拟一家快餐店三个多小时。这三个小时分为 18 个间隔,每个间隔 600 秒。每个间隔都会输出有关这 600 秒内发生的情况的统计信息。 我原来的结构是这样的: int i; for (i=0;
这个问题已经有答案了: IE8 for...in enumerator (3 个回答) How do I check if an object has a specific property in J
哪个对性能更好?这可能与其他编程语言不一致,所以如果它们不同,或者如果你能用你对特定语言的知识回答我的问题,请解释。 我将使用 c++ 作为示例,但我想知道它在 java、c 或任何其他主流语言中的工
这个问题不太可能帮助任何 future 的访问者;它只与一个小的地理区域、一个特定的时间点或一个非常狭窄的情况有关,这些情况并不普遍适用于互联网的全局受众。为了帮助使这个问题更广泛地适用,visit
我是 C 编程和编写代码的新手,以确定 M 测试用例的质因数分解。如果我一次只扫描一次,该功能本身就可以工作,但是当我尝试执行 M 次时却惨遭失败。 我不知道为什么 scanf() 循环有问题。 in
这个问题已经有答案了: JavaScript by reference vs. by value [duplicate] (4 个回答) 已关闭 3 年前。 我在使用 TSlint 时遇到问题,并且理
我尝试在下面的代码中添加 foreach 或 for 循环,以便为 Charts.js 创建多个数据集。这将允许我在此折线图上创建多条线。 我有一个 PHP 对象,我可以对其进行编码以稍后填充变量,但
我是一名优秀的程序员,十分优秀!