精华内容
下载资源
问答
  • 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的冒号左边是定义变量,右边必须是数组或集合类型。例如上例中循环遍历的主浊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循环,一定要优先使用。

    更多相关内容
  • 下面小编就为大家带来一篇java增强for循环的实现方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 增强的for循环是在传统的for循环中增加的强大的迭代功能的循环,是在jdk1.5之后提出来的。下面这篇文章主要给大家介绍了关于Java中增强for循环的实现原理和坑的相关资料,需要的朋友可以参考下
  • 下面小编就为大家带来一篇老生常谈foreach(增强for循环)和for的区别。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • foreach 是 Java 中的一种语法糖,几乎每一种语言都有一些这样的语法糖来方便程序员进行开发,编译期间以特定的字节码或特定的方式来对这些语法进行处理。能够提高性能,并减少代码出错的几率。
  • 主要介绍了详解Java中list,set,map的遍历与增强for循环的相关资料,需要的朋友可以参考下
  • 下面小编就为大家带来一篇Java中增强for循环在一维数组和二维数组中的使用方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • NULL 博文链接:https://rensanning.iteye.com/blog/2003205
  • 增强for循环

    千次阅读 2021-05-23 20:21:23
    增强for循环一、什么是增强for循环?二、使用步骤1.引入库2.读入数据总结 一、什么是增强for循环增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环,专门用来遍历数组和集合。其内部原理是一个...

    一、什么是增强for循环?

      增强for循环 (也称for each循环) 是迭代器遍历方法的一个“简化版”,是JDK1.5以后出来的一个高级for循环,专门用来遍历数组集合

      其内部原理是一个Iteration迭代器,在遍历数组/集合的过程中,不能对集合中的元素进行增删操作。

    二、增强for循环的使用

      1.使用范围:用来遍历集合和数组(必须有遍历目标,目标只能是集合或者数组),所有单列表集合都可以使用增强for循环。
      2.格式如下:

    for(ElementType element: arrayName) 
    { //集合或数组的数据类型 变量名:集合名/数组名
    	System.out.println(变量名)};
    

    上述for循环可被读为:
    for each element in arrayName do {…}

    例如:
    ①使用普通for循环

        int[] num = {1,2,3,4,5,6};
        for(int i =  0 ; i<num.length ; i++){ 
            System.out.println("元素:"+ num[i]); 
        } 
    

    ②使用增强for循环

    	 int[] num = {1,2,3,4,5,6};
         for(int i :num){   //集合或数组a : 数组名称num
             System.out.println("元素:"+ i); 
         } 
    

    三、使用时要注意的事项

    1.增强for循环底层也是使用了迭代器获取的,在使用增强for循环遍历元素的过程中不准使用集合对象对集合的元素个数进行修改

    2.迭代器与增强for循环遍历元素的区别:使用增强for循环遍历集合的元素时,不能调用迭代器的remove方法删除元素而使用迭代器遍历集合的元素时可以删除集合的元素。

    3.增强for循环和普通for循环的区别:普通for循环可以没有遍历的目标,而增强for循环一定要有遍历的目标

    总结

    相对于普通for循环(;;)而言 增强for循环有两个好处:

    1.写起来简单容易

    2.遍历集合、数组比较简单

    展开全文
  • 在本篇文章里小编给大家整理是的关于Java中如何使用增强for循环的实例内容以及相关代码,需要的朋友们可以学习下。
  • 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。

    展开全文
  • 迭代器和增强for循环

    千次阅读 2021-03-18 08:12:39
    增强for循环的缺点:增强for循环和iterator遍历的效果是一样的,也就说增强for循环的内部也就是调用iteratoer实现的,但是增强for循环有些缺点,例如不能在增强循环里动态的删除集合内容、不能获取下标等。 增强for...

    Iterator迭代器的使用:

    迭代:Iterator,即collection集合元素的通用获取方式

    java.util.Iterator接口。迭代器(对集合进行遍历)

    有两个常用的方法

    Boolean hasNext()如果仍有元素可以迭代,则返回true

    判断集合中还有没有下一个元素,有就返回true,没有就返回false

    E next()返回迭代的下一个元素

    取出集合中的下一个元素

    Iterator迭代器,是一个接口,我们无法直接使用,需要Iterator接口的实现类对象,获取实现类的方式比较特殊

    Collection接口中有一个方法,叫Iterator(),这个方法返回的就是迭代器的实现类对象

    Iterator iterator()返回在此collection的元素上进行迭代的迭代器

    迭代器的使用步骤(重点)

    1、使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)

    2、使用Iterator接口中的方法hasNext判断还有没有下一个元素

    3、使用Iterator接口中的方法next取出集合中的下一个元素

    package Iterator;

    import java.util.ArrayList;

    import java.util.Collection;

    import java.util.Iterator;

    public class Demo01Collection {

    public static void main(String[] args) {

    //创建一个集合对象

    Collection coll=new ArrayList<>();

    coll.add("星星");

    coll.add("仰望星空");

    coll.add("最美的太阳");

    coll.add("这就是爱");

    //1、使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)

    //Iterator的接口也是有泛型的,迭代器的泛型跟着集合走,集合是什么泛型,迭代器就是什么泛型

    //多态 接口 实现类对象

    Iterator it=coll.iterator();

    //发现使用迭代器取出集合中元素的代码是一个重复的过程

    //所以我们可以使用循环优化

    //不知道集合中有多少元素,使用while集合

    //循环结束的条件,hasNext方法返回false

    while (it.hasNext()){

    String e=it.next();

    System.out.println(e);

    }

    // //2、使用Iterator接口中的方法hasNext判断还有没有下一个元素

    // boolean b=it.hasNext();

    // System.out.println(b);//true

    //

    // // 3、使用Iterator接口中的方法next取出集合中的下一个元素

    // String s=it.next();

    // System.out.println(s);

    //

    // //2、使用Iterator接口中的方法hasNext判断还有没有下一个元素

    // b=it.hasNext();

    // System.out.println(b);//true

    // // 3、使用Iterator接口中的方法next取出集合中的下一个元素

    // s=it.next();

    // System.out.println(s);

    // 2、使用Iterator接口中的方法hasNext判断还有没有下一个元素

    // b=it.hasNext();

    // System.out.println(b);//true

    // // 3、使用Iterator接口中的方法next取出集合中的下一个元素

    // s=it.next();

    // System.out.println(s);

    // 2、使用Iterator接口中的方法hasNext判断还有没有下一个元素

    // b=it.hasNext();

    // System.out.println(b);//true

    // // 3、使用Iterator接口中的方法next取出集合中的下一个元素

    // s=it.next();

    // System.out.println(s);

    //

    // b=it.hasNext();

    System.out.println(b);没有元素,返回false

    // 3、使用Iterator接口中的方法next取出集合中的下一个元素

    s=it.next();没有元素,在取出元素会抛出NoSuchElementException没有元素异常

    System.out.println(s);

    }

    }

    Iterator(迭代器)实现原理

    这里我们来看看Java里AbstractList实现Iterator的源代码:

    public abstract class AbstractList extends AbstractCollection implements List { // List接口实现了Collection, Iterable

    protected AbstractList() {

    }

    public Iterator iterator() {

    return new Itr(); // 这里返回一个迭代器 }

    private class Itr implements Iterator { // 内部类Itr实现迭代器

    int cursor = 0;

    int lastRet = -1;

    int expectedModCount = modCount;

    public boolean hasNext() { // 实现hasNext方法

    return cursor != size();

    }

    public E next() { // 实现next方法

    checkForComodification();

    try {

    E next = get(cursor);

    lastRet = cursor++;

    return next;

    } catch (IndexOutOfBoundsException e) {

    checkForComodification();

    throw new NoSuchElementException();

    }

    }

    public void remove() { // 实现remove方法

    if (lastRet == -1)

    throw new IllegalStateException();

    checkForComodification();

    try {

    AbstractList.this.remove(lastRet);

    if (lastRet < cursor)

    cursor--;

    lastRet = -1;

    expectedModCount = modCount;

    } catch (IndexOutOfBoundsException e) {

    throw new ConcurrentModificationException();

    }

    }

    final void checkForComodification() {

    if (modCount != expectedModCount)

    throw new ConcurrentModificationException();

    }

    }

    }

    可以看到,实现next()是通过get(cursor),然后cursor++,通过这样实现遍历。

    这部分代码不难看懂,唯一难懂的是remove操作里涉及到的expectedModCount = modCount;

    在网上查到说这是集合迭代中的一种“快速失败”机制,这种机制提供迭代过程中集合的安全性。

    从源代码里可以看到增删操作都会使modCount++,通过和expectedModCount的对比,迭代器可以快速的知道迭代过程中是否存在list.add()类似的操作,存在的话快速失败!

    在第一个例子基础上添加一条语句:

    import java.util.*;

    public class Muster {

    public static void main(String[] args) {

    ArrayList list = new ArrayList();

    list.add("a");

    list.add("b");

    list.add("c");

    Iterator it = list.iterator();

    while(it.hasNext()){

    String str = (String) it.next();

    System.out.println(str);

    list.add("s"); //添加一个add方法

    }

    }

    }

    运行结果:

    a

    Exception in thread "main" java.util.ConcurrentModificationException

    at java.util.ArrayList$Itr.checkForComodification(Unknown Source)

    at java.util.ArrayList$Itr.next(Unknown Source)

    at com.hasse.Muster.main(Muster.java:11)

    这就会抛出一个下面的异常,迭代终止。

    增强for循环

    增强for循环的作用: 简化迭代器的书写格式。(注意:增强for循环的底层还是使用了迭代器遍历。)

    增强for循环的适用范围: 如果是实现了Iterable接口的对象或者是数组对象都可以使用增强for循环。

    增强for循环的缺点:增强for循环和iterator遍历的效果是一样的,也就说增强for循环的内部也就是调用iteratoer实现的,但是增强for循环有些缺点,例如不能在增强循环里动态的删除集合内容、不能获取下标等。

    增强for循环的格式:

    for(数据类型 变量名 :遍历的目标){

    //数据类型 变量名:声明一个变量用来接收遍历目标遍历后的元素

    }

    增强for循环要注意的事项:

    增强for循环底层也是使用了迭代器获取的,只不过获取迭代器由jvm完成,不需要我们获取迭代器而已,所以在使用增强for循环变量元素的过程中不准使用集合对象对集合的元素个数进行修改。

    迭代器遍历元素与增强for循环变量元素的区别:使用迭代器遍历集合的元素时可以删除集合的元素,而增强for循环变量集合的元素时,不能调用迭代器的remove方法删 除 元素。

    普通for循环与增强for循环的区别:普通for循环可以没有遍历的目标,而增强for循环一定要有遍历的目标。

    int[] arr = {5,11,2,4,9,18};

    普通for循环的遍历方式

    for(int i = 0 ; i

    System.out.println("元素:"+ arr[i]);

    }

    //使用增强for循环实现

    for(int item :arr){

    System.out.println("元素:"+ item);

    }

    HashSet set = new HashSet();

    //添加元素

    set.add("张狗蛋");

    set.add("张全蛋");

    set.add("张傻蛋");

    //使用迭代器遍历Set的集合.

    Iterator it = set.iterator();

    while(it.hasNext()){

    String temp = it.next();

    System.out.println("元素:"+ temp);

    it.remove();

    }

    //使用增强for循环解决

    for(String item : set){

    System.out.println("元素:"+ item);

    }

    注意: Map集合没有实现Iterable接口,所以map集合不能直接使用增强for循环,如果需要使用增强for循环需要借助于Collection的集合。

    HashMap map = new HashMap();

    map.put("01","甲");

    map.put("02","乙");

    map.put("03","丙");

    map.put("04","丁");

    Set> entrys = map.entrySet();

    for(Map.Entry entry :entrys){

    System.out.println("键:"+ entry.getKey()+" 值:"+ entry.getValue());

    }

    展开全文
  • 增强型的for循环 和普通for循环一样 增强型的for循环 优点主要体现在集合中,随便举个例子 比如对 set 的遍历 一般是迭代遍历
  • for循环与增强for循环的区别与使用

    千次阅读 2021-01-15 23:36:47
    for循环分为两种:一种为普通for循环,一种为增强for循环(也就是foreach循环) 区别: 1)任何循环都能用普通for循环运行,但不一定能用增强for循环,也就是增强for循环的使用范围要小。 2)增强for循环内部其实是...
  • 一、增强for循环 1. 三种常用for循环 // 普通for循环遍历 for (int i = 0; i < list.size(); i++) { System.out.print(list.get(i) + ","); } // 迭代器循环遍历 Iterator iterator = list.iterator(); while...
  • for循环之增强for循环

    2020-11-05 17:46:36
    增强for循环,属于for循环的一种用法,不同的是增强型for只能用来取值,却不能用来修改数组里面的值 //对数组进行遍历 int a[] = new int[]{1,2,3,4,5}; //常规for循环遍历 for int(i = 0; i < a.length; i++) ...
  • 首先说一下foreach有的也叫增强for循环,foreach其实是for循环的一个特殊简化版。再说一下foreach的书写格式:for(元素类型 元素名称 : 遍历数组(集合)(或者能进行迭代的)){语句}foreach虽然是for循环的简化版本,...
  • C++增强for循环

    千次阅读 多人点赞 2020-05-17 19:07:58
    for循环是常见的代码语句,常规的for循环如下 #include <iostream> using namespace std; int main() { int array[] = { 1,1,2,3,5,8 }; //常规for循环 for (int i = 0; i < sizeof(array) / ...
  • java中的增强for循环

    2022-02-12 16:14:21
    /*增强for循环 * 语法格式: * for(元素类型 变量名: 数组或集合) { * System.out.println(变量名); * } * 缺点:没有下标,在需要使用下标的循环中不建议使用*/ public class ForEachTest01 { public static void ...
  • Java实用技巧---增强for循环

    千次阅读 2022-02-13 09:45:53
    1、泛型接口 把泛型定义在接口上 格式:public interface 接口名<泛型类型1…>...2、增强for循环概述:简化数组和Collection集合的遍历 语句定义格式: for(元素数据类型 变量名(自定义)..
  • 曾经没怎么多想过for each有什么特殊的地方,以为就是for循环的简便写法,直到今天写力扣发现了不对劲,使用for each就是过不了,而用正规for循环就过了,决定来好好了解一下for each。 最后发现,是否能理解for ...
  • IDEA生成增强for循环

    千次阅读 2021-12-13 09:47:15
    IDEA生成增强for循环 - 悦文 - 博客园
  • JAVA增强for循环

    千次阅读 多人点赞 2020-12-09 22:31:09
    增强for循环 为什么需要增强for循环呢? 简化数组和集合的遍历。 想要使用增强for循环必须先要了解它的格式 增强for循环的格式 for(数据类型 变量名 : 数组或者集合对象){ //循环体,变量即元素 } 下边我们通过...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 123,972
精华内容 49,588
关键字:

增强for循环

友情链接: 特效.zip