精华内容
下载资源
问答
  • 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 :
    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 : a){
                System.out.print(i+" ");
            }
        }
    }
    
    展开全文
  • 增强的for循环是在传统的for循环中增加的强大的迭代功能的循环,是在jdk1.5之后提出来的。下面这篇文章主要给大家介绍了关于Java增强for循环的实现原理和坑的相关资料,需要的朋友可以参考下
  • java中增强for循环

    2014-08-29 22:33:28
    public static void test(){ int arr[] = {4,2,3}; for(int i : arr){ System.out.println(i); } }
    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);
    		}
    	}

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

    展开全文
  • 下面小编就为大家带来一篇Java中增强for循环在一维数组和二维数组的使用方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • java中增强for循环的原理

    千次阅读 2015-01-23 23:21:16
    java中增强for循环的原理 增强for循环的语句如下: for(ElementType element:arrayName){}; 遍历数组 int[] arr = {1,2,3}; for(int i = 0; i  System.out.println(arr[i]);//1,2,3 } for(int e : arr)...
    java中增强for循环的原理

    增强for循环的语句如下:
    for(ElementType element:arrayName){};

    遍历数组
    int[] arr = {1,2,3};
    for(int i = 0; i < arr.length; i++) {
      System.out.println(arr[i]);//1,2,3
    }
    for(int e : arr) {
      System.out.println(e);//1,2,3
    }

    遍历List
    List<String> list = new ArrayList<String>();
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");
    for(int i = 0; i < list.size(); i++) {
      String s = list.get(i);
      System.out.println(s);
    }
    for(String s : list) {
      System.out.println(s);
    }

    遍历Set
    Set<String> set = new HashSet<String>();
    set.add("a");
    set.add("b");
    set.add("c");
    Iterator it = set.iterator();
    while(it.hasNext()) {
      System.out.println(it.next());
    }
    for(String s : set) {
      System.out.println(s);
    }

    遍历Map
    Map<String,String> map = new HashMap<String,String>();
    map.put("a", "a");
    map.put("b", "b");
    map.put("c", "c");
    Set<Entry<String,String>> entrySet = map.entrySet();
    for(Entry<String,String> entry : entrySet) {
      System.out.println(entry.getKey() + "=" + entry.getValue());
    }

    原理
    任何实现了iterable接口的类,都有返回iterator的方法,也就是说其实增强for循环的底层是迭代器,任何实现了iterable接口的类都可以使用增强for循环来遍历。
    下面就通过一个具体的事例来说明
    class demo implements Iterable<String>{
    private String patm;
    public demo(String patm) {
    this.patm = patm;
    }
    public Iterator<String> iterator() {
    return new Iterator<String>() {
    private String[] dmeoArray = patm.split("\\s+");//使用正则表达式处理空格
    private int index = 0;//表示从0下标开始遍历!
    public boolean hasNext() {
    return index < demoArray.length;
    }
    public String next() {
    return demoArray[index++];
    }
    public void remove() {
    throw new UnsupportedOperationException("error");
    }

    };
    使用JUNIT测试方法如下
    @Test
    public void fun() {
    demo d = new demo("demo1 demo2 demo3 demo4");
    for(String s : d) {
    System.out.println(s);
    }
    }
    输出的结果将遍历整个数组。
    展开全文
  • 首先普通for循环是能获取元素下标,并能通过下标遍历元素,而增强for却不可以获取下标,因此在遍历时的效率不同。当为数组时,效率几乎是差不多的当为集合时效率却大不同,当为ArrayLIst时,普通for的效率高于增强...

    首先普通for循环是能获取元素下标,并能通过下标遍历元素,而增强for却不可以获取下标,因此在遍历时的效率不同。

    当为数组时,效率几乎是差不多的

    当为集合时效率却大不同,当为ArrayLIst时,普通for的效率高于增强for

    当为LInkedList时,增强for的效率高于普通for

    验证代码:

    package com.niuguwang.jihe;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.LinkedList;
    
    public class CollectionTest {
    
    	public static void main(String[] args) {
    //		ArrayList listtest =new ArrayList<>();
    //		LinkedList listtest =new LinkedList();
    		person[] listtest =new person[5000000];
    		for(int i=0;i<5000000;i++){
    			listtest[i]= new person("xiaoming");
    		}
    /*		
    		for(int i=0;i<5000000;i++){
    			listtest.add(new person("xiaoming"));
    		}
    		
    	*/	
    		Object p=null;
    		long start=System.currentTimeMillis();
    		for(int i=0;i<listtest.length;i++){
    			p=listtest[i];
    		}
    /*		
    		for(int i=0;i<(listtest.size());i++){
    			p = listtest.get(i);
    		}
    		*/
    		
    		System.out.println("普通for的耗用时间     "+(System.currentTimeMillis()-start));
    		long start1=System.currentTimeMillis();
    		for(Object o:listtest){
                            p=o;
                     }
    		System.out.println("增强for的耗用时间     "+(System.currentTimeMillis()-start1));
    	}
    }
    class person{
    	String name;
    
    	public person(String name) {
    		super();
    		this.name = name;
    	}
    	
    }

    其次集合中的元素动态删除时,增强for无法动态删除,而普通for可以动态删除。在增强for动态删除时会报一个 java.util.ConcurrentModificationException的错误,而普通for却没有这个问题,但是每删除一个元素时,集合的size会发生变化,删除会有遗漏,所以建议使用迭代器Iterator对集合进行动态删除操作。

    在next()方法中有一个checkForComodification()方法,其实现为:

        final void checkForComodification() 
        {
             if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

      可以看到,该函数是用来判断集合的修改次数是否合法。

      在集合内部维护一个字段modCount用于记录集合被修改的次数,每当集合内部结构发生变化(add,remove,set)时,modCount+1。

      在迭代器内部也维护一个字段expectedModCount,同样记录当前集合修改的次数,初始化为集合的modCount值。当我们在调用Iterator进行遍历操作时,如果有其他线程修改list会出现modCount!=expectedModCount的情况,就会报并发修改异常java.util.ConcurrentModificationException。

    而使用迭代器删除时在执行remove操作时,同样先执行checkForComodification(),然后会执行ArrayList的remove()方法,该方法会将modCount值加1,这里我们将expectedModCount=modCount,使之保持统一。



    有参考博客https://blog.csdn.net/u010911386/article/details/52711519


    展开全文
  • 引入增强for循环的原因:在JDK5以前的版本,遍历数组或集合的元素,需要先获得数组的长度或集合的迭代器,比较麻烦。 JDK5定义了一种新的语法—-增强for循环,以简化此类操作。增强for循环只能用在数组或实现...
  • for(int i:a) { System.out.print(i+" "); }输出:1 2 3 二维数组: import java.util.Scanner; public class tet { public static void main(String[] args) { //int[][] b={{1,2
  • 一、增强for循环的产生 1、jdk1.5之后collection接口继承了Iterable...增强for循环相当于把数组的值赋值给变量,并没有改变数组的值。因此无法操作容器里的值。上图在打印arr[0]时打印的还是3。 除此之外for对...
  • Java增强for循环

    2019-03-20 16:58:35
    java增强for循环格式: (增强for循环主要用于数组) for(声明语句 : 表达式) { //代码句子 } 声明语句:声明变量类型 表达式:表达式是要访问的数组名,或者是返回值为数组的方法。 实例: public class Test { ...
  • java中的for循环与jsfor循环,/*里面是js增强for循环
  • 在本篇文章里小编给大家整理是的关于Java中如何使用增强for循环的实例内容以及相关代码,需要的朋友们可以学习下。
  • java增强for循环

    2016-10-30 13:21:57
    增强for循环的格式:for(集合内储存类型 变量名:集合的变量名) 常用语遍历集合,数组和实现terable接口类都可以使用。 增强for循环的好处:1 写起来简单,2 遍历集合、容器简单 写一个小例子 增强for循环 ...
  • foreach 是 Java 的一种语法糖,几乎每一种语言都有一些这样的语法糖来方便程序员进行开发,编译期间以特定的字节码或特定的方式来对这些语法进行处理。能够提高性能,并减少代码出错的几率。
  • Java增强for循环

    2009-05-27 15:51:17
    Java增强for循环讲解Java增强for循环讲解
  • Java中增强for循环

    万次阅读 多人点赞 2018-07-27 00:52:14
    增强for循环定义如下: for(ElementType element: arrayName){}; 上述for循环可被读为:for each element in arrayName do {...} ------------------------------------------------------------------------...
  • JAVA增强for循环

    千次阅读 多人点赞 2020-12-09 22:31:09
    增强for循环 为什么需要增强for循环呢? 简化数组和集合的遍历。 想要使用增强for循环必须先要了解它的格式 增强for循环的格式 for(数据类型 变量名 : 数组或者集合对象){ //循环体,变量即元素 } 下边我们通过...
  • 增强型的for循环 和普通for循环一样 增强型的for循环 优点主要体现在集合,随便举个例子 比如对 set 的遍历 一般是迭代遍历
  • 下面小编就为大家带来一篇java增强for循环的实现方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • ``` Circlelist[] tempArr = new Circlelist[radix]; // for (Circlelist tempList : tempArr) { ...**为什么第一个增强for循环不能对tempArr数组的每个成员进行初始化,而第二个普通的for循环却可以**
  • Java 增强for循环原理

    千次阅读 2017-05-04 13:06:17
    [Java]增强for循环原理在Java语言循环遍历的方式有多种常见的有:for循环、增强for循环、while循环、do while循环、迭代器。最近在学习java Collection集合的原理,发现了集合中增强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&...
  • Java增强for循环

    2014-10-03 17:56:07
    1 增强for循环基本格式
  • Java-增强for循环(学习笔记)

    千次阅读 2017-09-27 10:43:38
    增强for循环:简化迭代器书写 一、增强for循环的简单实例 public class Demo{ public static void main(String[] args){ int arr[] = {1,2,3}; /** *增强for */ for(int num : arr){ System.out....
  • java增强fou循环(foreach) 是java5的新特征之一 foreach的循环对象一般是一个集合,List、ArrayList、LinkedList、Vector、数组等 格式: for(元素类型T 每次循环元素的名称O : 循环对象){  //对O进行操作 ...
  • Java中增强for循环

    2020-06-02 19:06:39
    高级for循环 格式为: 格式:for(数据类型 变量名 : 被遍历的集合(Collection)或者数组) { } 特点:对集合进行遍历。只能获取集合元素。但是不能对集合进行操作。 迭代器除了遍历,还可以进行remove集合元素...
  • Java_增强for循环

    千次阅读 2015-06-18 11:23:16
    增强for循环的介绍  JDK1.5增加了增强的for循环。  缺点:  对于数组,不能方便的访问下标值;  对于集合,与使用Interator相比,不能方便的删除集合的内容(在内部也是调用Interator).  
  • 普通for循环与增强for循环的差别: &amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;普通for循环:通过角标操作数组更加灵活,并可操作数组内元素。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 64,395
精华内容 25,758
关键字:

java中的增强for循环

java 订阅