scala当中的文件操作、网络请求和隐式转换

文件操作和网络请求

读取文件当中每一行的数据

def main(args: Array[String]): Unit = {
  //注意文件的编码格式，如果编码格式不对，那么读取报错
  val file: BufferedSource = Source.fromFile("F:\\scala与spark课件资料教案\\3、scala第三天\\files\\file.txt","GBK");
  val lines: Iterator[String] = file.getLines()
 for(line <- lines){
   println(line)
 }
  //注意关闭文件
  file.close()
}

如果要将文件内容转数组，直接调用toArray即可

读取词法单元和数字

如果想将以某个字符或某个正则表达式分开的字符成组读取，可以这么做：

def main(args: Array[String]): Unit = {
  val file: BufferedSource = Source.fromFile("F:\\scala与spark课件资料教案\\3、scala第三天\\files\\file2.txt","GBK");
  val split: Array[String] = file.mkString.split(" ")
  println(split.mkString("\t"))
  file.close()
}

读取网络资源、文件写入、控制台操作

读取网络资源

def main(args: Array[String]): Unit = {
  val source: BufferedSource = Source.fromURL("http://www.baidu.com")
  val string: String = source.mkString

  println(string)
  source.close()
}

文件写入操作

def main(args: Array[String]): Unit = {
  val writer = new PrintWriter("F:\\scala与spark课件资料教案\\3、scala第三天\\files\\printWriter.txt")
  for(i <- 1 to 100){
    writer.println(i)
    writer.flush()
  }
  writer.close()
}
 

控制台交互操作

def main(args: Array[String]): Unit = {
  //控制台交互--老API
  print("请输入内容:")
  val consoleLine1 = Console.readLine()
  println("刚才输入的内容是:" + consoleLine1)

  //控制台交互--新API
  print("请输入内容(新API):")
  val consoleLine2 = StdIn.readLine()
  println("刚才输入的内容是:" + consoleLine2)
}

scala当中的序列化

@SerialVersionUID(1L)
class Person extends Serializable{
  override def toString = name + "," + age

  val name = "Nick"
  val age = 20

}

object PersonMain extends App{
  override def main(args: Array[String]): Unit = {

    import java.io.{FileOutputStream, FileInputStream, ObjectOutputStream, ObjectInputStream}
    val nick = new Person
    val out = new ObjectOutputStream(new FileOutputStream("Nick.obj"))
    out.writeObject(nick)
    out.close()

    val in = new ObjectInputStream(new FileInputStream("Nick.obj"))
    val saveNick = in.readObject()
    in.close()
    println(saveNick)
  }
}

scala当中的正则表达式

我们可以通过正则表达式匹配一个句子中所有符合匹配的内容，并输出：

def main(args: Array[String]): Unit = {
  import scala.util.matching.Regex
  val pattern1 = new Regex("(S|s)cala")
  val pattern2 = "(S|s)cala".r
  val str = "Scala is scalable and cool"
  println((pattern2 findAllIn str).mkString(","))

}

隐式转换和隐式参数

隐式转换

Scala提供的隐式转换和隐式参数功能，是非常有特色的功能。是Java等编程语言所没有的功能。它可以允许你手动指定，将某种类型的对象转换成其他类型的对象或者是给一个类增加方法。通过这些功能，可以实现非常强大、特殊的功能。
Scala的隐式转换，其实最核心的就是定义隐式转换方法，即implicit conversion function。定义的隐式转换方法，只要在编写的程序内引入，就会被Scala自动使用。Scala会根据隐式转换方法的签名，在程序中使用到隐式转换方法接收的参数类型定义的对象时，会自动将其传入隐式转换方法，转换为另外一种类型的对象并返回。这就是“隐式转换”。其中所有的隐式值和隐式方法必须放到object中。
然而使用Scala的隐式转换是有一定的限制的，总结如下：

• implicit关键字只能用来修饰方法、变量（参数)。
• 隐式转换的方法在当前范围内才有效。如果隐式转换不在当前范围内定义（比如定义在另一个类中或包含在某个对象中），那么必须通过import语句将其导。
  隐式参数
  所谓的隐式参数，指的是在函数或者方法中，定义一个用implicit修饰的参数，此时Scala会尝试找到一个指定类型的，用implicit修饰的参数，即隐式值，并注入参数。
  Scala会在两个范围内查找：
• 当前作用域内可见的val或var定义的隐式变量；
• 一种是隐式参数类型的伴生对象内的隐式值；

隐式转换方法作用域与导入

（1）Scala默认会使用两种隐式转换，一种是源类型或者目标类型的伴生对象内的隐式转换方法；一种是当前程序作用域内的可以用唯一标识符表示的隐式转换方法。
（2）如果隐式转换方法不在上述两种情况下的话，那么就必须手动使用import语法引入某个包下的隐式转换方法，比如import test._。通常建议，仅仅在需要进行隐式转换的地方，用import导入隐式转换方法，这样可以缩小隐式转换方法的作用域，避免不需要的隐式转换。
隐式转换的时机
（1）当对象调用类中不存在的方法或成员时，编译器会自动将对象进行隐式转换
（2）当方法中的参数的类型与目标类型不一致时

隐式转换和隐式参数案例

隐式转换案例一（将我们的Double类型的数据自动转换成Int类型）

object Chapter14 {
  implicit def ConvertDoubleToInt(first:Double):Int= first.toInt
}

object Convert{
  //导入隐式转换的方法
  import Chapter14._
  def main(args: Array[String]): Unit = {
    val first:Int = 3.5
  }
}

例如我们也可以定义猫和狗，并且让狗学会抓老鼠的技能

object CatAndDog {
  implicit  def dogCatchMouse(dog:Dog) = new Cat()
  def main(args: Array[String]): Unit = {
      val dog = new Dog
      dog.catMouse("大黄狗")
  }
}
class Cat{
  def catMouse(name:String): Unit ={
    println(name+"catch a mouse")
  }
}
class Dog{
  def wangwangwang(name:String) ={
    println(name+"看门汪汪汪")
  }
}

隐式转换案例二（让File类具备RichFile类中的read方法）

import java.io.File
import scala.io.Source
object MyPredef{
  //定义隐式转换方法
  implicit def file2RichFile(file: File)=new RichFile(file)
}
class RichFile(val f:File) {
  def read()=Source.fromFile(f,"GBK").mkString
}
object RichFile{
  def main(args: Array[String]) {
    val f=new File("F:\\scala与spark课件资料教案\\3、scala第三天\\files\\file.txt")
    //使用import导入隐式转换方法
    import MyPredef._
    //通过隐式转换，让File类具备了RichFile类中的方法
    val content=f.read()
    println(content)
  }
}

隐式转换案例三（超人变身）

class Man(val name:String)
class SuperMan(val name: String) {
  def heat=print("超人打怪兽")
}
object SuperMan{
  //隐式转换方法
  implicit def man2SuperMan(man:Man)=new SuperMan(man.name)
  def main(args: Array[String]) {
    val hero=new Man("hero")
    //Man具备了SuperMan的方法
    hero.heat
  }
}

隐式转换案例四（一个类隐式转换成具有相同方法的多个类）

class A(c:C) {
  def readBook(): Unit ={
    println("A说：好书好书...")
  }
}
class B(c:C){
  def readBook(): Unit ={
    println("B说：看不懂...")
  }
  def writeBook(): Unit ={
    println("B说：不会写...")
  }
}
class C
object AB{
  //创建一个类的2个类的隐式转换
  implicit def C2A(c:C)=new A(c)
  implicit def C2B(c:C)=new B(c)
}
object B{
  def main(args: Array[String]) {
    //导包
    //1. import AB._ 会将AB类下的所有隐式转换导进来
    //2. import AB._C2A 只导入C类到A类的的隐式转换方法
    //3. import AB._C2B 只导入C类到B类的的隐式转换方法
    import AB._
    val c=new C
    //由于A类与B类中都有readBook()，只能导入其中一个，否则调用共同方法时代码报错
    //c.readBook()
    //C类可以执行B类中的writeBook()
    c.writeBook()
  }
}

隐式参数案例五（员工领取薪水）

object Company{
  //在object中定义隐式值    注意：同一类型的隐式值只允许出现一次，否则会报错
  implicit  val aaa="zhangsan"
  implicit  val bbb=10000.00
}
class Boss {
  //注意参数匹配的类型   它需要的是String类型的隐式值
  def callName()(implicit name:String):String={
    name+" is coming !"
  }
  //定义一个用implicit修饰的参数
  //注意参数匹配的类型    它需要的是Double类型的隐式值
  def getMoney()(implicit money:Double):String={
    " 当月薪水："+money
  }
}
object Boss extends App{
  //使用import导入定义好的隐式值，注意：必须先加载否则会报错
  import Company._
  val boss =new Boss
  println(boss.callName()+boss.getMoney())

}