Scala01

1.什么是Scala

Scala是一种多范式的编程语言，其设计的初衷是要集成面向对象编程和函数式编程的各种特性。Scala运行于Java平台（Java虚拟机），并兼容现有的Java程序。

优点：
1.优雅，直接影响用户的体验
2.速度快，Scala语言表达能力强，一行代码抵得上java多行；Scala是静态编译的。
3.能融合到hadoop生态圈；

2.在IDEA下创建Scala项目

下载并安装Scala在Windows
1.下载Scala2.12.8.zip
2.解压到任意目录
3.添加环境变量
4.测试（出现如下结果，成功）

在创建项目前需要在IDEA中安装Scala插件
1.使用本地Scala





导入成功！

2.使用指定版本的Scala

创建一个Scala项目





点击运行测试，此时，第一个Scala项目运行成功。

传递参数


运行成功！

3.使用Scala做WordCount

4.数据类型

Any(类似于Java中的Object)
Anyval
基本类型：Byte,Int,Char,Double,Flat,Int,Long,Short
布尔类型：Boolean
Unit:表示无值，和其他语言中void等同，作为不返回任何结果的方法的结果类型
AnyRef
Scalaclasses
javaclasses

变量的定义
var和val用于定义变量(编译器自动推测数据的类型)
var | val 变量名: 数据类型 = 数值
var | val 变量名 = 数值

var name = “zhangsan” //var修饰的变量值可以改变
var name2: String = “xiaoqiang”

val age = 18 //val修饰的变量值不能改变，类似于Java中被final修饰的变量
val age2: Int = 19

var a: Unit //错误做法

Unit数据类型相当于Java中的void，但是在Scala中的表现形式为()
在代码块中的最后一行代码，为代码块的返回值。

val r = if(i < 8) i //else没有写，编译器会自动推测出你什么都没有返回就是Unit
val r1 = if(i<8) i else "haah"

循环语句/yield关键字
在scala中有for循环和while循环，使用for循环比较多
使用for循环取出数组中的元素

使用角标的方法取出数组中的元素


0 to 5 //左闭右闭区间
0 until 5 //左闭右开区间

将数组中的偶数输出

双层for循环

yield关键字：会生成一个新的数组并且返回。

操作符重载成方法

5.方法定义

def 方法名(参数1: 类型1, 参数2: 类型2):类型3 = {方法体}

定义一个不传递任何参数的方法


在定义函数的时候没有带（）那么在调用方法的时候一定不能带有（）。

6.方法可转换成函数

经方法转换成函数：方法名 _

定义匿名函数

7.函数的定义

第一种函数定义方式：

第二种函数定义方式：


函数可以作为参数传递到另一个方法里面。
传值调用与传名调用案例分析

  var money = 100
  def huaQian():Unit = {
    money = money - 5;
  }
  def shuQian() = {
    huaQian()
    money
  }
  //x: => Int 表示是一个方法的签名=>没有参数，返回参数，返回值为Int类型的函数
  def printByName(x: => Int): Unit ={
    for(b<- 0 to 3){
      println(s"每次都算算还剩：${x}元")
    }
  }
  def printByValue(x: Int) = {
    for(a <- 0 until 3){
      println(s"测试：${x}元")
    }
  }
  def main(args: Array[String]): Unit = {
    //传名调用
    printByName(shuQian())
    //传值调用printByValue参数为一个具体的数值
    //printByValue(shuQian())
  }

  //add方法拥有2个Int类型的参数，返回值为2个Int的和
  def add(a:Int, b:Int) = {
    a + b
  }
  //add2方法拥有3个参数，第一个参数是一个函数，第二个，第三个为Int类型的参数
  //第一个参数：是拥有2个Int类型的参数，返回值为Int类型的函数
  def add2(f:(Int, Int) => Int, a:Int, b:Int) = {
    f(a, b)
  }
  def add3(a:Int => Int, b:Int) = {
    a(b) + b
  }
  def main(args: Array[String]): Unit = {
    val r3 = add3((a: Int) => a - 1,5)
    println(r3)
    val r1 = add(1, 2+3)
    println(r1)
    val r2 = add2(add, 7, 9)
    println(r2)
  }

Java实现对操作符的封装

public interface IOperate {
    public Object caoZuo(Integer ele);
}

public class MyList {

    private ArrayList<Integer> list;
    private ArrayList<Integer> resultList;


    public MyList(ArrayList<Integer> list){
        this.list = list;
    }

    public ArrayList<Integer> map(IOperate op){

        resultList = new ArrayList<>();

        for(Integer l : list){
            resultList.add((Integer) op.caoZuo(l));
        }

        return resultList;
    }

}

    public static void main(String[] args){
        
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        
        MyList myList = new MyList(list);
        
        ArrayList<Integer> rlist = myList.map(new IOperate(){

            @Override
            public Object caoZuo(Integer ele) {
                return ele * 10;
            }
        });

        rlist.forEach(r -> System.out.println(r));
        for(Integer r : rlist){
            System.out.println("r = " + r);
        }
    }
}