0701-Scala函数式编程

最新推荐文章于 2022-07-31 13:30:36 发布
最新推荐文章于 2022-07-31 13:30:36 发布
阅读量611 收藏
点赞数
分类专栏： 07 Spark之基础篇 -Scala 文章标签： scala java lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35199832/article/details/103562181
版权

0701-Scala函数式编程

第一章 函数式编程

1.1 问题引入

有数组numberList = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]，编写程序完成以下目标：
- 1.1 将numberList中的每个元素加1得到一个新的数组
- 1.2 将numberList中的每个元素乘2得到一个新的数组
- 1.3 将numberList中的每个元素模3得到一个新的数组

1.2 实现

# 1.1 将numberList中的每个元素加1得到一个新的数组
def func1(numberList){
	newList = []
	for num in numberList:
    	newList.append(num + 1)
}
# 1.2 将numberList中的每个元素乘2得到一个新的数组
def func2(numberList){
	newList = []
	for num in numberList:
	    newList.append(num * 2)
}
# 1.3 将numberList中的每个元素模3得到一个新的数组
def func3(numberList){
	newList = []
	for num in numberList:
	    newList.append(num % 3)
}
# 调用函数
# 1.1 将numberList中的每个元素加1得到一个新的数组
func1(numberList)

# 1.2 将numberList中的每个元素乘2得到一个新的数组
func2(numberList)

# 1.3 将numberList中的每个元素模3得到一个新的数组
func3(numberList)

1.3 使用函数式编程进行改进

# 高阶函数`map`
# 该函数接受一个函数和一个数组作为输入，函数体中将这个函数作用于数组的每个元素然后作为返回值返回
def map(mappingFuction, numberList):
    newList = []
    for num in numberList:
        newList.append(mappingFuction(num))

# 调用函数
# 1.1 将numberList中的每个元素加1得到一个新的数组
map(lambda x: x + 1, numberList)

# 1.2 将numberList中的每个元素乘2得到一个新的数组
map(lambda x: x * 2, numberList)

# 1.3 将numberList中的每个元素模3得到一个新的数组
map(lambda x: x % 3, numberList)

1.4 什么是函数式编程

第二章 Scala函数式编程基础语法

2.1 函数声明

函数与方法:
java中的方法和Scala中的函数都可以进行功能的封装，但是方法必须和类型（类）绑定，但是函数不需要

def 函数名（参数名[：参数类型]…）[: 返回值类型 = ] {函数体}
  1. 无参, 无返回值
        // 无参 ，无返回值
        def test1(): Unit = {
            println("无参 ，无返回值")
        }
  1. 有参, 无返回值
        // 有参， 无返回值
        // Scala中没有重载的概念，如果在同一个作用域中，函数不能重名
        def test2(s: String): Unit = {
            println(s)
        }
  1. 有参, 有返回值
        // 有参，有返回值
        def test3(s: String): String = {
            return s + "--"
        }
  1. 无参, 有返回值
        // 无参，有返回值
        def test4(): String = {
            return "Hello World"
        }

2.2 自动推断, 能省则省

  1. 如果函数声明时，明确无返回值 Unit，那么即使函数体中有return也不起作用
        def test1(): Unit = {
            return "zhangsan"
        }
  1. 如果将函数体的最后一行代码进行返回，那么return关键字可以省略
        // 2.如果将函数体的最后一行代码进行返回，那么return关键字可以省略
        def test2(): String = {
            "zhangsan"
        }
  1. 如果可以根据函数体的最后一行代码推断出类型，那么函数的返回值类型可以省略
        // 3.如果可以根据函数体的最后一行代码推断出类型，那么函数的返回值类型可以省略
        def test3() = {
            "zhangsan"
        }
  1. 如果整个函数体只有一行代码，那么大括号可以省略
        def test4() = "zhangsan"
  1. 如果函数声明中没有参数列表，那么小括号可以省略
        def test5 = "zhangsan"

如果函数声明时省略小括号，那么调用函数时不能增加括号

  1. 如果明确函数没有返回值，那么 = 可以省略，最后一行代码也不会被返回
        def test6() {
            "zhangsan"
        }

如果函数没有参数列表，可以省略小括号，调用时一定不能加
如果函数没有参数列表，但是没有省略小括号，调用时 可加可不加

2.3 可变参数

        // TODO 可变参数
        def test1(name: String*) = {
            print(name)
        }

java中如何实现可变参数 String...

    public static void printMax( double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }
 
        double result = numbers[0];
 
        for (int i = 1; i <  numbers.length; i++){
            if (numbers[i] >  result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }

2.4 默认参数

        def test2(name: String, age: Int = 20): Unit = {
            print(name, age)
        }
        test2("zhangsan")

java中实现默认参数: 方法重载

    public static void main(String[] args) throws ParseException {
        // 日期格式化
        Date d = parse("2019-12-16 12:00:00", "yyyy-MM-dd HH:mm:ss");
    }
    public static Date parse(String date, String format) throws ParseException {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
        return simpleDateFormat.parse(date);
    }

// 将format设为默认参数

    public static void main(String[] args) throws ParseException {
        // 日期格式化
        //Date d = parse("2019-12-16 12:00:00", "yyyy-MM-dd HH:mm:ss");

        // 将format设为默认参数
        Date parse = parse("2019-12-16 12:00:00");
    }
    public static Date parse(String date) throws ParseException {
        return parse(date, "yyyy-MM-dd HH:mm:ss");
    }
    private static Date parse(String date, String format) throws ParseException {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
        return simpleDateFormat.parse(date);
    }

第三章 Scala高阶函数

3.1 函数作为参数

将函数作为参数传递给另外一个函数，需要采用特殊的声明方式
函数名:参数列表=>返回值类型 可以理解为 变量名 : 变量类型

  1. 定义函数, 指定函数作为参数
		// 高阶函数, 函数做参数, f是形参
        def f4(f: (Int) => Int) = {
            f(4) + 10
        }
        // 普通函数
        def f5(i: Int) = {
            i * 3
        }
  1. 调用函数
        // 调用f4, 将f5作为参数传递给f4, f5 是实参
        val result: Int = f4(f5)
        println(result)

3.2 匿名函数

3.1 的写法太麻烦, 还需要再重新定义 f5, 使用匿名函数, 不必再定义f5

		// 定义高阶函数
        def f6(f: (Int) => Int): Int = {
            f(4) + 10
        }
        // 调用
        val result2: Int = f6(x => x * 3)
        println(result2)

3.3 函数作为返回值

        def f() = {
            println("function")
        }
        // TODO 函数作返回值
        def f0() = {
            // 返回函数本身，而不是返回函数的执行结果，但是，因为函数f是无参的，所以就算这里不加括号f()也是在调用f执行
            // f
            // 直接返回有问题，加特殊符号
            f _
        }
        f0()()

3.4 闭包

        // TODO 闭包
        // 一个函数在实现时，将外部变量引入到函数的内容，改 变了这个变量的生命周期，称之为闭包
        def f1(i: Int) = {
            def f2(j: Int) = {
                i * j
            }
            f2 _
        }
        f1(2)(3)

3.5 柯里化

        def f3(i: Int)(j: Int) = {
            i * j
        }
        f3(2)(3)

函数编程中，接受多个参数的函数都可以转化为接受单个参数的函数，这个转化过程就叫柯里化，柯里化就是证明了函数只需要一个参数而已。其实我们刚才的学习过程中，已经涉及到了柯里化操作，所以这也印证了，柯里化就是以函数为主体这种思想发展的必然产生的结果。

  1. 柯里化实例
		def mul(x: Int, y: Int) = x * y
		println(mul(10, 10))
		
		def mulCurry(x: Int) = (y: Int) => x * y
		println(mulCurry(10)(9))
		
		def mulCurry2(x: Int)(y:Int) = x * y
		println(mulCurry2(10)(8))

3.6 匿名函数的省略

        // TODO 省略的过程
        def f7(f: (Int, Int) => Int) = {
            f(10, 10)
        }
        // 原型
        f7((x: Int, y: Int) => {x + y})
        // 省略参数类型，自动推断
        f7((x, y) => {x + y})
        // 函数体只有一行代码，省略大括号
        f7((x, y) => x + y)
        // 参数只被使用了一次，用_代替
        f7(_ + _)

        f8((i: Int )=> {println(i)})
        f8((i)=> {println(i)})
        f8((i)=> println(i))
        f8((println(_)))
        f8(println

第四章 Java中的函数式编程

4.1 问题引入

    List<Employee> employees = Arrays.asList(
            new Employee("zhangsan",38,2999),
            new Employee("lisisddd",28,2399),
            new Employee("wangwuid",48,4599),
            new Employee("zhansdsd",58,6599),
            new Employee("zsdngsan",28,2399),
            new Employee("sddngsan",18,3199)
    );

    // 筛选年龄大于35岁的所有员工
    public List<Employee> filterByAge(List<Employee> employees) {
        List<Employee> emp = new ArrayList<>();
        for (Employee employee : employees) {
            if (employee.getAge() > 35) {
                emp.add(employee);
            }
        }
        return emp;
    }

    // 筛选年龄工资大于3000的所有员工
    public List<Employee> filterBySalary(List<Employee> employees) {
        List<Employee> emp = new ArrayList<>();
        for (Employee employee : employees) {
            if (employee.getSalary() > 3000) {
                emp.add(employee);
            }
        }
        return emp;
    }

    @Test
    public void test1() {
        // 按照年龄过滤
        List<Employee> employees = filterByAge(this.employees);
        for (Employee employee : employees) {
            System.out.println(employee);
        }

        // 按照工资过滤
        List<Employee> employees2 = filterBySalary(this.employees);
        for (Employee employee : employees2) {
            System.out.println(employee);
        }
    }

4.2 使用策略设计模式进行优化

4.2.1 定义策略接口

package com.lz.java8.lambda;

public interface MyFilter {
    public boolean test(Employee employee);
}

4.2.2 定义不同的策略

  1. 基于年龄过滤的策略
package com.lz.java8.lambda;

/**
 * @ClassName MyFilterByAge
 * @Description: TODO
 * @Author MAlone
 * @Date 2019/12/16
 * @Version V1.0
 **/
public class MyFilterByAge implements MyFilter {
    @Override
    public boolean test(Employee employee) {
        return employee.getAge() > 35;
    }
}
  1. 基于工资过滤的策略
package com.lz.java8.lambda;

/**
 * @ClassName MyFilterBySalary
 * @Description: TODO
 * @Author MAlone
 * @Date 2019/12/16
 * @Version V1.0
 **/
public class MyFilterBySalary implements MyFilter {
    @Override
    public boolean test(Employee employee) {
        return employee.getSalary() > 3000;
    }
}

4.2.3 设计基于策略的业务逻辑

    // 优化方式一: 策略设计模式
    public List<Employee> filterEmployee(List<Employee> employees, MyFilter filter) {
        List<Employee> emp = new ArrayList<>();
        for (Employee employee : employees) {
            if (filter.test(employee)) {
                emp.add(employee);
            }
        }
        return emp;
    }

4.2.4 根据具体的策略实现业务

    public void test2() {
        // 按照年龄过滤
        List<Employee> employees = filterEmployee(this.employees, new MyFilterByAge());
        // 按照工资过滤
        List<Employee> employees1 = filterEmployee(this.employees, new MyFilterBySalary());
    }

4.3 使用匿名内部类进行优化

解决策略设计模式,针对每种策略都要定义一个实现接口的策略类的问题

package com.lz.java8.lambda;

public interface MyFilter {
    public boolean test(Employee employee);
}


    public List<Employee> filterEmployee(List<Employee> employees, MyFilter filter) {
        List<Employee> emp = new ArrayList<>();
        for (Employee employee : employees) {
            if (filter.test(employee)) {
                emp.add(employee);
            }
        }
        return emp;
    }

    // 优化方式二: 匿名内部类
    public void test3() {
        // 按照年龄过滤
        List<Employee> employees = filterEmployee(this.employees, new MyFilter() {
            @Override
            public boolean test(Employee employee) {
                return employee.getAge() > 35;
            }
        });

        // 按照工资过滤
        List<Employee> employees1 = filterEmployee(this.employees, new MyFilter() {
            @Override
            public boolean test(Employee employee) {
                return employee.getSalary() > 3000;
            }
        });
    }

4.4 使用lambda表达式

package com.lz.java8.lambda;

public interface MyFilter {
    public boolean test(Employee employee);
}


    public List<Employee> filterEmployee(List<Employee> employees, MyFilter filter) {
        List<Employee> emp = new ArrayList<>();
        for (Employee employee : employees) {
            if (filter.test(employee)) {
                emp.add(employee);
            }
        }
        return emp;
    }

    // 优化方式三: lambda 表达式
    @Test
    public void test4() {
        // 按照年龄过滤
        filterEmployee(this.employees, (e) -> e.getAge() > 35);
        // 按照工资过滤
        filterEmployee(this.employees, (e) -> e.getSalary() > 3000);
    }

4.5 java8 内置的四大核心函数式接口

不用自己再去定义函数式接口,
即不用自己定义 MyFilter

4.5.1 Consumer : void accept(T t)

4.5.2 Supplier : T get()

4.5.3 Function< T, R > : R apply(T t)

4.5.4 Predicate : boolean test(T t)

4.6 优化方式四: 内置函数式接口

    // 优化方式四: 内置函数式接口
    public List<Employee> filterEmployee2(List<Employee> employees, Predicate<Employee> predicate) {
        ArrayList<Employee> emp = new ArrayList<>();
        for (Employee employee : employees) {
            if (predicate.test(employee)) {
                emp.add(employee);
            }
        }
        return emp;
    }

    public void test5() {
        // 按照年龄过滤
        filterEmployee2(this.employees, (e) -> e.getAge() > 35);
        // 按照工资过滤
        filterEmployee2(this.employees, (e) -> e.getSalary() > 3000);
    }
YanLzh_MAlone
关注
专栏目录
Scala考试题1
08-08
1.var，val和def三个关键字之间的区别 2.trait（特质）和abstract class（抽象类）的区别 3.object和class的区别 4.c
scala习题精选100道
weixin_30487317的博客
05-05 2456
1、**[primary]**关于和Scala进行交互的基本方式REPL说法错误的是?C A、R 读取（read）B、E 求值（evaluate）C、P 解析（Parse）D、L 循环（Loop） 2、**[primary]**不属于Scala7种数值类型的是?D A、CharB、IntC、FloatD、LongLong ...
Scala编程题
m0_55834564的博客
05-15 2722
1.题目:利用条件运算符的嵌套来完成此题: 学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用c表示。 object GradeTest { def main(args: Array[String]): Unit = { var a = 59.0 if(a<0||a>100){ println("对不起，您提供的考试成绩不合法") }else if(a>=90){ println("该考生的考试成绩等.
《Spark编程基础及项目实践》试卷及答案2套.pdf
04-04
《Spark编程基础及项目实践》试卷及答案2套.pdf《Spark编程基础及项目实践》试卷及答案2套.pdf《Spark编程基础及项目实践》试卷及答案2套.pdf《Spark编程基础及项目实践》试卷及答案2套.pdf《Spark编程基础及项目实践》试卷及答案2套.pdf《Spark编程基础及项目实践》试卷及答案2套.pdf
Scala100道练习题答案
热门推荐
Maynor的博客
04-11 1万+
package Test.E1 import scala.collection.mutable.Set import scala.collection.mutable.Map import scala.collection.immutable.List import scala.io.StdIn import scala.util.control.Breaks import scala.collection.mutable.ArrayBuffer import scala.util.Random /**
Scala函数式编程
03-18
　这本书所讲授的，正是基于 Scala 的函数式编程基础。基于 Scheme、Haskell 等老牌函数式语言的传统教材的问题在于，相关语言的语法和思维方式与读者现有的知识体系迥异，容易造成较为陡峭的入门门槛。此外，由于...
Scala函数式编程.pdf
05-18
函数式编程（FP）是一种...《Scala函数式编程》是针对希望学习FP并将它应用于日常编码中的程序员而写的，内容包括：函数式编程的概念；函数式编程相关的各种“为什么”和“怎么做”；如何编写多核程序；练习和检测。
Scala函数式编程专题--scala基础语法介绍
08-18
Scala 函数式编程专题 -- Scala 基础语法介绍 本文主要介绍 Scala 基础语法的相关知识点，旨在帮助读者更好地理解和学习 Scala 编程语言。 一、Scala 语言简介 Scala 是一种现代化的、多范式的编程语言，运行于 ...
转：scala常见笔试题
11-18 466
scala最近几年很火，主要是因为其在大数据领域的应用。 下面这些面试题，基本上是scala函数式编程的精髓。 Q1 var，val和def三个关键字之间的区别？ 答：var是变量声明关键字，类似于Java中的变量，变量值可以更改，但是变量类型不能更改。 val常量声明关键字。 def 关键字用于创建方法（注意方法和函数的区别） 还有一个lazy val（惰性val）声明，意思是当需要计算时才使用，避免重复计算 代码示例： var x = 3 // x是I..
scala习题精选100道附带解析
11-10
scala习题精选100道,每道都有人工分析，技术点原理，不只是简单的答案
Scala练习题+答案
holiday0520的博客
07-31 1784
Scala练习题和参考答案
大数据编程语言scala讲座
12-26
在大数据库发展的今天，scala是java语言的新的发展，可以理解为java++,学习难度又不是很大，并且又适应新的大数据编程的需要。scala语言本身也可以和java语言一起互调，所以，是我们必须学习的语言。 本讲座以电子书为教基准，一章节一章节的按步就班的讲述，很适合刚入学scala的人，对有经验的scala编程者也有很大的帮助！
Scala 40道基础练习题及答案
海边微风落
12-03 8582
Scala 40道基础练习题及答案 set集合(1-10) 1、定义一个不可变set集合a，保存以下元素：10,20,30,10,50,40 var a = Set(10,20,30,10,50,40) 2、获取a集合的大小 Println(a.size) 3、遍历a集合 a.foreach(i => println(i)) 4、a集合删除元素50 println(a - 50) 5、a集合拼接set集合Set(60,80,90) println(a ++ Set(60,80,90)) 6、
Scala数组
lm709409753的专栏
12-26 1098
在Scala中，数组是一种特殊的collection。一方面，Scala数组与Java数组是一一对应的。即Scala数组Array[Int]可看作Java的Int[]，Array[Double]可看作Java的double[]，以及Array[String]可看作Java的String[]。但Scala数组比Java数组提供了更多内容。首先，Scala数组是一种泛型。即可以定义一个Array[T]，
scala的练习题
echo的博客
04-20 4262
 //创建一个List    val lst0 = List(1,7,9,8,0,3,5,4,6,2)    //将lst0中每个元素乘以10后生成一个新的集合   解析 ：       lst0.map(_*10)    //将lst0中的偶数取出来生成一个新的集合   解析 ：      lst0.filter(_%2==0)    //将lst0排序后生成一个新的集合    解析 ：    ...
scala复习（面试题）
leofionn的博客
03-06 1万+
1.Scala怎样声明变量与常量？var val2.Scala数据类型有哪些？数据类型描述Byte8位有符号补码整数。数值区间为 -128 到 127Short16位有符号补码整数。数值区间为 -32768 到 32767Int32位有符号补码整数。数值区间为 -2147483648 到 2147483647Long64位有符号补码整数。数值区间为 -9223372036854775808 到 9...
scala常见笔试题(囊括了scala的精髓)
zhaolimin6666的专栏
03-19 4706
scala最近几年很火，主要是因为其在大数据领域的应用。 下面这些面试题，基本上是scala函数式编程的精髓。 Q1 var，val和def三个关键字之间的区别？ 答：var是变量声明关键字，类似于Java中的变量，变量值可以更改，但是变量类型不能更改。 val常量声明关键字。 def 关键字用于创建方法（注意方法和函数的区别） 还有一个lazy val（惰性val）声明，意思...
Scala函数式编程：集合与函数详解
Scala函数式编程专题深入探讨了Scala语言中的集合和函数，这些是实现高效、简洁编程的关键组成部分。首先，让我们回顾一下Scala的基础，它是结合了面向对象和函数式编程的多范式语言，其中函数被设计为独立的实体，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值