精华内容
下载资源
问答
  • Java List集合 遍历 四种方式(包含 Lambda 表达式遍历) package com.miracle.luna.lambda; import java.util.ArrayList; import java.util.List; /** * @Author Miracle Luna * @Date 2019/6/9 23:36 * @...

    Java List集合 遍历 四种方式(包含 Lambda 表达式遍历)

    package com.miracle.luna.lambda;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @Author Miracle Luna
     * @Date 2019/6/9 23:36
     * @Version 1.0
     */
    public class ListLambda {
        public static void main(String[] args) {
            List<String> items = new ArrayList<>();
    
            items.add("A");
            items.add("B");
            items.add("C");
    
            // 普通for循环遍历
            System.out.println("第一种遍历方式:普通for循环遍历 List 集合");
            for (int i = 0; i < items.size(); i++) {
                System.out.println(items.get(i));
            }
    
            // 增强for循环遍历
            System.out.println("\n第二种遍历方式:增强for循环遍历 List 集合");
            for (String item : items) {
                System.out.println(item);
            }
    
            // Lambda 表达式遍历(JDK 1.8)
            System.out.println("\n第三种遍历方式:Lambda 表达式遍历 List 集合");
            items.forEach(item->{
                System.out.println(item);
            });
    
            // Lambda 表达式遍历(JDK 1.8)
            System.out.println("\n第四种遍历方式:Lambda 表达式遍历 List 集合");
            items.forEach(System.out::println);
    
    
            // 普通for循环遍历,判断List集合中是否包含字符串“C”
            System.out.println("\n第一种判断方式:普通for循环遍历,判断List集合中是否包含字符串“C”");
            for (int i = 0; i < items.size(); i++) {
                if ("C".equals(items.get(i))){
                    System.out.println(items.get(i));
                }
            }
    
            // 增强for循环遍历,判断List集合中是否包含字符串“C”
            System.out.println("\n第二种判断方式:增强for循环遍历,判断List集合中是否包含字符串“C”");
            for (String item : items) {
                if ("C".equals(item)){
                    System.out.println(item);
                }
            }
    
            // Lambda 表达式 判断List集合中是否包含字符串“C”(JDK 1.8)
            System.out.println("\n第三种判断方式:Lambda 表达式,判断List集合中是否包含字符串“C”");
            items.forEach(item->{
                if ("C".equals(item)){
                    System.out.println(item);
                }
            });
    
            // Lambda 表达式 判断List集合中是否包含字符串“C”(JDK 1.8)
            System.out.println("\n第四种判断方式:Lambda 表达式,判断List集合中是否包含字符串“C”");
            items.stream().filter(s->s.equals("C")).forEach(System.out::println);
        }
    }
    

    运行结果如下:

    第一种遍历方式:普通for循环遍历 List 集合
    A
    B
    C
    第二种遍历方式:增强for循环遍历 List 集合
    A
    B
    C
    
    第三种遍历方式:Lambda 表达式遍历 List 集合
    A
    B
    C
    
    第四种遍历方式:Lambda 表达式遍历 List 集合
    A
    B
    C
    
    第一种判断方式:普通for循环遍历,判断List集合中是否包含字符串“CC
    
    第二种判断方式:增强for循环遍历,判断List集合中是否包含字符串“CC
    
    第三种判断方式:Lambda 表达式,判断List集合中是否包含字符串“CC
    
    第四种判断方式:Lambda 表达式,判断List集合中是否包含字符串“CC
    
    展开全文
  • java.lang中有一个Iterable接口提供了一个forEach的默认方法,是Collection 接口的父接口,因此Collection也可以使用这个方法,所需要一个函数式接口的传入,遍历Collection 集合。 示例: public class dome2{ ...

    在java.lang中有一个Iterable接口提供了一个forEach的默认方法,是Collection 接口的父接口,因此Collection也可以使用这个方法,所需要一个函数式接口的传入,遍历Collection 集合。

    示例:

    public class dome2{
    	public static void main(String[] args){
    	 List<String> list=new ArrayList<>();
    	 list.add("java");
    	 list.add("python");
    	 list.add("c++");
    	 list.add("java");
    	 list.add("html");
    	 list.add("c语言");
    	
          list.forEach(o -> System.out.println(o));
       }
    }
    

    结果
    java
    python
    c++
    java
    html
    c语言

    展开全文
  • for循环遍历Lambda表达式遍历 */ public class List2Lambda { public static void main(String[] args) { List items = new ArrayList<>(); items.add("Apple"); items.add("Pear"); items.ad

    package com.config;

    import java.util.ArrayList;
    import java.util.List;

    /**

    • for循环遍历之Lambda表达式遍历
      */
      public class List2Lambda {
      public static void main(String[] args) {
      List items = new ArrayList<>();

       items.add("Apple");
       items.add("Pear");
       items.add("Carambola");
      
       // 普通for循环遍历
       System.out.println("1:普通for循环遍历");
       for (int i = 0; i < items.size(); i++) {
           System.out.println(items.get(i));
       }
      
       // 增强for循环遍历
       System.out.println("\n2:增强for循环遍历");
       for (String item : items) {
           System.out.println(item);
       }
      
       // Lambda 表达式遍历(JDK 1.8)
       System.out.println("\n3:Lambda表达式遍历");
       items.forEach(item->{
           System.out.println(item);
       });
      
       // Lambda 表达式遍历(JDK 1.8)
       System.out.println("\n4:Lambda 表达式遍历");
       items.forEach(System.out::println);
      
      
       // 普通for循环遍历,判断List集合中是否包含字符串“C”
       System.out.println("\n1:普通for循环遍历,判断List集合中是否包含字符串Apple");
       for (int i = 0; i < items.size(); i++) {
           if (items.get(i).equals("Apple")){
               System.out.println(items.get(i));
           }
       }
      
       // 增强for循环遍历,判断List集合中是否包含字符串“C”
       System.out.println("\n2:增强for循环遍历,判断List集合中是否包含字符串Apple");
       for (String item : items) {
          if(item.equals("Apple")){
              System.out.println(item);
          }
      
       }
      
       // Lambda 表达式 判断List集合中是否包含字符串“C”(JDK 1.8)
       System.out.println("\n3:Lambda 表达式,判断List集合中是否包含字符串Apple");
       items.forEach(item->{
           if(item.equals("Apple")){
               System.out.println(item);
           }
       });
      
       // Lambda 表达式 判断List集合中是否包含字符串“C”(JDK 1.8)
       System.out.println("\n4:Lambda 表达式,判断List集合中是否包含字符串Apple");
       items.stream().filter(s->s.equals("Apple")).forEach(System.out::println);
      

      }
      }

    执行效果:

    1:普通for循环遍历
    Apple
    Pear
    Carambola

    2:增强for循环遍历
    Apple
    Pear
    Carambola

    3:Lambda表达式遍历
    Apple
    Pear
    Carambola

    4:Lambda 表达式遍历
    Apple
    Pear
    Carambola

    1:普通for循环遍历,判断List集合中是否包含字符串Apple
    Apple

    2:增强for循环遍历,判断List集合中是否包含字符串Apple
    Apple

    3:Lambda 表达式,判断List集合中是否包含字符串Apple
    Apple

    4:Lambda 表达式,判断List集合中是否包含字符串Apple
    Apple

    展开全文
  • java lambda表达式 遍历操作集合

    千次阅读 2014-10-22 20:27:30
    jdk 8 添加了lambda表达式这个特性,

    经常需要遍历集合中的元素,做一些操作

    假设有这样一个需求: 分别输出字符集合里对应字符,

    public void print(List<Character> list){
    		for(Character c : list){
    			System.out.println(c);
    		}
    	}

    需求变了: 输出字符集合里对应字符的的大写
    <pre name="code" class="java">public void printUpper(List<Character> list){
    		for(Character c : list){
    			System.out.println((char)(c - 32));
    		}
    	}


     还可能有很多其他操作,遍历是不变的,变化的是操作部分。可以把这些不变的部分写成模板,通过提供回调接口来分离变化的操作,比如:
    
    public interface Action<T> {
    	public void action(T t);
    }
    那么上面的需求的实现可以写成:

    	public void genericPrint(List<Character> list, Action<Character> action){
    		for(Character c : list){
    			action.action(c);
    		}
    	}

    在具体调用的时候,只需要提供具体的实现就可以。比如输出大写的那个的需求 : 

    genericPrint(list, new Action<Character>() {
    			@Override
    			public void action(Character c) {
    				System.out.println((char)(c - 32));
    			}
    		});

    jdk8 提供了对lambda表达式的支持,lambda表达式使得抽象函数行为有了更加方便的方法。

    上面的例子在jdk8 中,可以简化为:

    genericPrint(list, c -> System.out.println((char)(c - 32)));

    这样更加符合逻辑,因为我们需要抽象的只是不同的函数行为。 在上面的例子中 c 为action方法的入参, system......为方法体,编译器做了类型推断,如果写全了应该为:

    genericPrint(list, (Character c) -> {System.out.println((char)(c - 32));}); 

    并且在jdk8的List中新增了forEach方法(由接口Iterable提供),所以在遍历list操作的时候,可以直接:

    list.forEach(c ->System.out.println((char)(c - 32)));

    抽象函数行为在很多地方都有见到,比如创建线程,区别就在线程的行为,即run()方法上。现在创建线程可以:

    new Thread(() -> {doSomething;});


    by the way : lambda表达式不是java语言独创(也不是c#),在函数式语言中lambda表达式是司空见惯的,并且使用的更加优雅与自然, 比如高阶函数。

    以erlang为例:对于上面输出大写字符的需求:

    lists:foreach(fun(C) ->io:format("~c",[C-32]) end, List).
    











    展开全文
  • Java8的lambda表达式遍历集合

    万次阅读 2018-12-18 16:31:41
    Java8 lambda 表达式遍历集合 遍历List 示例 List&lt;Strudent&gt; list = new ArrayList&lt;Strudent&gt;() {{ add(new Strudent("b", 11, "女")); add(new Strudent("...
  • 遍历list提取值,放到新的list List<Object> list = new ArrayList(); ... list.add(); //写法1: List<String> aa = new ArrayList<>(); permissions.forEach((p -> aa.add(p.getKey())));...
  • package com.miracle.luna.lambda; import java.util.HashMap; import java.util.Iterator; import java.util.Map; /** * @author Miracle Luna * @version 1.0 * @date 2019/6/9 21:41 ...
  • 示例代码如下: package ...import java.util.Arrays; /** * @Author Miracle Luna * @Date 2019/6/9 23:33 * @Version 1.0 */ public class ArrayLambda { public static vo...
  • package springboot.activiti.demo.utils; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.patch; import java.util.ArrayList;...import java.util....import java....
  • Lambda表达式遍历List

    千次阅读 2018-12-20 15:05:31
    Lambda表达式 Lambda表达式,也可称为闭包,它是推动Java8发布的最重要的新特新。 Lambda允许把函数作为一个方法的参数。使用Lambda可以使代码变得更加简洁紧凑。...遍历List public class Test01 ...
  • java8 forEach结合Lambda表达式遍历 List

    千次阅读 2020-08-13 20:31:01
    //java8 foreach + 拉姆达表达式遍历Map items.forEach((k, v) -> { System.out.println(k+":"+v); }); } @Test void testJava8ForeachList() { List items = new ArrayList(); items.add("A"); items.add("B"); ...
  • Having an Optional List of Optional's like:Optional>> optionalList = Optional.of(Arrays.asList(Optional.empty(),Optional.of("ONE"),Optional.of("TWO")));How to traverse optionalList to print out ...
  • 使用forEach函数进行遍历 List集合中元素为对象<User>类型 Map集合中元素为<String,Student>类型 这个元素类型就可以根据自己的需要去设定了 需求:想要将两个集合中的元素合并到同一个集合中,并且两个...
  • Java8 Lambda遍历集合

    2018-09-22 13:46:57
    Java8支持使用Lambda语法对集合进行遍历,语法如下 更多精彩 更多技术博客,请移步 asing1elife’s blog List allQuestions.forEach(question -&gt; { if (question.getType().getCode().equals(typeCode)) ...
  • Java8新特性之forEach+Lambda 表达式遍历Map和List

    万次阅读 多人点赞 2017-04-20 12:18:32
    这是Java8系列的第二篇,今天来说一下Java8中forEach的简单使用。...一、遍历Map============Java8之前的方式========== Map, Integer> items = new HashMap(); items.put("A", 10); items.put("B", 20); items.pu
  • Lambda表达式遍历List集合

    千次阅读 2019-08-21 19:58:22
    import java.util....import java.util.List; public class Lambda { public static void main(String[] args) { List list = new ArrayList<>(); list.add(“zhagnsan”); list.add(“wangwu”); list.ad...
  • java8 lambda 遍历集合

    2018-03-29 15:15:29
    java 8 为 Iterable 增加了forEach(Consumer&lt;? super T&gt; action)方法需要传入对的参数是个函数式接口collction 继承自IterableList&lt;String&gt; collection = new ArrayList&lt;&...
  • 我们使用对比的方式来看应该会看得更加清楚,更能理解:一、遍历Map============Java8之前的方式==========Map items = new HashMap<>();items.put("A", 10);items.put("B", 20);items.put("C", 30);items...
  • Java8 lambda遍历出来后有人说它快有人说它要慎用?到底怎么回事让我们来一探究竟吧!看不懂可以先看后面的分析 测试代码: package cn.cncommdata.zhonglvreport; import java.util.ArrayList; import java.util.....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,593
精华内容 8,237
热门标签
关键字:

javalambdalist遍历

java 订阅