精华内容
下载资源
问答
  • 2014-08-29 22:33:28
    public static void test(){
    		int arr[] = {4,2,3};
    		for(int i : arr){
    			System.out.println(i);
    		}
    	}


    下面是list

    public static void test2(){
    		List list = new ArrayList();
    		list.add(1);
    		list.add(3);
    		list.add(4);
    		
    		for(Object obj : list){
    			int i = (Integer)obj;
    			System.out.println(i);
    		}
    	}

    下面是map

    public void test3(){
    		Map map = new HashMap();
    		map.put(1, "aa");
    		map.put(2, "bb");
    		map.put(3, "dd");
    		
    		for(Object obj : map.keySet()){
    			Integer k = (Integer) obj;
    			String v = (String)map.get(k);
    			System.out.println(k+"::"+v);
    		}
    	}

    此方法比较适合取数据,不适合修改数据

    更多相关内容
  • 增强的for循环是在传统的for循环中增加的强大的迭代功能的循环,是在jdk1.5之后提出来的。下面这篇文章主要给大家介绍了关于Java增强for循环的实现原理和坑的相关资料,需要的朋友可以参考下
  • 下面小编就为大家带来一篇Java中增强for循环在一维数组和二维数组的使用方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Java中增强for循环总结

    千次阅读 2021-02-26 10:19:36
    1 增强for循环增强for循环是for的一种新用法!用来循环遍历数组和集合。1.1 增强for的语法for(元素类型 e : 数组或集合对象) {}例如:int[] arr = {1,2,3};for(int i : arr) {System.out.println(i);}增强for的...

    1 增强for循环

    增强for循环是for的一种新用法!用来循环遍历数组和集合。

    1.1 增强for的语法

    for(元素类型 e : 数组或集合对象) {

    }

    例如:

    int[] arr = {1,2,3};

    for(int i : arr) {

    System.out.println(i);

    }

    增强for的冒号左边是定义变量,右边必须是数组或集合类型。例如上例中循环遍历的主浊arr这个int数组,增强for内部会依次把arr中的元素赋给变量i。

    1.2 增强for的优缺点

    只能从头到尾的遍历数组或集合,而不能只遍历部分;

    在遍历List或数组时,不能获取当前元素下标;

    增强for使用便简单,这是它唯一的优点了;

    增强for比使用迭代器方便一点!

    1.3 增强for原理

    其实增强for内部是使用迭代器完成的!也就是说,任何实现了Iterable接口的对象都可以被增强for循环遍历!这也是为什么增强for可以循环遍历集合的原因(Collection是Iterable的子接口)。

    但要注意,Map并没有实现Iterable接口,所以你不能直接使用增强for来遍历它!

    1 Map map = new HashMap();2 map.put("1", "one");3 map.put("2", "two");4 map.put("3", "three");5

    6 for(String key : map.keySet() ) {7 String value =map.get(key);8 System.out.println(key + "=" +value);9 }

    map.keySet()循环遍历map的所有键,map.keySet()返回的是Set类型,而Set是可以被增强for遍历的。

    一:传统的for循环和增强for循环的比较

    1 //传统的数组遍历

    2 String[] persons={"张三","李四","王五"};3 for(int i=0;i

    7 String[] persons={"张三","李四","王五"};8 for(String person:persons){9 System.out.println(person);10

    11 //传统的Iterator遍历集合

    12 List persons=new ArrayList();13 persons.add("张三");14 persons.add("李四");15 persons.add("王五");16 for(Iterator i=persons.iterator();i.hasNext();){17 String person=i.next();18 System.out.println(person);19 }20 //使用增强For循环遍历集合

    21 List persons=new ArrayList();22 persons.add("张三");23 persons.add("李四");24 persons.add("王五");25 for(String person:persons){26 System.out.println(person);27 }

    可以看到使用增强for循环使得代码变得短小而精炼的多,如果你觉得这点变化还体现不出来,可以忍受,那你可以试试嵌套for循环,就会感觉到增强for循环的好处了,这里就不贴代码了。

    二:定制自己的增强for循环

    众所周知,增强for循环是按数组或者集合的内在顺序输出的,如果我们想在遍历的时候定制行为怎么做呢?下面就以一个逆序输出的例子说明怎么定制自己的增强for循环。

    要想使用增强for循环,必须实现Iterable接口。

    ReverIterableClass.java

    1 importjava.util.Iterator;2

    3 /**

    4 * 一个简单的逆序输出增强for循环5 */

    6 public class ReverIterableClass implements Iterable{7 protectedT[] elements;8 publicReverIterableClass(T... elems) {9 this.elements=elems;10 }11 public Iteratoriterator() {12 return new Iterator(){13 private int current=elements.length-1;14 public booleanhasNext() {15 return current>-1;16 }17

    18 publicT next() {19 return elements[current--];20 }21

    22 public voidremove() {23 throw new UnsupportedOperationException("目前不支持删除操作");24 }25 };26 }27 public static voidmain(String[] args){28 ReverIterableClass iterableClass=new ReverIterableClass("a","b","c","d");29 for(String s:iterableClass){30 System.out.println(s);31 }32 }33 }

    在这个程序里我们定制了自己的输出行为--逆序输出,当然你也可以定义属于你自己的,只需要在next()函数里写处理代码即可。

    三:增强for循环的局限性

    不能在增强for循环中访问位置,例如下面的代码:

    String[] persons={"张三","李四","王五"};for(int i=0;i

    System.out.println(i+":"+persons[i]);

    }

    在增强for循环中你是得不到这个位置"i"的。

    例如还有我们常用的在组合sql语句,select字段的时候,当是最后一个字段时,不能加","的。

    1 String[] fields={"name","age","sex"};2 StringBuilder sql=new StringBuilder("select ");3 for(int i=0;i

    这在增强for循环中也是不能处理的。。

    还有对元素的删除,在增强for循环中也不能做到,但是使用传统的Iterator接口遍历时就可以使用他的remove()方法删除符合条件的元素。

    四:小结

    增强for循环有它的好处,比如简洁,代码优雅,如果能使用增强for循环,一定要优先使用。

    展开全文
  • Is there a way to determine if the loop is iterating for the last time. My code looks something like this:int[] array = {1, 2, 3...};StringBuilder builder = new StringBuilder();for(int i : array){buil...

    Is there a way to determine if the loop is iterating for the last time. My code looks something like this:

    int[] array = {1, 2, 3...};

    StringBuilder builder = new StringBuilder();

    for(int i : array)

    {

    builder.append("" + i);

    if(!lastiteration)

    builder.append(",");

    }

    Now the thing is I don't want to append the comma in the last iteration. Now is there a way to determine if it is the last iteration or am I stuck with the for loop or using an external counter to keep track.

    解决方案

    Another alternative is to append the comma before you append i, just not on the first iteration. (Please don't use "" + i, by the way - you don't really want concatenation here, and StringBuilder has a perfectly good append(int) overload.)

    int[] array = {1, 2, 3...};

    StringBuilder builder = new StringBuilder();

    for (int i : array) {

    if (builder.length() != 0) {

    builder.append(",");

    }

    builder.append(i);

    }

    The nice thing about this is that it will work with any Iterable - you can't always index things. (The "add the comma and then remove it at the end" is a nice suggestion when you're really using StringBuilder - but it doesn't work for things like writing to streams. It's possibly the best approach for this exact problem though.)

    展开全文
  • foreach 是 Java 的一种语法糖,几乎每一种语言都有一些这样的语法糖来方便程序员进行开发,编译期间以特定的字节码或特定的方式来对这些语法进行处理。能够提高性能,并减少代码出错的几率。
  • 下面小编就为大家带来一篇java增强for循环的实现方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • NULL 博文链接:https://rensanning.iteye.com/blog/2003205
  • Java中普通for循环和增强for循环的对比

    Java中普通for循环和增强for循环的对比
     今天刷LeetCode时发现对于普通数组用普通for循环比用增强for each循环耗时少,因此在网上查找了资料之后决定自己通过反编译进行比较。
    测试代码
    反编译之后的结果:
    反编译之后的代码
     通过javap -v-c-l 反编译之后发现,增强for循环底层是通过迭代器iterator来实现的,next,hasNext();而普通for循环就是单纯根据下标进行访问。因此我们可以知道,当数据量大时在对底层通过数组实现的ArrayList进行普通for循环访问时,普通for循环是要比增强for循环快的。在对LinkedList用增强for循环遍历时要比用普通for循环快。
    我们先用十万数据量进行测试:
     测试代码:

    public static void main(String[] args) {
        List<Integer> arrayList = new ArrayList<Integer>();
        List<Integer> linkList = new LinkedList<Integer>();
        // 每个集合插入10万条数据
        for (int i = 0; i < 100000; i++) {
            arrayList.add(i);
            linkList.add(i);
        }
    
        int arry = 0;
    
        System.out.println("============遍历arrayList============");
    
        // 用for循环arrayList
        long forStartTime = System.currentTimeMillis();
        for (int i = 0; i < arrayList.size(); i++) {
            arry = arrayList.get(i);
        }
        long forEndTime = System.currentTimeMillis();
        System.out.println("for遍历需要:" + (forEndTime - forStartTime) + "毫秒");
    
    
        // 用增强for循环arrayList
        long forUpStartTime = System.currentTimeMillis();
        for (Integer in : arrayList) {
            arry = in;
        }
        long forUpEndTime = System.currentTimeMillis();
        System.out.println("增强for遍历需要:" + (forUpEndTime - forUpStartTime) + "毫秒");
    
    
        System.out.println("============linkList============");
    
        // 用for循环linkList
        long linkForStartTime = System.currentTimeMillis();
        int link = 0;
        for (int i = 0; i < linkList.size(); i++) {
            link = linkList.get(i);
        }
        long linkForEndTime = System.currentTimeMillis();
        System.out.println("for遍历:" + (linkForEndTime - linkForStartTime) + "毫秒");
    
        // 用增强for循环linkList
        long linkForeachStartTime = System.currentTimeMillis();
        for (Integer in : linkList) {
            link = in;
        }
        long linkForeachEndTime = System.currentTimeMillis();
        System.out.println("用增强for遍历需要:" + (linkForeachEndTime - linkForeachStartTime) + "毫秒");
    
    }
    

    十万数据量结果:
    十万数据量结果
    插入百万数据量结果:
    插入百万数据量结果对比
     从上面结果可以看出,插入10万数据量时,对于ArrayList来说,普通for循环和增强for循环时间都是3ms,当数据上升到百万时,普通for循环要比增强for循环快;对于LinkedList来说,10万数据量时,普通for循环比增强for循环慢了很多个数量级。当增加到百万数据量时,增强for循环所使用的时间只用了10ms,但是普通for循环的时间就很长了,已经达到1268秒以上。
     既然这次讨论了普通for循环和增强for循环,下次我会继续比较普通for、增强for以及java8 新增的foreach。

    展开全文
  • 在本篇文章里小编给大家整理是的关于Java中如何使用增强for循环的实例内容以及相关代码,需要的朋友们可以学习下。
  • 主要介绍了详解Java中list,set,map的遍历与增强for循环的相关资料,需要的朋友可以参考下
  • 刷题时想用增强for循环来给初始数组赋值,结果发现了问题。所以记录学习一下增强for循环的用法。 1. 增强for循环 增强for循环是for的一种新用法!用来循环遍历数组和集合。 2. 语法 for (元素类型 e : 数组或...
  • Java中增强for循环

    千次阅读 2021-10-11 15:43:02
    增强for循环定义如下: for(ElementType element: arrayName){}; 例1: int[] num = {1,2,3,4,5,6}; for(int i: num){ System.out.print(i); } 例2: int[] num = {1,2,3,4,5,6}; for(int i = 0; i <...
  • java代码-使用java增强for循环 string数组赋值的源代码 ——学习参考资料:仅用于个人学习使用!
  • 首先普通for循环是能获取元素下标,并能通过下标遍历元素,而增强for却不可以获取下标,因此在遍历时的效率不同。当为数组时,效率几乎是差不多的当为集合时效率却大不同,当为ArrayLIst时,普通for的效率高于增强...
  • Java实用技巧---增强for循环

    千次阅读 2022-02-13 09:45:53
    1、泛型接口 把泛型定义在接口上 格式:public interface 接口名<泛型类型1…>...2、增强for循环概述:简化数组和Collection集合的遍历 语句定义格式: for(元素数据类型 变量名(自定义)..
  • java中增强for循环的原理

    千次阅读 2016-10-23 13:30:05
    import java.util.ArrayList; import java.util.List;...public class TestFor { public static void main(String[] args) { List&lt;String&gt; lists = new ArrayList&lt;String&gt;();
  • Java中增强for循环

    2017-07-10 16:27:16
    package tk.zhangwei.array2; /*** * * jdk新特性 */ import java.util.Arrays;public class test02 { public static void main(String[] args){ int[] a = {15,12,45,84,87,23,42}; for(int i :
  • Java中增强for循环

    2020-06-02 19:06:39
    高级for循环 格式为: 格式:for(数据类型 变量名 : 被遍历的集合(Collection)或者数组) { } 特点:对集合进行遍历。只能获取集合元素。但是不能对集合进行操作。 迭代器除了遍历,还可以进行remove集合元素...
  • 增强型的for循环 和普通for循环一样 增强型的for循环 优点主要体现在集合,随便举个例子 比如对 set 的遍历 一般是迭代遍历
  • java中增强for循环

    2022-02-12 16:14:21
    /*增强for循环 * 语法格式: * for(元素类型 变量名: 数组或集合) { * System.out.println(变量名); * } * 缺点:没有下标,在需要使用下标的循环中不建议使用*/ public class ForEachTest01 { public static void ...
  • 转载: ... 在JAVA中,遍历集合和数组一般有以下三种形式: 第一种是普通的for循环遍历、第二种是使用迭代器...可以看到,第三种形式是JAVA提供的语法糖,这里我们剖析一下,这种增强for循环底层是如何实现的。 ...
  • 下面小编就为大家带来一篇浅谈java 增强型的for循环 for each。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 引入增强for循环的原因:在JDK5以前的版本,遍历数组或集合的元素,需要先获得数组的长度或集合的迭代器,比较麻烦。 JDK5定义了一种新的语法—-增强for循环,以简化此类操作。增强for循环只能用在数组或实现...
  • Java中for的几种常见形式 1.For loop using index. for (int i = 0; i &lt; arr.length; i++) { type var = arr[i]; body-of-loop } 复制代码2.Loop using explicit iterator. for (Iterator&lt;type&...
  • 现在重新学习下,为什么在增强for循环中容器不能直接remove 开始前,先说一下增强for循环是什么鬼,就是咱们常用的for(数据类型 变量名 :遍历的目标){},底层还是使用了迭代器遍历。好了,开搞 一、List 1...
  • public class Test4 { public static void main(String[] args) { int[] intArray = {1, 2, 4, 5, 7, 8}; for(int number : intArray) { System.out.println(number); } } }

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 75,631
精华内容 30,252
关键字:

java中增强for循环

java 订阅