1. 中缀

什么是中缀？
中缀就是形如 a + b的表达式
就是中缀表达式
中缀表达式两边是参数，中间是操作。
在编程语言中，基本类型支持所有的中缀表达式。
比如在Java中，可以写 1+2就是中缀表达。
当然，在Java中，除了基本类型，还有包装类型，得益于自动拆箱和自动装箱，包装类也可以写中缀表达式。
但是，作为普通的类就没有这样好的待遇了。

在scala中，因为在调用方法时，可以有限的省略点。
所以，scala可以实现普通类的中缀表达式。
举个例子：

class Middle(v: Int){
  val add = (x: Middle) => this.v + x.getV
}

我们创建了一个普通的Java类，有一个add函数。
同时有一个int的属性。
add函数有一参数，其类型是其本身，实现的操作是将调用本身的属性值与参数的属性值进行相加，然后返回。
在Java中，我们只能如下调用
对象.方法(参数)
不过，在scala中，可以用中缀表达式进行调用。
我们写这个类的伴生对象，然后在伴生对象中写main方法进行调用。

object Middle{

  def apply(x: Int) = new Middle(x)

  def main(args: Array[String]): Unit = {
    val xs = Middle(3)
    val xsw = Middle(4)
    println(xs add xsw)
    println(xs.add(xsw))
    println(Middle(8) add Middle(10))
    println(Middle(8).add(Middle(10)))
  }
}

在伴生类中，定义了apply方法，使得我们可以像调用无参方法一样得到类的对象。
然后我们可以用中缀表达式进行调用
其输出结果如下

2. 后缀

除了中缀表达式，还有后缀表达式
后缀表达式比较常见的写法形如取反等等
!true就是后缀表达式。
当然这个解释可能不太正确。
不过，在scala中后缀主要是表达一个方法调用的方式。
对于无参方法的调用，可以省略点
最终的结果就像shell命令一样。
对象 操作
举个例子
我们在1中的类中增加一个无参的方法

def getV = this.v

然后在伴生类中调用。

    println(Middle(19) getV)
    println(Middle(19).getV)

当然，要用后缀表达式进行调用无参方法，还需要导入一个scala实现的包
import scala.language.postfixOps
如果不导入这个包，编译会报错

Error:(19, 24) postfix operator getV needs to be enabled
by making the implicit value scala.language.postfixOps visible.
----
This can be achieved by adding the import clause 'import scala.language.postfixOps'
or by setting the compiler option -language:postfixOps.
See the Scaladoc for value scala.language.postfixOps for a discussion
why the feature needs to be explicitly enabled.
    println(Middle(19) getV)

其执行结果如下

@羲凡——只为了更好的活着

Scala 重命名hdfs文件

楼主使用scala2.11.12版本

1.主要的内容

fileSystem.rename(new Path(beforeFilePath), new Path(afterFilePath))

2.不啰嗦直接上代码

import java.net.URI

import org.apache.hadoop.conf.Configuration
import org.apache.hadoop.fs.{FileStatus, FileSystem, FileUtil, Path}

object RenameHdfsFile {
  def main(args: Array[String]): Unit = {
    
    val path = "/testdata/data/test"
    val sourceFile = "part-"
    renameFile(path, sourceFile)

    def renameFile(path: String, sourceFile: String): Unit = {
      val fileSystem = FileSystem.newInstance(URI.create(path), new Configuration())
      val fsArr: Array[FileStatus] = fileSystem.listStatus(new Path(path))
      val paths: Array[Path] = FileUtil.stat2Paths(fsArr)
      val arr = paths.filter(fileSystem.getFileStatus(_).isFile()).map(_.toString)
      println("===========亲，原文件如下==================")
      arr.foreach(println)

      println("===========亲，下面执行重命名函数===========")
      for (i <- 0.until(arr.length)) {
        val beforeFilePath = arr(i)
        val lastIndex = beforeFilePath.lastIndexOf("/") + 1
        val beforeFileName = beforeFilePath.substring(lastIndex)
        if (beforeFileName.contains(sourceFile)) {
          val num = beforeFilePath.substring(lastIndex + 6, lastIndex + 10).toInt
          val afterFilePath = beforeFilePath.substring(0, lastIndex) + s"#$num-r-00000"
          fileSystem.rename(new Path(beforeFilePath), new Path(afterFilePath))
          println(s"亲，$beforeFileName 被重命名为 #$num-r-00000 ")
        } else {
          println(s"亲，$beforeFileName 这个不是我想要的重命名的文件哦")
        }
      }
    }

    println("====================羲凡success======================")
  }
}

3.执行结果

===========亲，原文件如下==================
hdfs://ns/testdata/data/test/coverage
hdfs://ns/testdata/data/test/part-00000-e9d534da-d1e1-47fa-9d0e-ef9734d900d4-c000.csv
hdfs://ns/testdata/data/test/part-00001-e9d534da-d1e1-47fa-9d0e-ef9734d900d4-c000.csv
hdfs://ns/testdata/data/test/part-00002-e9d534da-d1e1-47fa-9d0e-ef9734d900d4-c000.csv
hdfs://ns/testdata/data/test/part-00003-e9d534da-d1e1-47fa-9d0e-ef9734d900d4-c000.csv
hdfs://ns/testdata/data/test/part-00004-e9d534da-d1e1-47fa-9d0e-ef9734d900d4-c000.csv
===========亲，下面执行重命名函数===========
亲，coverage 这个不是我想要的重命名的文件哦
亲，part-00000-e9d534da-d1e1-47fa-9d0e-ef9734d900d4-c000.csv 被重命名为 #0-r-00000 
亲，part-00001-e9d534da-d1e1-47fa-9d0e-ef9734d900d4-c000.csv 被重命名为 #1-r-00000 
亲，part-00002-e9d534da-d1e1-47fa-9d0e-ef9734d900d4-c000.csv 被重命名为 #2-r-00000 
亲，part-00003-e9d534da-d1e1-47fa-9d0e-ef9734d900d4-c000.csv 被重命名为 #3-r-00000 
亲，part-00004-e9d534da-d1e1-47fa-9d0e-ef9734d900d4-c000.csv 被重命名为 #4-r-00000 
====================羲凡success============

====================================================================
@羲凡——只为了更好的活着

若对博客中有任何问题，欢迎留言交流

scala中的概述

scala是完全面向对象的编程语言，即在scala中一切皆对象。我们的java只是使用了面向对象的编程思想，还不够完全面向对象。如在java中的基本数据类型就不是对象，而在scala中的一切数据类型【数值类型(AnyVal），应用类型（AnyRef）】都是对象，java不够面向对象还体现在：使用类的静态属性时是不能直接使用对象去调用的，而是要使用类名进行调用。

作为scala之父的马丁·奥德斯基是编译器及编程的狂热爱好者，长时间的编程之后，希望发明一种语言，能够让写程序这样的基础工作变得高效，简单。于是scala就诞生了。

我们之所以学习scala主要是因为spark的快速发展，市场对spark技术的需求大，而spark又是由scala进行编写，因此可以这么说，是spark的发展带动了scala的发展。

scala的后缀名与java不同，使用的是.scala。scala是完全面向对象和函数编程语言，scala的文件名可以与我们的声明的scala名称不同，但是在运行的时候还是要使用我们声明的scala名， scala文件编译后生成的字节码文件，就可以在jvm虚拟机上进行识别（jvm会将字节码文件解释成当前操作系统所能识别的文件），然后运行。

在声明创建一个对象时，我们使用object关键字来进行修饰，再使用def关键字来修饰创建一个方法，之后就可以在方法体里面写上我们的代码语句。 scala中不使用static来修饰方法，主要还是考虑到为了让我们的写出来的的代码是完全面向对象的，就不使用类名可以调用的static静态方法。

 从上图我们可以看到，与java不同的是scala生成的文件有两个，一个是我们熟悉的字节码文件，另外一个是带有$（dollar美元）符号的文件,想要看源码的可以去下载java 反编译软件进行查看

Java Decompiler

提取码: pux2

使用下载好的java 反编译软件我们可以看到生成的Test01.class文件里面的main方法调用的是Test01$.class的main方法，没有做直接的打印，只是一个伴生类（伴生类可以访问伴生对象内的方法）。因为我们的载java 反编译软件还不够完善，没有显示完全，用起来还是可以接受的，大家有啥好用的软件请不吝在评论区推荐一波。

 在含有$符号的字节码文件里面我们可以看到该类在类体里面创建了一个 MODULE$对象，导入了scala中Predef包，再去调用该包下的打印结合 MODULE$对象来调用打印输出方法println/print/printf都可以，主要是看自己在写打印输出语句时使用的是哪个。所以含有$符号的字节码文件我们在运行程序时的真正对象在的文件，MODULE$为真正的对象（在含有$符号的类中创建），含有$符号的类为伴生对象（我们使用object关键字来修饰并创建的对象）的所属类（含有$符号的类）。

scala中的变量和常量

• 变量：就是在程序执行的过程中，其值可以改变的。
• 常量：就是在程序执行的过程中，其值不可以改变。

• 变量的声明：var  变量名[:变量类型]=初始值----var,variable变量
• 常量的声明：val  常量名[:常量类型]=初始值 ---val，value常量

从上面的格式我们可以看到，在scala中变量和常量的声明可以先不用直接给它数据类型（编译器会给我们自动推导），我们只需要写出变量或常量并给它一个初始化值，就可以使用这个数据。看起来scala和一些弱数据类型很像，直接声明一个变量赋个值就可以用，但scala的类型确定后是不能更改的，如我们给一个int型的变量赋一个String类型的值，就会出错。

 提示需要传入的类型为int型的值，而我们传入的是String类型的值。所以scala是一个强数据类型的语言。scala和java不同还体现在，声明变量的时候必须要有初始值，即使是全局变量也需要有初始值。如果不给初始值就会报错------提示：错误的值声明。

在java中只有局部变量的在声明同时必须要给一个初始化的值，成员变量可以不用在声明的同时给该变量赋值，jvm虚拟机会自动给我们的java全局变量赋一个默认的初始化的值。

 相信大家也发现了，在声明变量和常量时，变量的声明var明显要比常量的声明暗淡一些。主要是因为在我们的scala中推荐能够用常量的地方要尽量少用变量。那如果我们要对一个数据进行修改怎么办呢？我们可以将数据声明成引用类型或者是集合类型就可以修改它相应的属性值。下面我们使用代码来直观的看一下：

 首先我们创建一个有name和age的学生类，并实例化一个学生张三

  在之后的某一天张三说同学都在拿他的名字取笑他，他想要换名字，于是我们可以将张三的名字进行如下修改

 但是我们不能使用new来进行修改，因为new是重新创建一个student对象，就不再是张三了，生成的是另外一个人。

 scala中的标识符

scala标识符的命名规范和java类似，在scala中哪怕是一个简单的操作符都可以是方法。scala的标识符可以是由操作符（+-*/#?等）组成，但是需要注意的是：如果是包含有操作符，那么就必须全部是由操作符组成，不能有除了操作符外的内容，比方说英文数字等。

（操作符：用我来作为标识符，就在这个标识符里面全用我吧，不要去用其他的符号了。）

 除了上面标识符的命名方式和java不同外，scala也有自己的关键字（保留字），例如创建伴生对象的object，隐式声明implicit，模式匹配match，声明常量val，声明变量var等。是不建议使用关键字来做标识符的，因为每个关键字都有它自己的作用，我们将标识符命名成关键字会与本来存在的关键字冲突，如果非得使用关键字来做标识符的话我们可以使用反引号``来将我们声明成关键字的标识符括起来，使之成为标识符，而不是关键字，不会冲突。

其他的命名方式就和java一样了，不能以数字开头即可，英文，下划线都可以作为开头。

 scala中的输出和输入

scala的打印输出语句和java差不多，但多了个字符串模板（插值字符串），可以通过$获取变量值。使用   s"${ }"-----使打印输出更加方便

我们在使用输出语句时，可以使用*号将字符串复制多次并拼接输出。 

 我们还可以使用三引号来进行字符串的输出，使之保持多行字符串原来的格式。这种情况一般是在我们进行编写SQL语句时会用到，基本格式：s"""    """如下：

 在scala的输入中我们先来认识基本的输入类，可以直接使用StdIn类包下的方法读取键盘输入

 scala中的数据类型 

scala中的一切数据类型都是对象，其超类为Any（java的超类为Object）在scala中只有两种数据类型：

一种是值类型（AnyVal）-any  value，另外一种是引用数据类型（AnyRef）-any reference

• 数值类型：Double，Float，Long，Int，Short，Byte，Char，Boolean，StringOps，Unit
• 引用类型：scala中的其他类，所有java的类，scala的集合类

 在认识了scala中有哪些数据类型后，我们就可以使用它们来声明我们的数据。在scala中也有隐式转换和强制转换。

• 自动转换（隐式转换）：数据类型依旧遵循低精度向高精度值类型自动转换。
• 强制转换：高精度类型向低精度类型转换，（与java一样）会有数据的缺失或溢出。scala中的强制类型转换的格式是在高精度的后面加上.to低精度数据类型()

如上在将双精度浮点型（如果不在浮点型后面加上f，默认为双精度浮点型）强制转换成整型时，数据缺失，本来66.6的数值变成了66。低精度数据类型和高精度数据类型混合运算时，依照自动类型提升原则，系统会手动将数据转换成精度大的数据类型，然后再运算。

 我们可以不用给数据指定类型，让编译器来自动识别类型。

 scala中的数据类型之间的继承及存在的因式转换关系，如下图：

 从上图我们可以看到在值类型里面除了与我们java中相似的基本数据类型的装箱类型（int数据类型在java中的装箱类是Integer型），还有两个数据类型：StringOps类型和Unit类型。

• 为了和java兼容StringOps其实就是java中的String引用类型的增强和优化。
• Unit对应java中的void，用于方法返回值的位置，表示方法没有返回值，只有一个实例值（）

除了上面图中的数据类型外，还有两个数据需要我们认识一下

• Null:返回值（实例值）为null，是所有引用类型的子类。和java一样，一般用于对象为null时。
• Nothing:是所有数据类型的子类，主要用于在一个函数没有明确返回值时使用，这样就可以把抛出的返回值，返回给任何的变量类型。并且会直接抛异常，不会接着去运行。

Null的使用 

 Nothing的使用

可以用来直接抛异常，程序不再执行

 通过前面的小知识我们也知道了在scala中每一个表达式都有一个值，我们可以将我们的方法（表达式）传递赋值给另外一个数据，并打印出相应的返回值。

 Unit的使用

有问题可以评论区一起交流✿✿ヽ(°▽°)ノ✿