List集合遍历for循环优化

比眉伴天荒 2022-09-10 16:08 319阅读 0赞

### List集合遍历for循环优化 ###

*  1. 遍历类型
 *  2. 实现验证

# 1. 遍历类型 #

* 方法一：最常规的不加思考的写法
         * 优点：较常见，易于理解
         * 缺点：每次都要计算list.size()
         
         * 方法二：数组长度提取出来
         * 优点：不必每次都计算
         * 缺点：m的作用域不够小，违反了最小作用域原则不能在for循环中操作list的大小，比如除去或新加一个元素
    
         * 方法三：数组长度提取出来
         * 优点：不必每次都计算 ，变量的作用域遵循最小范围原则
         * 缺点：m的作用域不够小，违反了最小作用域原则不能在for循环中操作list的大小，比如除去或新加一个元素
    
         * 方法四：采用倒序的写法
         * 优点：不必每次都计算 ，变量的作用域遵循最小范围原则
         * 缺点：1、结果的顺序会反 2、看起来不习惯，不易读懂
         * 适用场合：与显示结果顺序无关的地方：比如保存之前数据的校验
    
         * 方法五：迭代器Iterator 遍历
         * 优点：简洁
    
         * 方法六：jdk1.5后的写法,forEach
    
         * 方法七：循环嵌套外小内大原则
    
         * 方法八：循环嵌套提取不需要循环的逻辑
    
         * 方法九：异常处理写在循环外面
    
         * 方法十：流式
         * 有点：简洁

# 2. 实现验证 #

package com.zrj.unit.util;
    
    import org.junit.Before;
    import org.junit.Test;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    /** * For循环优化 * * @author zrj * @since 2021/9/9 **/
    public class ForCycle { 
        private List<String> list = new ArrayList<>( 3 );
    
        @Before
        public void init() { 
            list.add( "hello" );
            list.add( "world" );
        }
    
        @Test
        public void forCycle() { 
            /** * 方法一：最常规的不加思考的写法 * 优点：较常见，易于理解 * 缺点：每次都要计算list.size() */
            for (int i = 0; i < list.size(); i++) { 
                System.out.println( list.get( i ) );
            }
    
            /** * 方法二：数组长度提取出来 * 优点：不必每次都计算 * 缺点：m的作用域不够小，违反了最小作用域原则不能在for循环中操作list的大小，比如除去或新加一个元素 */
            int m = list.size();
            for (int i = 0; i < m; i++) { 
                System.out.println( list.get( i ) );
            }
    
            /** * 方法三：数组长度提取出来 * 优点：不必每次都计算 ，变量的作用域遵循最小范围原则 * 缺点：m的作用域不够小，违反了最小作用域原则不能在for循环中操作list的大小，比如除去或新加一个元素 */
            for (int i = 0, n = list.size(); i < n; i++) { 
                System.out.println( list.get( i ) );
            }
    
            /** * 方法四：采用倒序的写法 * 优点：不必每次都计算 ，变量的作用域遵循最小范围原则 * 缺点：1、结果的顺序会反 2、看起来不习惯，不易读懂 * 适用场合：与显示结果顺序无关的地方：比如保存之前数据的校验 */
            for (int i = list.size() - 1; i >= 0; i--) { 
                System.out.println( list.get( i ) );
            }
    
            /** * 方法五：迭代器Iterator 遍历 * 优点：简洁 */
            Iterator<String> iterator = list.iterator();
            while (iterator.hasNext()) { 
                System.out.println( iterator.next() );
            }
    
            for (Iterator<String> it = list.iterator(); it.hasNext(); ) { 
                System.out.println( it.next() );
            }
    
            /** * 方法六：jdk1.5后的写法,forEach */
            for (String str : list) { 
                System.out.println( str );
            }
    
            /** * 方法七：循环嵌套外小内大原则 */
            for (int i = 0; i < 10; i++) { 
                for (int j = 0; j < 10000; j++) { 
                }
            }
    
            /** * 方法八：循环嵌套提取不需要循环的逻辑 */
            //前：
            int a = 10, b = 11;
            for (int i = 0; i < 10; i++) { 
                i = i * a * b;
            }
            //后：
            int c = a * b;
            for (int i = 0; i < 10; i++) { 
                i = i * c;
            }
    
            /** * 方法九：异常处理写在循环外面 */
            try { 
                for (int i = 0; i < 10; i++) { 
                }
            } catch (Exception e) { 
    
            }
    
            /** * 方法十：流式 * 有点：简洁 */
            list.forEach( s -> System.out.println( s ) );
        }
    
    }