精华内容
下载资源
问答
  • 使用forEach函数进行遍历 List集合中元素为对象<User>类型 Map集合中元素为<String,Student>类型 这个元素类型就可以根据自己的需要去设定了 需求:想要将两个集合中的元素合并到同一个集合中,并且两个...

    使用forEach函数进行遍历

    List集合中元素为对象<User>类型
    Map集合中元素为<String,Student>类型

    这个元素类型就可以根据自己的需要去设定了

    需求:想要将两个集合中的元素合并到同一个集合中,并且两个集合中的元素是不相同的 结果的集合类型可自行选择

    	@Test
        public void test() {
    
            List<User> userList = new ArrayList<>();
            User user1 = new User();
            user1.setUserId("111111");
            user1.setUserName("张三");
            User user2 = new User();
            user2.setUserId("222222");
            user2.setUserName("李四");
            userList.add(user1);
            userList.add(user2);
            
    		//元素类型可根据自己需要判定
            Map<String, Student> studentMap = new HashMap<>();
            Student student1 = new Student();
            student1.setStudentId("333333");
            student1.setStudentName("学生1");
            Student student2 = new Student();
            student2.setStudentId("444444");
            student2.setStudentName("学生2");
            studentMap.put(student1.getStudentId(), student1);
            studentMap.put(student2.getStudentId(), student2);
    
            //最终结果定义为User类型  也可根据需要替换成Student类型 只需要在后面add时 替换即可
            List<User> users = new ArrayList<>();
    
            //for循环方式
    //        for (User user : userList) {
    //            User u = new User(user.getUserId(), user.getUserName());
    //            users.add(u);
    //        }
    //        for (String studentId : studentMap.keySet()) {
    //            //将student类型 替换成 user类型
    //            User user = new User(studentId, studentMap.get(studentId).getStudentName());
    //            users.add(user);
    //        }
            //lambda方式
            userList.forEach(user -> users.add(new User(user.getUserId(), user.getUserName())));
            studentMap.forEach((key, value) -> users.add(new User(key, value.getStudentName())));
            System.out.println("users: " + users);
    }
    

    结果:
    在这里插入图片描述

    展开全文
  • 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).
    











    展开全文
  • 本节重点思维导图 集合框架 ...有序无序:元素放入的顺序与取出的顺序是否一致,一致即...ArrayList:长度可变的数组,遍历速度快 LinkedList:链表:添加删除节点速度快 import java.util.ArrayList; i...

    本节重点思维导图

    集合框架

     

     

     

     

     

     

     

     

     

     

    有序无序:元素放入的顺序与取出的顺序是否一致,一致即为有序,不一致即无序。

     

    • List:允许重复、有序
    • ArrayList:长度可变的数组,遍历速度快
    • LinkedList:链表:添加删除节点速度快
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    
    public class Demo {
        public static void main(String[] args) {
            List list = new ArrayList();
            System.out.println("--------"+list.toString());//add
            list.add("aa");
            list.add(1234);
            list.add(true);
            list.add(new Date());
            list.add(1234);
            list.add(3.14);
    
            System.out.println(list.get(0) + "   --     " + list.get(3));
            System.out.println(list.size());
    
            System.out.println(list);
            System.out.println(list.toString());
    
            for (Object obj : list) {
                System.out.println(obj);
            }
    
            list.remove(0);// 根据下标移除
    
            list.clear();
            System.out.println(list.size());
        }
    
    }

    结果:

    --------[]
    aa   --     Fri May 31 15:07:45 CST 2019
    6
    [aa, 1234, true, Fri May 31 15:07:45 CST 2019, 1234, 3.14]
    [aa, 1234, true, Fri May 31 15:07:45 CST 2019, 1234, 3.14]
    aa
    1234
    true
    Fri May 31 15:07:45 CST 2019
    1234
    3.14
    0

     

     

     泛型

    import java.util.ArrayList;
    import java.util.Date;
    import java.util.Iterator;
    import java.util.List;
    
    public class Demo {
        public static void main(String[] args) {
                            List<String> list = new ArrayList<>();  
                            list.add("1234");  
                            list.add("true");  
                            list.add("aaaa");  
                            list.add("aaaa");  
                            list.add("bbbb");  
                            list.add("dddd");  
                      
                            String e3 = list.get(3);  
                            System.out.println(e3);  
                            System.out.println(list.get(3));
                            int size = list.size();  
                            System.out.println(size);  
                      
                            for (String item : list) {  
                                System.out.println(item);  
                            }  
                      
                            System.out.println("--------------------------");  
                            // Iterator迭代器  
                            Iterator<String> iterator = list.iterator();  
                            while (iterator.hasNext()) {// 判断是否还有下一个元素,有的话返回true  
                                String next = iterator.next();// 取出元素,同时将指针指向当前位置  
                                System.out.println(next);  
                            }  
                        }
    } 

    结果:

    aaaa
    aaaa
    6
    1234
    true
    aaaa
    aaaa
    bbbb
    dddd
    --------------------------
    1234
    true
    aaaa
    aaaa
    bbbb
    dddd

     

     

     

    list\Lambda\set\map

     *lambda

    public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("zhangsan");
            list.add("lisi");
            list.add("zhangsan");
            list.add("wanger");
            list.add("mazi");
            list.add("wanger");
    
            list.stream().forEach(element->System.out.println(element));
            System.out.println();
            list.forEach(item -> System.out.println(item));
            System.out.println();
            list.forEach(System.out::println);
            
            //将List中所有的元素变成大写字母后再逆序输出
            System.out.println();
            for(int i =list.size()-1;i>=0;i--) {
                String item = list.get(i);
                item = item.toUpperCase();
                System.out.println(item);
            }
            System.out.println();
            list.stream().map(item->item.toUpperCase())//映射:依次拿出List中的每一个元素进行映射
                .forEach(System.out::println);
            
            //输出List中每一个元素的前两个字符
            System.out.println();
            list.stream().map(item->item.substring(0, 2))
                .forEach(System.out::println);
            
            //只输出List中长度大于4的元素
            System.out.println();
            list.stream().filter(item->item.length()>4)
                .forEach(System.out::println);
            
            //去除重复
            System.out.println();
            list.stream().distinct().forEach(System.out::println);
            
            //将Stream转换成List
            System.out.println();
            List<String> collect = list.stream().collect(Collectors.toList());
            System.out.println(collect);
        }

    *set

    public static void main(String[] args) {
            Set<String> set  = new HashSet<>();
            set.add("zhangsan");
            set.add("lis");
            set.add("zhangsan");
            set.add("wanger");
            set.add("mazi");
            set.add("wanger");
            
            for(String item : set) {
                System.out.println(item);
            }
            
            System.out.println();
            Iterator<String> iterator = set.iterator();
            while(iterator.hasNext()) {
                System.out.println(iterator.next());
            }
            
            System.out.println();
            set.forEach(System.out::println);
        }

    示例:学习set判断元素是否相等

    public class Dept {
        private int deptno;
        private String dname;
        private String loc;
    
        public Dept() {
            super();
        }
    
        public Dept(int deptno, String dname, String loc) {
            super();
            this.deptno = deptno;
            this.dname = dname;
            this.loc = loc;
        }
    
        public int getDeptno() {
            return deptno;
        }
        public void setDeptno(int deptno) {
            this.deptno = deptno;
        }
    
        public String getDname() {
            return dname;
        }
    
        public void setDname(String dname) {
            this.dname = dname;
        }
    
        public String getLoc() {
            return loc;
        }
    
        public void setLoc(String loc) {
            this.loc = loc;
        }
    
        @Override
        public int hashCode() {
            return 234;
        }
    
        @Override
        public boolean equals(Object obj) {
            return true;
        }
    
        @Override
        public String toString() {
            return "Dept [deptno=" + deptno + ", dname=" + dname + ", loc=" + loc + "]";
        }
    }
    
    
        public static void main(String[] args) {
            Set<Dept> set = new HashSet<>();
        
            set.add(new Dept());
            set.add(new Dept());
            set.add(new Dept(10,"sales","new york"));
            set.add(new Dept(20,"research","chicago"));
            
            System.out.println(set.size());
            
            set.forEach(System.out::println);
        }

    *map

    键值对

    public static void main(String[] args) {
            Map<String, Integer> data = new HashMap<>();
            data.put("a", 1);
            data.put("b", 2);
            data.put("c", 3);
            data.put("d", 4);
            
            System.out.println(data.get("a"));
            
            Set<String> keySet = data.keySet();
            keySet.forEach(System.out::println);
            
            Collection<Integer> values = data.values();
            values.forEach(item->System.out.print(item+" "));
            
            System.out.println();
            Set<Entry<String, Integer>> entrySet = data.entrySet();
            for(Entry<String, Integer> item: entrySet) {
                System.out.println(item.getKey()+" "+item.getValue());
            }
            
            
            data.forEach((k,v)->System.out.println(k+" : "+v));;
        }

     

     



     

    遍历方法

    快捷键:

    代码格式化:ctrl+sfhit+f

    自动提示:alt+?

    抽取变量:alt+shift+L

     

     复习总结

     

     Arrays

    public static void main(String[] args) {
            String[] data = { "zhangsan", "lisi", "wanger", "mazi","qianwu","zhaoliu" };
            List<String> asList = Arrays.asList(data);
            System.out.println(asList);
    
            System.out.println(data);
            System.out.println(Arrays.toString(data));
    
            int binarySearch = Arrays.binarySearch(data, "lisi");
            System.out.println(binarySearch);
    
            //对数组进行扩容
            String[] copyOf = Arrays.copyOf(data, data.length + 4);
            for (String item : copyOf)
                System.out.println(item);
            
            String[] copyOfRange = Arrays.copyOfRange(data, 2, 4); 
            System.out.println(Arrays.toString(copyOfRange));
            
            String[] copyOf2 = Arrays.copyOf(data, data.length);
            boolean equals = Arrays.equals(data,copyOf2);//比较两个数组的内容是否相等
            System.out.println(equals);
            
            
            boolean[] bol = new boolean[8];
            System.out.println(Arrays.toString(bol));
            Arrays.fill(bol,true);
            System.out.println(Arrays.toString(bol));
            
            Arrays.sort(data);
            System.out.println(Arrays.toString(data));
            
            System.out.println("--------------------");
            //匿名内部类
            Comparator<String> c = new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    return o2.length()-o1.length();
                }
            };
            
            Arrays.sort(data,c);
            System.out.println(Arrays.toString(data));
            
            data = new String[]{ "zhangsan", "lisi", "wanger", "mazi","qianwu","zhaoliu" };
            Arrays.sort(data,(o1,o2)->o2.length()-o1.length());
            System.out.println(Arrays.toString(data));
        }

    collections

    public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            
            Collections.addAll(list,"zhangsan", "lisi","zhangsan","wanger","zhangsan","mazi");
            System.out.println(list);
            
            int binarySearch = Collections.binarySearch(list, "lisi3");
            System.out.println(binarySearch);
            
            int binarySearch2 = Collections.binarySearch(list, "wanger", (o1,o2)->o1.length()-o2.length());
            System.out.println(binarySearch2);
            
            Collections.sort(list, new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    return o1.length()-o2.length();
                }
            });
            System.out.println(list);
            
            Collections.shuffle(list);
            System.out.println(list);
            
            Collections.sort(list, (o1,o2)->o1.length()-o2.length());;
            System.out.println(list);
            
            Collections.replaceAll(list, "zhangsan", "***");
            System.out.println(list);
            
            Collections.swap(list, 1, 3);
            System.out.println(list);
            
            Collections.reverse(list);
            System.out.println(list);
        }

    list

    public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            Collections.addAll(list,"zhangsan", "lisi","wanger","mazi");
            
            for(int i =0;i<list.size();i++){
                System.out.println(list.get(i));
            }
            
            for(String item : list){
                System.out.println(item);
            }
            
            Iterator<String> iterator = list.iterator();
            while(iterator.hasNext()){
                System.out.println(iterator.next());
            }
            
            ListIterator<String> listIterator = list.listIterator();
            while(listIterator.hasNext()){
                System.out.println(listIterator.next());
            }
            
            list.forEach(item->System.out.println(item));
            
            list.forEach(System.out::println);
        }

    set

    public static void main(String[] args) {
            Set<String> set = new HashSet<>();
            set.add("aa");
            set.add("bb");
            set.add("cc");
            set.add("dd");
    
            for(String item : set){
                System.out.println(item);
            }
            
            Iterator<String> iterator = set.iterator();
            while(iterator.hasNext()){
                System.out.println(iterator.next());
            }
            
            set.forEach(item->System.out.println(item));
            
            set.forEach(System.out::println);
        }

    map

    原则:将map变为set

    public static void main(String[] args) {
            Map<Integer,Goods> map = new HashMap<>();
            map.put(111, new Goods(111,"aaa",1,"aaaaaaaaaaa"));
            map.put(222, new Goods(222,"bbb",2,"bbbbbbbbbbbbb"));
            map.put(333, new Goods(333,"ccc",3,"ccccccccccccc"));
            map.put(444, new Goods(444,"ddd",4,"dddddddddddd"));
            
            Set<Integer> keySet = map.keySet();
            for(Integer key : keySet){
                System.out.println(key+" : "+map.get(key));
            }
            
            Set<Entry<Integer, Goods>> entrySet = map.entrySet();
            for(Entry<Integer, Goods> item : entrySet){
                System.out.println(item.getKey()+" "+item.getValue());
            }
            
            map.forEach((k,v)->System.out.println(k+" :: "+v));;
        }

     

     

     

    扩展:

    public static void main(String[] args) {
            List<String> list = Arrays.asList("zhangsan","lisi","wanger","mazi");
            
            Collections.sort(list, new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    return o1.length() - o2.length();
                }
            });
            
            System.out.println(list);
            
            System.out.println("-------------");
            list.forEach(item->System.out.println(item+" "+item.hashCode()));
            
            list.sort((o1,o2)->{
                return o1.hashCode()- o2.hashCode();
            });
            list.forEach(System.out::println);
        }

     

    转载于:https://www.cnblogs.com/expedition/p/10955318.html

    展开全文
  • 集合的函数式API但是入门 Lambda编程 的最佳示例,这里我们先创建一个水果集合,并且向里面添加水果: // 第一种方式 val list = ArrayList<String>() list.add("Apple") list.add("Banana") list.add(...

    1. Lambda编程

    1.1

    集合的函数式API但是入门 Lambda编程 的最佳示例,
    这里我们先创建一个水果集合,并且向里面添加水果:
    
    //	第一种方式
        val list = ArrayList<String>()
        list.add("Apple")
        list.add("Banana")
        list.add("watermelon")
        list.add("Pear")
    
    这种初始化集合的方式比较繁琐, Kotlin专门提供了一个内置的listOf()
    函数来简化初始化集合的操作:
    
    val list = listOf("Apple", "Banana", "watermelon", "Pear")
    
    遍历集合的操作 for-in 循环:
    
    fun main() {
    //    val list = ArrayList<String>()
    //    list.add("Apple")
    //    list.add("Banana")
    //    list.add("watermelon")
    //    list.add("Pear")
        val list = listOf("Apple", "Banana", "watermelon", "Pear")
        for (fruit in list) {
            println(fruit)
        }
    }
    

    运行结果:
    在这里插入图片描述

    需要注意的是 listof函数创建的集合是一个不可变的集合
    
    那么如何创建一个可变的集合呢?
    
        val list = mutableListOf("Apple", "Banana", "watermelon", "Pear")
        list.add("Grape")
    
    前面介绍的都是用List集合的用法,实际上Set集合的用法几乎与它一样,
    只是将创建集合的方式换成了setOf()和mutableSetOF()函数而已.
    
        val set = setOf("Apple", "Banana", "watermelon", "Pear")
        for (fruit in set) {
            println(fruit)
        }
    
    需要注意的是 Set集合底层使用的是hash映射机制来存放数据的, 
    因此集合中的元素无法保证有序, 这是和List集合最大的不同之处.
    
    我们来看一下Map集合. 
    Map是一种键值对型的数据结构,因此在用法上和List,Set集合有着较大的不同.
    

    这是传统的写法:

     val map=HashMap<String,Int>()
        map.put("Apple",1)
        map.put("Banana",2)
        map.put("watermelon",3)
        map.put("Pear",4)
        map.put("Grape",5)
    

    Kotlin更推荐这种写法:

        val map=HashMap<String,Int>()
        map["Apple"] = 1
        map["Banana"] = 2
        map["watermelon"] = 3
        map["Pear"] = 4
        map["Grape"] = 5
    

    从map中读取一条数据可以这么写:

    val number=map["Apple"]
    
    Kotlin提供了mapOf()和mutableMapOf()函数来继续简化Map的用法. 
    在mapOf()函数中,我们可以直接传入初始化的键值对组合来完成对Map集合的创建.
    
    val map = mapOf("Apple" to 1, "Banana" to 2, "watermelon" to 3, "Pear" to 4)
    
    这里的to并不是关键字, 而是infix函数
    

    遍历Map集合:

    fun main() {
        val map = mapOf("Apple" to 1, "Banana" to 2, "watermelon" to 3, "Pear" to 4)
        for ((fruit, number) in map) {
            println("fruit is $fruit , number is $number")
        }
    }
    

    在这里插入图片描述


    关于集合的创建和遍历就学到这里了, 下面开始学习集合的函数式API, 
    从而正式入门Lambda编程.
    
    首先我们先来考虑一个需求,如何在一个水果集合里面找到单词最长的那个水果?
     当然这个需求很简单, 也有很多种写法, 你可能会很自然的这样写出来:
    
    fun main() {
        val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
        var maxLengthFruit = ""
        for (fruit in list) {
            if (fruit.length > maxLengthFruit.length) {
                maxLengthFruit = fruit
            }
            println(maxLengthFruit)
        }
    }
    
    虽然这段代码很简洁, 思路也很清晰, 但如果我们使用集合的函数式API,
    就可以让这个功能变得更加容易
    
    fun main() {
        val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
        val maxLengthFruit=list.maxBy { it.length }
        println("maxLengthFruit is $maxLengthFruit.")
        }
    
    或许你现在看来比较吃力, 但当你学完Lambda表达式的语法后, 
    再回头来看这段代码, 你就会觉得非常简单了.
    

    1.2 Lambda定义:

    如果用最直白的话来阐述.lambda就是一小段可以作为参数传递的代码. 
    从定义看, 正常情况下, 我们向某个函数传入参数时只能传入变量, 
    但借助Lambda却允许传入一小段代码.
    注意: 这里的一小段代码并没有现在多长, 
    但是不建议在Lambda表达式中写入大量的代码, 否则会极大的影响代码的可读性.
    

    Lambda表达式的语法结构:
    {参数名1 : 参数类型 , 参数名2 : 参数类型 -> 函数体}

    函数体中可以编写任意行代码, 
    并且最后一行代码会作为Lambda表达式的返回值.
    maxBy()函数的工作原理是根据我们传入的条件来遍历集合,
    从而找到该条件下的最大值.
    
    理解了maxBy()函数的工作原理后,我们开始套用Lambda表达式
    
        val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
        val lambda = { fruit: String -> fruit.length }
        val maxLengthFruit = list.maxBy(lambda)
    
    可以看maxBy()函数实际上是接收了一个Lambda参数而已.
    下面开始简化代码:
    
    一.我们不需要专门定义lambda变量,而是直接将lambda传入到maxBy()函数中
    
        val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
        val maxLengthFruit = list.maxBy({ fruit: String -> fruit.length })
    
    二.Kotlin规定, 当Lambda表达式是函数的最后一个参数时,可以将它写在外面
    
        val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
        val maxLengthFruit = list.maxBy(){ fruit: String -> fruit.length }
    
    三.如果Lambda表达式是唯一参数,则可以省略()
    
        val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
        val maxLengthFruit = list.maxBy{ fruit: String -> fruit.length }
    
    四.由于Kotlin拥有出色的类型推导机制,
    所有在大多数情况下可以省略参数的类型
    
        val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
        val maxLengthFruit = list.maxBy { fruit -> fruit.length }
    
    五.当Lambda表达式的参数列表只有一个参数时,
    也不必声明参数名,而是可以使用it关键字来代替
    
        val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
        val maxLengthFruit=list.maxBy { it.length }
    
    所以这里就得到了最开始的Lambda表达式的形式.
    

    接下来我们再来学习几个集合中常用的API,
    相信这些对于现在的你来说,已经没有什么难度了.
    
    集合中的map函数是最常用的一种函数式的API,
    它用于将集合中的每个元素都映射成为一个另外的值,
    映射的规则是在Lambda表达式中指定,最终生成一个新的集合.
    比如现在我们希望让所有的水果名都变为大写的字母.
    
    fun main() {
        val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
        val newList=list.map { it.toUpperCase() }
        for (fruit in newList){
            println(fruit)
        }
    }
    

    运行结果:
    在这里插入图片描述

    接下来我们学习另外一种比较常用的函数式API-filter函数.
    顾名思义,filter函数就是过滤集合里的数据用的,它可以单独使用,
    也可以结合map使用.比如我们向只保留5个字母以内的水果,我们可以这么做.
    
    fun main() {
        val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
        val newList = list.filter { it.length <= 5 }.map { it.toUpperCase() }
        for (fruit in newList) {
            println(fruit)
        }
    }
    

    运行结果:
    在这里插入图片描述
    !注意:

    上述代码我们是先调用了filter函数再去调用map函数.
    如果你是先调用map函数再去调用filter函数,也可以实现相同的效果,
    但是效率会低很多.
    因为这样相当于要对集合里的所有元素进行一次映射转换后在进行过滤.
    

    接下来我们继续学习2个比较常用的函数式API-any和all函数,
    其中any函数用于判断集合中是否至少存在一个满足指定条件的元素,
    而all函数则是用于判断集合里所有的元素是否都满足指定的条件.
    由于这2个函数比较简单,这里就直接上手代码:
    
    fun main() {
        val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
        val anyResult = list.any { it.length <= 5 }
        val allResult = list.all { it.length <= 5 }
        println("anyResult is $anyResult")
        println("allResult is $allResult")
    }
    

    运行结果:
    在这里插入图片描述



    展开全文
  • List集合与set集合的多种... lambda表达式遍历一、List集合的遍历1.创建一个集合,添加一些元素放在集合当中public static void main(String[] args) {//int[] ins = new int[8];//intList list = new ArrayList()...
  • List集合与set集合的多种... lambda表达式遍历一、List集合的遍历1.创建一个集合,添加一些元素放在集合当中public static void main(String[] args) {//int[] ins = new int[8];//intList list = new ArrayList()...
  • 4. lambda表达式遍历 一、List集合的遍历 1.创建一个集合,添加一些元素放在集合当中 public static void main(String[] args) { //int[] ins = new int[8];//int List<String> list = new ArrayList<...
  • 文章目录创建HashMap集合,添加数据一、第一种foreach遍历二、第二种foreach遍历三、第一种迭代器遍历 效率高(建议使用)四、第二种迭代器遍历 效率低(不建议使用)五、JDK8新特性,通过lambda遍历Map 创建HashMap...
  • Java遍历Map对象的四种方法(Map泛型)1.使用entrySet遍历2....使用Lambda遍历5.总结 添加map模拟数据 Map<String,Object> map = new HashMap<>(); for (int i = 0; i < 10; i++) { ...
  • lambda

    2019-12-27 21:55:51
    1.对象不为空 DictionaryDTO dictionaryByIdReq = dictionaryMapper.findDictionaryById(dictionaryId);...2.集合添加(将一个集合遍历到另一个空集合中,此例是批量删除) List<SpuAttributeDO> spu = spu...
  •   在JDK-8中,新添加了很多的方法,比如说现在我所说的forEach,该方法是用于集合遍历的,其方式相当于传统的for循环遍历方式,只是与其不同之处就在于采用了lambda表达式,因而在进行循环遍历时代码更加的简介。...
  • 二、Lambda表达式

    2016-06-05 02:15:37
    Java 8新特性.个人感觉能减少不少没必要的格式代码.可以理解为匿名函数Lambda lambda好处 bad code lambda code Lambda语法 Lambda 表达式的结构 Lambda使用日常 ...Android添加Lambda支持Lambdalambda好处bad
  • 我们想要在遍历UGUI控件的同时找到所有的Button并为他们添加点击事件这项需求,和我们想要在遍历UGUI控件的同时找到所有的Toggle并为他们添加值改变事件这项需求。 同时为了区分不同的Button或Toggle我们需要一个...
  • Java基础加强重温_06:可变参数(格式)、Collections类...、Map集合遍历(键找值遍历、键值对遍历、forEach遍历结合λ Lambda)、Map案例(自定义类做key、统计字符次数、TreeMap排序)、图书管理系统(结合Map实现)
  • Lambda表达式是Java8中添加的新功能。使用Lambda表达式可以替代只有一个抽象函数接口实现,告别匿名内部类,代码看起来更简洁。Lambda表达式同时还提升了对集合、框架的迭代、遍历、过滤数据的操作。 函数式接口 ...
  • 集合的函数式API是用来入门Lambda编程的最佳示例,我们先用kotlin创建一个包含许多水果的集合,然后将水果一个个添加到集合中 val list = ArrayList<String>() list.add("苹果") list.add("香蕉") list.add(...
  • 2.6--Lambda编程

    2020-05-03 02:34:23
    2.6.1集合的创建于遍历 传统意义上的集合主要就是List 和Set 以及键值对的Map ,这些数据结构在Java 中都是接口,List 的主要实现为ArrayList 和 LinkedList,Set 的主要实现为HashSet,而Map 的主要实现为HashMap,...
  • H4_Lambda衍生_Stream流

    2020-07-09 19:07:29
    而当我们需要对集合中的元素进行操作的时候,除了必需的添加、删除、获取外,最典型的就是集合遍历。 传统做法: public class D01List { public static void main(String[] args) { List<String> list = ...
  • Kotlin笔记6-Lambda编程1-集合的创建与遍历 4.1 Lambda编程1 集合 Java接口 List Set Map ArrayList,LinkedList HashSet HashMap List List 集合逐个添加 val list = ArrayList<String>() ...
  • 比如我需要多次筛选出一个List集合里面合适的元素,那么我需要多个遍历,每个遍历添加筛选条件。而使用Stream可以直接体现“做什么”的思想,让我们不用在实现细节方面做文章。 ②没有副作用,变量无状态。不保存...
  • Lambda,AWS和Python的自动化管理操作 - 自动开机和关机发布时间:2020-08-19 01:57:49来源:51CTO阅读:537栏目:云计算上一篇豆子已经配置在PyCharm里面添加了boto3和pyboto3,因此写脚本的时候可以直接在自己的...
  • Stream流 说到Stream便容易想到I/O Stream,而实际上,谁规定“流”就一定是“IO...而当我们需要对集合中的元素进行操作的时候,除了必需的添加、删除、获取外,最典型的就是集合遍历。例如: package com.wsj.java
  • filter和mapfilter即过滤,它会遍历集合并选出应用给定lambda后返回未true的元素。使用它可以移除不满足条件的元素(数据源并不会改变)例如:val list = listOf(1,2,3,4,5,6)//过滤奇数,保留偶数println(list....
  • { 语句 }1.Lambda遍历List和MapView Code二、接口的默认方法Java 8允许我们给接口添加一个非抽象的方法实现,只需要使用 default关键字即可,这个特征又叫做扩展方法。View Code三、方法和构造函数的引用Java 8 允....
  • 迭代方法,顾名思义就是对数组进行遍历操作的算法,当然大部分方法都不仅仅只是遍历这么简单,例如filter方法可以添加遍历的筛选条件,此外对于需要传递回调参数的方法,本文都使用了Lambda语法,所以需要有一些基础...
  • JAVA之Stream流

    2020-11-21 20:11:21
    而当我们需要对集合中的元素进行操作的时候,除了必需的添加、删除、获取外,最典型的就是集合遍历。 循环遍历的弊端 Java 8的Lambda让我们可以更加专注于做什么(What),而不是怎么做(How),这点此前已经结合...
  • 处理集合的Stream流

    2020-11-21 19:30:07
    一、Stream流 在Java 8中,得益于Lambda所带来的...而当我们需要对集合中的元素进行操作的时候,除了必需的添加、删除、获取外,最典型的就是集合遍历。 List<String> list = new ArrayList<>(.
  • Stream流在Java 8中,得益于Lambda所带来的函数式编程,引入了一个全新的Stream概念,用于解决已有集合类库既有的弊端一、传统遍历1、传统集合的多步遍历代码几乎所有的集合(如 Collection 接口或 Map 接口等)都支持...
  •   说到Stream很容易想到IO流,实际上,在Java8中,得益于Lambda表达式带来的函数式编程,引入全新的Stream概念,用于解决有集合类库既有的弊端。 1.1、传统集合遍历   对于集合的操作,除了添加、删除、获取外,...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 126
精华内容 50
关键字:

lambda添加遍历