精华内容
下载资源
问答
  • # -*- coding: utf-8 -*- import os import random #设定文件路径 path = r'C:UsersAIDesktop0' ls = [] # 对目录下的文件进行遍历 for file in os.listdir(path): ...# ls.sort(key=lambda x: int(x[:-...
    # -*- coding: utf-8 -*-
    import os
    import random
    #设定文件路径
    path = r'C:UsersAIDesktop0'
    ls = []
    # 对目录下的文件进行遍历
    for file in os.listdir(path):
        ls.append(file)
    
    # 按照顺序排序修改
    # ls.sort(key=lambda x: int(x[:-4]))
    
    # 随机打乱数据修改
    # random.shuffle(ls)
    
    
    name = 201
    for dirs in ls:
        os.rename(os.path.join(path, dirs), os.path.join(path, str(name) + '.txt'))
        name += 1
    展开全文
  • 最近要做一个初始版的数据仓库项目,有一大批的MYSQL基础数据要通过整合后写入到ES,有部分数据量非常庞大,单线程批量写入会耗时很久,就想到了使用线程池来多线程做写入操作。 这个写法不要局限于我这个应用场景...

    最近要做一个初始版的数据仓库项目,有一大批的MYSQL基础数据要通过整合后写入到ES,有部分数据量非常庞大,单线程批量写入会耗时很久,就想到了使用线程池来多线程做写入操作。

    这个写法不要局限于我这个应用场景,别的应用场景也可以修改一下里面的逻辑。

    java版本要求在 1.8以上

    附代码:

    import org.apache.commons.collections.CollectionUtils;
    
    import java.util.List;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * 批量多线程执行写入任务
     */
    public class BatchThreadSave {
    
        /**
         * 批量多线程执行写入任务
         * @param action 返回的截取数据表  自行写操作方法
         * @param dataList 总数据表
         * @param threadCount 需要的线程总数  0 < threadCount < 11
         * @param <F> 指定数据表泛型
         */
        public static <F> void save(Executor<? super List<F>> action, List<F> dataList, int threadCount) {
            if (CollectionUtils.isEmpty(dataList)) {
                return;
            }
            if (threadCount < 1 || threadCount > 10) {
                return;
            }
            int threadSize = dataList.size() / (threadCount - 1);
            // 总数据条数
            int dataSize = dataList.size();
            // 分段数
            int threadNum = dataSize / threadSize + 1;
            // 创建一个线程池
            ExecutorService exec = Executors.newFixedThreadPool(threadCount);
            // 定义一个任务集合
            List<F> cutList = null;
            // 确定每条线程的数据
            try {
                for (int i = 0; i < threadNum; i++) {
                    if (i == threadNum - 1) {
                        cutList = dataList.subList(threadSize * i, dataSize);
                    } else {
                        cutList = dataList.subList(threadSize * i, threadSize * (i + 1));
                    }
                    List<F> finalCutList = cutList;
                    exec.execute(() -> {
                        action.runAction(finalCutList);
                    });
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                // 关闭线程池
                exec.shutdown();
            }
        }
    
        public interface Executor<T extends List> {
            void runAction(T t);
        }
    
    
    
    
    }

    那该怎么用呢?

    public void buildUserIndex() {
            List<User> users = userMapper.findAll();
            log.info("共获取到用户:" + users.size());
    
            BatchThreadSave.save(finalCutList -> {
                int j = 0;
                for (User user : finalCutList) {
    
                    j++;
                    log.info(Thread.currentThread().getName() + "   当前执行到" + user.getId() + "  剩余:" + (finalCutList.size() - j));
    
                    //finalCutList 这里就是被截取后的数据, 只管写后面的实现
                    //这里执行你的业务逻辑就行了  比如保存  数据处理等等
                    
                    
                }
            }, users, 10);
    
        }

     

    展开全文
  • 我要通过Id对应去修改Name值,下面这条sql语句能转吗?谢谢 <code class="language-sql">UPDATE test SET name = CASE id WHEN 1 THEN 'Name1' WHEN 2 THEN 'Name2' WHEN 3 ...
  • Lambda - 表达式

    千次阅读 2018-06-11 14:37:58
    为了编写这类处理批量数据的并行类库,需要在语言层面上修改现有的 Java:增加 Lambda 表达式。面向对象编程是对数据进行抽象,而函数式编程是对行为进行抽象。在写回调函数和事件处理程序时,程序员不必再纠缠于...

    本文总结、摘录自书籍《Java 8 函数式编程》
    系列文章 GitHub地址

    Lambda

    函数式编程

    为了编写这类处理批量数据的并行类库,需要在语言层面上修改现有的 Java:增加 Lambda 表达式。面向对象编程是对数据进行抽象,而函数式编程是对行为进行抽象。在写回调函数和事件处理程序时,程序员不必再纠缠于匿名内部类的冗繁和可读性,函数式编程让事件处理系统变得更加简单。能将函数方便地传递也让编写惰性代码变得容易,惰性代码在真正需要时才初始化变量的值。

    什么是函数式编程

    在思考问题时,使用不可变值和函数,函数对一个值进行处理,映射成另一个值。

    Lambda

    例子

    JButton button = new JButton("click me");
    
    button.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            System.out.println("clicked");
        }
    });

    等同于:

    button.addActionListener(event -> System.out.println("clicked"));

    不同的形式

    1) 无参数

    /**
     * 可打印的抽象接口
     */
    public interface Printable {
        void print();
    }
    
    public void testPrintable() {
        Printable printable = () -> System.out.println("aaa");
        printable.print();
    }

    2) 一个参数

    public interface Printable {
        void print(String arg);
    }
    
    Printable printable = arg -> System.out.println(arg);

    3)多个语句

    Printable printable = arg -> {
        System.out.println("one line");
        System.out.println(arg);
    };

    4)多个参数

    public interface PrintableMultiParams {
        void print(String print, boolean isPrint);
    }
    
    PrintableMultiParams printableMultiParams = (arg, isPrint) -> {
        if(isPrint) {
            System.out.println(arg);
        }
    };

    Lambda 表达式的参数类型可以由编译器推断出来,但是最好显式声明参数类型:

    PrintableMultiParams printableMultiParams = (String arg, boolean isPrint) -> {
        if(isPrint) {
            System.out.println(arg);
        }
    };

    Lambda 是静态类型

    下面引入一种情况:

    String name;
    
    PrintableMultiParams printableMultiParams = (arg, isPrint) -> {
        if(isPrint) {
            System.out.println(arg + name);
        }
    };

    上面的例子,在编译阶段就会报错。为什么呢?我们来看IDEA的编译器给我们提示了什么:

    Variable 'name' might not have been initialized

    意思是name没有初始化。我们在声明什么样子的变量时,会有这样的提示呢,或者说会有初始化的约束呢?答案就是final变量了。声明为final意味着不能为其重复赋值。实际上final变量可以被认为一个不可变的值。当然仅仅是不能改变引用指向的对象,并不是对象本身不可变,也就是说下面是可行的,这一点要特别注意,针对这一点,我很反感大量的博客说final变量是不可变的,却没有说明对象是可变的:

    final Person person = new Person("name");
    
    person.setName("Lisa");

    你可能会说,在这种情况下编译通过并且正常执行:

    String name = "vvv";
    
    PrintableMultiParams printableMultiParams = (arg, isPrint) -> {
        if(isPrint) {
            System.out.println(arg + name);
        }
    };

    那么我们尝试着对其做些改变:

    String name = "vvv";
    
    name = "ccc";
    
    PrintableMultiParams printableMultiParams = (arg, isPrint) -> {
        if(isPrint) {
            System.out.println(arg + name);
        }
    };

    下面是IDEA编译器给我们的提示:

    Variable used in lambda expression should be final or effectively final

    这种行为也解释了为什么 Lambda 表达式也被称为闭包。未赋值的变量与周边环境隔离起来,进而被绑定到一个特定的值。在众说纷纭的计算机编程语言圈子里,Java 是否拥有真正的闭包一直备受争议,因为在 Java 中只能引用既成事实上的 final 变量。名字虽异,功能相同,就好比把菠萝叫作凤梨,其实都是同一种水果。

    函数接口

    Lambda 表达式本身的类型:函数接口。函数接口指只有一个抽象方法的接口。前面的例子中的接口均符合函数接口的定义,如:

    public interface PrintableMultiParams {
        void print(String print, boolean isPrint);
    }

    可以得出以下约束:

    • 接口
    • 一个抽象方法

    注意:并没有对函数的返回值做任何限制,void或其它类型或泛型都是OK的。

    类型推断

    Lambda 表达式的参数类型可以由编译器推断出来。有时省略类型信息可以减少干扰,更易弄清状况;而有时却需要类型信息帮助理解代码。Lambda 表达式中的类型推断,实际上是 Java 7 就引入的目标类型推断的扩展,如下面的符号<>

    List<String> list = new ArrayList<>();

    Java 7 中程序员可省略构造函数的泛型类型,Java 8 更进一步,程序员可省略 Lambda 表达式中的所有参数类型。编译器可根据表达式的上下文推断出参数的类型,这就是所谓的类型推断。

    例子

    Java 8 中对ThreadLocal新增了一个创建此类实例的方法:

    public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
        return new SuppliedThreadLocal<>(supplier);
    }
    public interface Supplier<T> {
        T get();
    }

    不管SuppliedThreadLocal这个内部类是怎么实现的,我们只需要知道通过上面的静态方法可以创建一个实例,而静态方法需要一个函数接口Supplier类型的实例,既然是函数接口,Lambda就可以派上用场了:

    public void testThreadLocal() {
        ThreadLocal<Date> local = ThreadLocal.withInitial(() -> {
            return new Date();
        });
    
        System.out.println(local.get());
    }
    展开全文
  • 第一章 简介 1 Lambda表达式产生的原因:  商业发展需要复杂的应用,大多都跑在功能强大的多核CPU机器上,涉及到锁的...为了编写这类处理批量数据的并行类库,需要在语言层面上修改现有的Java:增加Lambda表达式。
    第一章 简介

    1 Lambda表达式产生的原因:
        商业发展需要复杂的应用,大多都跑在功能强大的多核CPU机器上,涉及到锁的编程,人们试图将并发抽象化,开发了java.util.concurrent包和第三方类的等,但是抽象级别还是不够,例如在处理大型数据集合时缺乏高效的并发操作,为了编写这类处理批量数据的并行类库,需要在语言层面上修改现有的Java:增加Lambda表达式。

    2 面向对象编程是对数据进行抽象,而函数式编程是对行为进行抽象。

    3 什么是函数式编程:
    每个人对函数式编程的理解不尽相同。但其核心是:在思考问题时,使用不可变值和函数,函数对一个值进行处理,映射成另一个值。

    第二章 Lambda表达式

    Java 8的最大变化是引入了Lambda表达式——一种紧凑的、传递行为的方式。

    设计匿名内部类的目的,就是为了方便Java程序员将代码作为数据传递。但是匿名内部类有较多样板代码,代码不够清晰。而Lambda表达式所需样板代码少,且参数类型不言而明时,不用显示指定,编译器可以通过上下文获取到参数的类型。

    Lambda表达式的不同形式:
            Runnable noArguments = () -> System.out.println("Hello world");

            ActionListener oneArgument = event -> System.out.println("Button clicked");

            Runnable mutiStatement = () -> {
                System.out.println("Hello");
                System.out.println(" World");
            };

            BinaryOperator<Long> add = (x, y) -> x + y;

            BinaryOperator<Long> addExplicit = (Long x, Long y) -> x + y;

    Lambada表达式引用的是值,而不是变量;

    函数接口:Lambda表达式本身的类型。函数接口是只有一个抽象方法的接口。,接口中单一方法的命名并不重要,只要方法签名和Lambda表达式的类型匹配即可。

    java中重要的函数接口


    展开全文
  • # -*- coding: utf-8 -*- import os import random #设定文件路径 path = r'C:\Users\AI\Desktop\0' ...# ls.sort(key=lambda x: int(x[:-4])) # 随机打乱数据修改 # random.shuffle(ls) name = 201 f
  • 直接上代码 import os,time import cv2 #获取文件夹中的文件名列表 def get_file_list(file_path): dir_list = os.listdir(file_path) ... # 注意,这里使用lambda表达式,将文件按照最后修改时...
  • 文章目录dataframe批量修改某一列 dataframe批量修改某一列 df['a'] = df['a'].map(lambda x: x*2)
  • pandas 字段操作

    2020-08-17 20:54:05
    1.添加字段 df.loc[:,"d"]=4 a b c d ...另外还可以通过操作df.columns对象来批量修改字段名 df.columns = df.columns.str.strip() # 把columns当成series看待 df.columns = df.columns.map(lambda x:x)
  • JAVA8 函数式编程

    2019-10-30 18:09:02
    为了编写这类处理批量数据的并行类库,需要在语言层面上修改现有的 Java:增加 Lambda 表达式。 2.什么是函数式编程 在思考问题时,使用不可变值和函数,函数对一个值进行处理,映射成另一个值。 3.Lambda 表达式的...
  • 文章目录wrapper介绍:CURD接口Mapper CRUD接口Service CURD接口构造器方法常用方法修改指定值查找不为空查询为某列为空或等于某值/查询A列等于某值或B列等于某值根据时间区间查询批量删除存在||不存在查询指定列 ...
  • 在数据处理过程中,经常会出现对某列批量做某些操作,比如dataframe df要对列名为“values”做大于等于30设置为1,小于30设置为0操作,可以这样使用dataframe的apply函数来实现, 具体实现代码如下: def fun(x): ...
  • 分布式文件系统用来存储不经常更新的数据,他们也是大规模批量计算所以来的数据存储方式。 批处理架构(lambda架构)实现计数的方式:持续摄取数据的管道(flume)每小时创建一个文件,由调度程序安排批处理作业...
  • 其中,λ演算(lambda calculus)为该语言最重要的基础。 特性 函数是“第一等公民” 函数与其他数据类型一样,可以赋值给其他变量,也可以作为参数,也可以作为返回值。 不可变性 像闭包一样,传入的自由变量是不...
  • 老男孩python 四期

    2015-06-25 16:36:28
    14、lambda 函数使用 15、装饰器 16、项目实践:编写备份程序,具备常规备份、增量备份、差异备份功能 第四天 1、面向对象编程基础 2、类的基本语法 3、编写类练习小程序 4、类的初始化 5、类下面的函数使用 6、类的...
  • 实例287 使用事务批量删除生产单信息 实例288 在事务中的表级锁定 实例289 实现事务的并发控制 实例290 创建分布式事务 7.6 游标的应用 实例291 创建一个标准、只读和更新游标 使用292 利用sp_cursor_list查看游标...
  • 实例209 使用lambda表达式查找指定字符串 400 实例210 检查序列中是否包含指定元素 402 实例211 使用linq在一个循环中遍历多个数组 403 实例212 过滤文章中包含指定单词的句子 404 实例213 使用linq生成随机序列 406...
  • 函数实战与常用数据结构函数的两种类型函数的本质再分析函数地址切换切换功能ifelse配合地址筛选函数收费函数调用过程函数基本小结return小结位置参数与默认参数混合参数填充混合填充错误情况lambda匿名函数可变长...
  • 实例134 DataAdapter对象的Update方法批量更新(2) 实例135 使用DataAdapter填充多个表(利用关系) 实例136 强类型DataSet与SqlDataAdapter搭配查询 实例137 用TableAdapter创建DataTable定义及查询 实例138 ...
  • 实例063 匿名方法杀手——Lambda表达式 98 实例064 使用值类型进行线程同步 99 2.8 C#高级算法应用 101 实例065 高级算法应用——韩信点兵的算法 101 实例066 高级算法应用——加密和解密算法 102 实例067 高级算法...
  • 实例063 匿名方法杀手——Lambda表达式 98 实例064 使用值类型进行线程同步 99 2.8 C#高级算法应用 101 实例065 高级算法应用——韩信点兵的算法 101 实例066 高级算法应用——加密和解密算法 102 实例067 高级算法...
  • 实例063 匿名方法杀手——Lambda表达式 98 实例064 使用值类型进行线程同步 99 2.8 C#高级算法应用 101 实例065 高级算法应用——韩信点兵的算法 101 实例066 高级算法应用——加密和解密算法 102 实例067 高级算法...
  • 2.使用组归一化(GroupNormalization)代替批量归一化(batch_normalization)-解决当Batch_size过小导致的准确率下降。当batch_size小于16时,BN的error率 逐渐上升,train.py。 for i, layer in enumerate(model....
  • * 作者姓名 修改时间 版本号 描述 */ package com.cwj.backoffice.web.controller; import com.cwj.backoffice.web.User.Items; import com.cwj.backoffice.web.User.User; import ...
  • python-docx:读取,查询以及修改 Microsoft Word 2007/2008 docx 文件。 python-pptx:可用于创建和修改 ppt 文件的 Python 库。 relatorio:模板化 OpenDocument 文件。 unoconv:在 LibreOffice/OpenOffice ...
  • 纳税服务系统一(用户模块)【简单增删改查、日期组件、上传和修改头像】 纳税服务系统二(用户模块)【POI、用户唯一性校验】 纳税服务系统三(优化处理)【异常处理、抽取BaseAction】 纳税服务系统四(角色模块)...
  • 问题:例如在自己制作了成对的输入(input256×256 target 200×256)后,如何让输入图像和输出图像分辨率不一致,例如成对图像中:input的分辨率是256×256, output 和target都是200×256,需要修改哪里的参数。...

空空如也

空空如也

1 2
收藏数 27
精华内容 10
关键字:

lambda批量修改