精华内容
参与话题
问答
  • Lamda

    2019-10-28 17:17:50
  • lamda

    2020-09-08 19:25:44
    1-groupBy Map<String, List<User>> map = list.parallelStream() .collect(Collectors.groupingBy(User::getClass)); Map<Integer, Long> map = list.parallelStream() .collect(Collectors....

    1-groupBy

     Map<String, List<User>> map = list.parallelStream() .collect(Collectors.groupingBy(User::getClass));

     Map<Integer, Long> map = list.parallelStream() .collect(Collectors.groupingBy(User::getId, Collectors.counting()));

    2- toList

     List<Long> ids = list.stream().map(User::getId).collect(Collectors.toList());

    3-sum

     int sum = list.stream() .mapToInt(u -> u.getScore()).sum();

    4-filter

    List<User> list = list.stream().filter(u -> u.getScore()>60).collect(Collectors.toList());

    5-findAny

     boolean has100= list.stream().filter(u -> u.getScore()==60).findAny().isPresent();

    展开全文
  • 最常用的 Java 8 中的 Lambda 函数(项目中实用笔记) 简介 Java 8 中的新特性,虽然现在都出到了Java14版本,不过在日常的开发过程中,8的版本是足够使用了,再说现在的8以上的版本也都面向商业收费了,很多新手,我...

    最常用的 Java 8 中的 Lambda 函数(项目中实用笔记)

    在这里插入图片描述

    简介

    Java 8 中的新特性,虽然现在都出到了Java14版本,不过在日常的开发过程中,8的版本是足够使用了,再说现在的8以上的版本也都面向商业收费了,很多新手,我所接触到的,像我那时候一样,追求船新版本,一上来就去学java14的东西,当成一个爱好还行,重心还是要放在实用上

    过滤

    需求:我需要过滤高考分数大于500的人

    首先,新建一个内部类

        static class Student{
            private String name;
            private Integer score;
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name!=null ? name.trim() : null;
            }
    
            public Integer getScore() {
                return score;
            }
    
            public void setScore(Integer score) {
                this.score = score;
            }
    
            public Student(String name, Integer score) {
                this.name = name;
                this.score = score;
            }
    
            @Override
            public String toString() {
                return "Student{" +
                        "name='" + name + '\'' +
                        ", score=" + score +
                        "}\n";
            }
        }
    

    使用IntStream遍历快速初始化一批值

        public static void main(String[] args) {
          List<Student> studentList =  IntStream.rangeClosed(0,20)
                    .mapToObj(i -> new Student("Java Pro"+i,490+i))
                    .collect(Collectors.toList());
        }
    

    过滤出分数大于500的并输出

            List<Student> studentGiao = studentList.stream()
                  .filter(student -> student.score > 500)
                  .collect(Collectors.toList());
            System.out.println(studentGiao.toString());
    

    输出:

    [Student{name='Java Pro11', score=501}
    , Student{name='Java Pro12', score=502}
    , Student{name='Java Pro13', score=503}
    , Student{name='Java Pro14', score=504}
    , Student{name='Java Pro15', score=505}
    , Student{name='Java Pro16', score=506}
    , Student{name='Java Pro17', score=507}
    , Student{name='Java Pro18', score=508}
    , Student{name='Java Pro19', score=509}
    , Student{name='Java Pro20', score=510}
    ]
    

    日常求和

    需要考虑到为空和为0的情况

    package com.github.gleans;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.Objects;
    
    public class LambdaLearning {
        public static void main(String[] args) {
            List<Double> nums = Arrays.asList(1.01, 2.11, 3.23, 4.222, null, 5.6);
            double resNum = nums.stream()
                    .map(num -> Objects.isNull(num) ? 0 : num)
                    .mapToDouble(num -> num)
                    .sum();
            System.out.println(resNum);
        }
    }
    

    map是重新指向一个对象,把->右侧的对象赋予,此处判断若num为null则赋予0值
    注意,这里不可给null使用filter过滤掉,否则全为null的情况,会报空指针异常

    扩展计算

        public static void testTwo(){
            List<Double> nums = Arrays.asList(1.01, 2.11, 3.23, 4.222, null, 5.6);
            DoubleSummaryStatistics number = nums.stream()
                    .map(num -> Objects.isNull(num) ? 0 : num)
                    .mapToDouble(num -> num)
                    .summaryStatistics();
            System.out.println("最大值:"+number.getMax());
            System.out.println("最小值:"+number.getMin());
            System.out.println("平均值:"+number.getAverage());
        }
    

    输出

    最大值:5.6
    最小值:0.0
    平均值:2.6953333333333336
    

    reduce简单使用

        public static void main(String[] args) {
            testOne();
        }
    
        public static void testOne(){
            List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
            // 这里的 10 相当于初始值
            int sum = numbers
                    .stream()
                    .reduce(10, Integer::sum);
            System.out.println(sum);
        }
    

    Collectors.groupingBy

    根据年龄分组

    package com.github.gleans;
    
    import java.math.BigDecimal;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    import java.util.stream.Collectors;
    
    public class SumWage {
        public static void main(String[] args) {
            List<UserDemo> userDemoList = new ArrayList<UserDemo>() {{
                add(new UserDemo(20, "jason", BigDecimal.valueOf(1000000)));
                add(new UserDemo(22, "yasuo", BigDecimal.valueOf(2000000)));
                add(new UserDemo(22, "ekko", BigDecimal.valueOf(100)));
            }};
            Map<Integer, List<UserDemo>> UserDemoMapByAge = userDemoList.stream()
                    .collect(Collectors.groupingBy(UserDemo::getAge));
            System.out.println(UserDemoMapByAge.toString());
        }
    
        static class UserDemo {
            private int age;
            private String username;
            private BigDecimal wage;
    
            public UserDemo(int age, String username, BigDecimal wage) {
                this.age = age;
                this.username = username;
                this.wage = wage;
            }
    
            public int getAge() {
                return age;
            }
    
            public void setAge(int age) {
                this.age = age;
            }
    
            public String getUsername() {
                return username;
            }
    
            public void setUsername(String username) {
                this.username = username;
            }
    
            public BigDecimal getWage() {
                return wage;
            }
    
            public void setWage(BigDecimal wage) {
                this.wage = wage;
            }
    
            @Override
            public String toString() {
                return "UserDemo{" +
                        "age=" + age +
                        ", username='" + username + '\'' +
                        ", wage=" + wage +
                        '}';
            }
        }
    }
    

    输出

    {20=[UserDemo{age=20, username='jason', wage=1000000}], 22=[UserDemo{age=22, username='yasuo', wage=2000000}, UserDemo{age=22, username='ekko', wage=100}]}
    

    json化观看观看更为直观

    {
    	20:[
    		{
    			"age":20,
    			"username":"jason",
    			"wage":1000000
    		}
    	],
    	22:[
    		{
    			"age":22,
    			"username":"yasuo",
    			"wage":2000000
    		},
    		{
    			"age":22,
    			"username":"ekko",
    			"wage":100
    		}
    	]
    }
    

    进阶计算 Collectors.summarizingDouble

    Map<Integer, DoubleSummaryStatistics> userAvgWageByAge = userDemoList.stream()
                    .collect(Collectors.groupingBy(UserDemo::getAge, Collectors.summarizingDouble(s -> s.getWage().doubleValue())));
    
    userAvgWageByAge.forEach((k, v) -> System.out.println(String.format("年龄:%d,平均工资:%f", k, v.getAverage())));
    

    数组快速转为List

    Stream.of(1, 2, 3, 4).collect(Collectors.toList())
    

    结论

    后续会学习更多关于Lambda的操作,日积月累…一定会成为一个秃头的程序猿

    展开全文
  • Sarsa-Lamda

    千次阅读 2017-05-07 17:37:37
    1、算法: Sarsa-lambda 是基于 Sarsa 方法的升级版, 他能更有效率地学习到怎么样获得好的 reward. 如果说 Sarsa 和 Qlearning 都是每次获取到 reward, 只更新获取到 reward 的前一步. 那 Sarsa-lambda 就是更新...

    1、算法:
    这里写图片描述
    Sarsa-lambda 是基于 Sarsa 方法的升级版, 他能更有效率地学习到怎么样获得好的 reward. 如果说 Sarsa 和 Qlearning 都是每次获取到 reward, 只更新获取到 reward 的前一步. 那 Sarsa-lambda 就是更新获取到 reward 的前 lambda 步. lambda 是在 [0, 1] 之间取值,
    如果 lambda = 0, Sarsa-lambda 就是 Sarsa, 只更新获取到 reward 前经历的最后一步.
    如果 lambda = 1, Sarsa-lambda 更新的是 获取到 reward 前所有经历的步.
    2、代码实现:
    算法更新同Sarsa;
    算法决策:
    2.1、主结构:

    class SarsaLambdaTable:
        # 初始化 (有改变)
        def __init__(self, actions, learning_rate=0.01, reward_decay=0.9, e_greedy=0.9, trace_decay=0.9):
    
        # 选行为 (与之前一样)
        def choose_action(self, observation):
    
        # 学习更新参数 (有改变)
        def learn(self, s, a, r, s_):
    
        # 检测 state 是否存在 (有改变)
        def check_state_exist(self, state):

    2.2、预设值:

    在预设值当中, 添加了 trace_decay=0.9 这个就是 lambda 的值了. 这个值将会使得拿到 reward 前的每一步都有价值.

    class SarsaLambdaTable(RL): # 继承 RL class
        def __init__(self, actions, learning_rate=0.01, reward_decay=0.9, e_greedy=0.9, trace_decay=0.9):
            super(SarsaLambdaTable, self).__init__(actions, learning_rate, reward_decay, e_greedy)
    
            # 后向观测算法, eligibility trace.
            self.lambda_ = trace_decay
            self.eligibility_trace = self.q_table.copy()    # 空的 eligibility trace 表

    2.3、检查state是否存在:

    check_state_exist 和之前的是高度相似的. 唯一不同的地方是我们考虑了 eligibility_trace,

    class SarsaLambdaTable(RL): # 继承 RL class
        def __init__(self, actions, learning_rate=0.01, reward_decay=0.9, e_greedy=0.9, trace_decay=0.9):
            ...
        def check_state_exist(self, state):
            if state not in self.q_table.index:
                # append new state to q table
                to_be_append = pd.Series(
                        [0] * len(self.actions),
                        index=self.q_table.columns,
                        name=state,
                    )
                self.q_table = self.q_table.append(to_be_append)
    
                # also update eligibility trace
                self.eligibility_trace = self.eligibility_trace.append(to_be_append)

    2.4、学习:

    有了父类的 RL, 我们这次的编写就很简单, 只需要编写 SarsaLambdaTable 中 learn 这个功能就完成了. 因为其他功能都和父类是一样的. 这就是我们所有的 SarsaLambdaTable 于父类 RL 不同之处的代码. 是不是很简单.

    class SarsaLambdaTable(RL): # 继承 RL class
        def __init__(self, actions, learning_rate=0.01, reward_decay=0.9, e_greedy=0.9, trace_decay=0.9):
            ...
        def check_state_exist(self, state):
            ...
        def learn(self, s, a, r, s_, a_):
            # 这部分和 Sarsa 一样
            self.check_state_exist(s_)
            q_predict = self.q_table.ix[s, a]
            if s_ != 'terminal':
                q_target = r + self.gamma * self.q_table.ix[s_, a_]
            else:
                q_target = r
            error = q_target - q_predict
    
            # 这里开始不同:
            # 对于经历过的 state-action, 我们让他+1, 证明他是得到 reward 路途中不可或缺的一环
            self.eligibility_trace.ix[s, a] += 1
    
            # Q table 更新
            self.q_table += self.lr * error * self.eligibility_trace
    
            **# 更有效的更新方式:
            self.eligibility_trace.ix[s, :] *= 0
            self.eligibility_trace.ix[s, a] = 1**
    
            # 随着时间衰减 eligibility trace 的值, 离获取 reward 越远的步, 他的"不可或缺性"越小
            self.eligibility_trace *= self.gamma*self.lambda_

    2.5、环境:

    import numpy as np
    np.random.seed(1)
    import tkinter as tk
    import time
    
    
    UNIT = 40   # pixels
    MAZE_H = 4  # grid height
    MAZE_W = 4  # grid width
    
    
    class Maze(tk.Tk,object):
    #注意不要却object
        def __init__(self):
            super(Maze, self).__init__()
            self.action_space = ['u', 'd', 'l', 'r']
            self.n_actions = len(self.action_space)
            self.title('maze')
            self.geometry('{0}x{1}'.format(MAZE_H * UNIT, MAZE_H * UNIT))
            self._build_maze()
    
        def _build_maze(self):
            self.canvas = tk.Canvas(self, bg='white',
                               height=MAZE_H * UNIT,
                               width=MAZE_W * UNIT)
    
            # create grids
            for c in range(0, MAZE_W * UNIT, UNIT):
                x0, y0, x1, y1 = c, 0, c, MAZE_H * UNIT
                self.canvas.create_line(x0, y0, x1, y1)
            for r in range(0, MAZE_H * UNIT, UNIT):
                x0, y0, x1, y1 = 0, r, MAZE_H * UNIT, r
                self.canvas.create_line(x0, y0, x1, y1)
    
            # create origin
            origin = np.array([20, 20])
    
            # hell
            hell1_center = origin + np.array([UNIT * 2, UNIT])
            self.hell1 = self.canvas.create_rectangle(
                hell1_center[0] - 15, hell1_center[1] - 15,
                hell1_center[0] + 15, hell1_center[1] + 15,
                fill='black')
            # hell
            hell2_center = origin + np.array([UNIT, UNIT * 2])
            self.hell2 = self.canvas.create_rectangle(
                hell2_center[0] - 15, hell2_center[1] - 15,
                hell2_center[0] + 15, hell2_center[1] + 15,
                fill='black')
    
            # create oval
            oval_center = origin + UNIT * 2
            self.oval = self.canvas.create_oval(
                oval_center[0] - 15, oval_center[1] - 15,
                oval_center[0] + 15, oval_center[1] + 15,
                fill='yellow')
    
            # create red rect
            self.rect = self.canvas.create_rectangle(
                origin[0] - 15, origin[1] - 15,
                origin[0] + 15, origin[1] + 15,
                fill='red')
    
            # pack all
            self.canvas.pack()
    
        def reset(self):
            self.update()
            time.sleep(0.5)
            self.canvas.delete(self.rect)
            origin = np.array([20, 20])
            self.rect = self.canvas.create_rectangle(
                origin[0] - 15, origin[1] - 15,
                origin[0] + 15, origin[1] + 15,
                fill='red')
            # return observation
            return self.canvas.coords(self.rect)
    
        def step(self, action):
            s = self.canvas.coords(self.rect)
            base_action = np.array([0, 0])
            if action == 0:   # up
                if s[1] > UNIT:
                    base_action[1] -= UNIT
            elif action == 1:   # down
                if s[1] < (MAZE_H - 1) * UNIT:
                    base_action[1] += UNIT
            elif action == 2:   # right
                if s[0] < (MAZE_W - 1) * UNIT:
                    base_action[0] += UNIT
            elif action == 3:   # left
                if s[0] > UNIT:
                    base_action[0] -= UNIT
    
            self.canvas.move(self.rect, base_action[0], base_action[1])  # move agent
    
            s_ = self.canvas.coords(self.rect)  # next state
    
            # reward function
            if s_ == self.canvas.coords(self.oval):
                reward = 1
                done = True
            elif s_ in [self.canvas.coords(self.hell1), self.canvas.coords(self.hell2)]:
                reward = -1
                done = True
            else:
                reward = 0
                done = False
    
            return s_, reward, done
    
        def render(self):
            time.sleep(0.05)
            self.update()
    展开全文
  • Lamda表达式

    2019-11-28 22:09:28
    Lamda表达式 一、Lamda表达式 1.为什么要使用Lamda表达式 A.避免匿名内部类定义过多; B.可以让你的代码看起来很简洁; C.去掉了一堆没有意义的代码,只留下核心的逻辑。 2.Lamda表达式的书写格式 new Thread(()-&...
  • lamda表达式

    2019-10-13 19:29:32
    lamda是jdk8的一个新特性 它可以避免匿名内部类定义过多 ,其实质属于函数式编程的概念 它在简单线程的使用比较广泛 首先定义一个接口 interface Myinterface{ void lambda(); } 用不同的方式去实现这个接口看 ...
  • python lamda

    2016-03-13 14:29:58
    lambda只是一个表达式,函数体比def简单很多。 lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。 lambda表达式是起到一个函数速写的作用。允许在代码内嵌入一个函数的...
  • C++ lamda

    2017-11-25 15:18:02
    我是搞C++的 一直都在提醒自己,我是搞C++的;但是当C++11出来这么长时间了,我却没有跟着队伍走,发现很对不起自己的身份,也还好,发现自己也有段时间没有写C++代码了。今天看到了C++中的Lambda表达式,虽然用过...
  • Python lamda

    2016-03-27 13:23:11
    Why are Python lambdas useful? [closed] up vote449down votefavorite 253 I'm trying to figure out python lambdas. Is lambda one of those 'interesting' language
  • Lamda函数

    2019-11-07 16:41:01
    lambda语句被用来创建新的函数对象,并且在运行时返回它们 python使用lambda关键字来创建匿名函数。这种函数得名于省略了用def声明函数的标准步骤。 lambda只是一个表达式,函数体比def简单很多 ...
  • lamda expression

    2019-04-16 11:06:07
    Lambda表达式是什么 在解释Java Lambda Expression是什么之前,我们先来看看lambda表达式在Java语言中的表示形式。在Java中,每一个Lambda表达式都对应一个类型,(通常是接口类型)。在Java8以前,也即是Java ...
  • Lamda Expressions

    2017-11-16 14:24:03
    我们通常在调用一个方法时,在参数列表中定义一个匿名内部类,向方法中传递一个代码块,用来指定个性化的行为,如:Collections.sort(list, new Comparator(){ @Override public int compareTo(Person p1, Person...

空空如也

1 2 3 4 5 ... 20
收藏数 2,664
精华内容 1,065
关键字:

lamda