scala使用

2019独角兽企业重金招聘Python工程师标准>>>

一、安装scala开发环境

在www.scala-lang.org 官网上下载对应的scala-2.11.7.msi文件  双击安装

二、配置scala环境变量

三、验证安装是否成功

在cmd下输入 scala命令  出现如下界面表示安装成功

四、在eclipse安装scala开发插件

在eclipse中点help ->Install New Software

点击finish

五、第一个scala程序

1、新建scala project

2、新建scala object

3、代码

object Helloworld extends App{
  println("hello world");
}

4、运行看效果

六、scala简单语法代码

1、函数

/**
 * 函数
 */
object Test11 extends App{
  //  println("hello world!")

  /*无返回值的函数*/

//def定义一个函数
   def add(a:Int ,b:Int){
      println(a + b)
   }
    add(1,2)

  /*有返回值的函数*/
  //scala中返回值显示为（）表示Unit
  //如果我们强制指定函数返回值类型为Unit，返回就为Unit类型
  def add(a: Int, b: Int) :Int = {
    a + b
  }
  var a = add(2, 2)
  println(a)
  
  /*小知识点*/
//  1.scala中，“;”可以加也可以不加
//  2.调用函数的时候，我们可以给定参数名进行调用
  
  var c = add(b = 2 , a = 2) //给定参数名进行调用
  println(c)
  
}

2、控制结构 while for

/**
 * 控制结构 while for
 */
object Test22 extends App{
  /*while循环*/
    while(true){
      println("hello")
    }

  /*for循环*/
  //  for(int i = 0 ; i < 4 ; i ++){} //java的for循环
  //  for( i : List){}

  //for的基本形态
  //  println(1 to 10)

  //  for( i <- 1 to 10){ //闭区间
  //    println(i)
  //  }

  //  for (i <- 1 until 10) { //开区间
  //    println(i)
  //  }

  //  for (i <- 1 until 10 reverse) { //倒序
  //    println(i)
  //  }

  /*高级for循环*/
  //守卫
  for (i <- 1 until 10 reverse ;if i % 3 == 0) { //修改步长
   println(i)
  }

  for (i <- 1 until 10 ; j <- 1 to 5) { //双重for循环
      println(i + " - " + j)
  }
  
  //for的推导式
  var tmp = for( i <- 1 to 10 )yield {i * 2 ; i + 1}
  println(tmp)
}

3、数组

import scala.collection.mutable.ArrayBuffer
import java.util.ArrayList

/**
 * 数组
 */
object Test31 extends App{
  /*定长数组*/
  var arr1 = new Array[Int](4) //使用new的方式定义一个数组
  arr1(1) = 2
  for( i <- arr1){
   println(i)
  }
  
  //利用Array类定义数组
  var arr2 = Array(1,2,3,4,5,"hehe")
  for(i <- arr2){    println(i)
  }
  
  var arr3 = Array(1,2,3,4,5)
//  println(arr3.min)  //获取数组的最小值
//  println(arr3.max)  //获取数组最大值
//  println(arr3.sum)  //获取数组所有数的和
//  println(arr3.mkString(" ")) //Arrays.toString(arr)类似
  
  
  //使用for的推导式产生新的数组
  var arr4  = for( i <- arr3)yield i * 2
//  println(arr4)
//  for(i <- arr4){
//    println(i)
//  }
  
  /*变长数组*/
  var arr5 = ArrayBuffer[Int](1,2,3,4,5)
//  arr5 += 6           //添加一个元素
//  arr5 -= 1
//  arr5 ++= arr3     //添加一个数组
//  arr5 --= arr3       //删除数组中多个元素

//arr5.trimStart(2)   从前面移除两个元素

//arr5.insert(1,6)  在第一个位置加个6

//arr5.remove(2)  删除第三个位置的元素

//arr5.trimEnd(2) 从后面移除两个元素
//  println(arr5.mkString(","))
  
//  var arr6 = arr3.toBuffer  //定长数组转换为变长数组
//  arr6 += 7
//  println(arr6.mkString(","))
  
//  arr5.toArray     //变长数组转换为定长数组
  
//  var list = new ArrayList[Int]
//  list.add(1)
//  list.add(3)
//  for(i <- 0 to list.size() - 1){
//    println(list.get(i))
//  }
  
  //filter和map的用法
  var arr7 = Array(1,2,3,4,5)
  var arr8 = arr7.filter(_ % 2 == 0).map(_ * 2)
  var arr9 = arr7.filter{_ % 2 == 0}.map(_ * 2)
  
  for(i <- arr8){
    println(i)
  }
  
  
}

多维数据   var xx=Array.ofDim[Int](3,4)  定义一个三行四列的多维数组

5、映射

/**
 * 映射
 */
object Test32 extends App{
  /*不可变的映射*/
  //(zhangsan,17) 键值对称作对偶   对偶用（）
  var map1 = Map[String , Int]("zhangsan" -> 17 , "lisi" -> 18)
  map1 += ("wangwu" -> 10)
  map1 += ("zhaoliu",80)
  for(i <- map1){
    println(i)
  }
  
  //给对应key更改value
  map1("zhangsan") = 18
  map1 += ("zhangsan" -> 18)
  for (i <- map1) {
    println(i)
  }
  
  if(map1.contains("zhaoliu")) //添加判断 验证key是否存在
    println(map1("zhaoliu"))
    
    for((k , v) <- map1){  //使用（k,v）遍历map
     println(k + " -> " + v)
    }
  
  var tmp = map1.keys
  var tmp1 = map1.keySet
  println(tmp1)
  for(i <- tmp){    //利用keyset取出map的值
    println(map1(i))
  }
    
  /*可变的映射*/
  var map2 = scala.collection.mutable.Map[String,Int]("zhangsan"->18,"lisi"->19)
  map2("zhangsan") = 19
  for( i <- map2){
    println(i)
  }
}

map2.getOrElse("wangwu","123")   //如果wangwu这个值没有  就给wangwu个默认值123

6、元组

/**
 * 元组
 */
object Test33 extends App{
  /*元组*/
  //对偶是元组最简单的形式  也是用（）
  var t = (1,2,3,4,"haha")  //元组的定义
  println(t._1)      //使用._(下标) 
  println(t _5)      //使用._(下标) 
  println(t.productIterator)
  for(i <- t.productIterator){
    println(i)
  }
  
  var (first,second,third,_) = t //利用模式匹配访问元组元素
  println(third)
  
  var s = "Hello World!"
  println(s.partition {_.isUpper}) //返回值不是一个
  
  
  /*拉链操作*/
  var arr1 = Array(1,2,3,4,"##")
  var arr2 = Array("a","b","c","d")
  var arr3 = arr1.zip(arr2)
  println(arr3.mkString(","))
  for(i <- arr3){
    println(i)
  }
  
  var arr4 = arr3.toMap
  println(arr4)
  for(i <- arr4){
    println(i)
  }
  
  
}

7、类

import scala.beans.BeanProperty

/**
 * 类的基本内容1
 */
class TestClass41{
  var monary = 100
  
}

object Test41 extends App{
  
  //scala中class的字段用var定义都会生成对应的setter和getter方法 ，名称分别为monary_= 和 monary
  //如果class中使用val定义 scala不在提供setter方法
  var a = new TestClass41
//  a.monary = 200
  println(a.monary)
  
  //@BeanProperty和private修饰不能同时使用
//  a.setMonary(300)
//  println(a.getMonary())
    
}

8、类的构造器

/**
 * 类的构造器
 */

//主构造器
//class TestClass43(var a:Int = 1 , var b:Int = 2) {
//  var a:Int = 1
//  var b:Int = 2
//  println(a + b)
//}

//辅助构造器
class TestClass43 {
  var a:Int = 0
  var b:Int = 0
  
  def this(a:Int){
    this()    //辅助构造器第一行必须要调用主构造器
    this.a = a
    println("第一个辅助构造器")
  }
  
  def this(a:Int , b:Int){
    this(a)   //除了调用主构造器之外还可以调用其他辅助构造器
    this.a = a
    this.b = b
    println("第二个辅助构造器")
  }
  
  println(a + b)
  
  def show {
    println(a + b)
    println("show方法")
  }
  
}

object Test43 extends App{
  val c = new TestClass43(1,2)
//  println(c.a + c.b)
  println(c.show)
}

9、object  伴生对象

object对象相当于java中static的使用

伴生对象里可以放class的共享数据

/**
 * 伴生对象
 */

class TestObject51{
  def display(){
    println(TestObject51.value)
  }
}

//同名类的伴生对象
object TestObject51{
  //对象是一个单独类型，提供类似java中的静态字段和静态方法功能
  private var value = 1
  
//  def show(){
//    println("hello world!")
//  }
}

object Test51 extends App{
//  TestObject51.show()   //调用object的方法
//  println(TestObject51.value)  //object中使用private修饰的字段外部不能访问
  
  var tmp = new TestObject51
  println(tmp.display())
}

10、高阶函数

/**
 * 高阶函数
 */

object Test61 extends App{
  
  //定义一个有返回值的函数
  def add(a:Int , b:Int) = {
    a + b
  }
  var c = add(1,2)
  println(c)
  
  
  //把一个函数传递给另外一个函数
  var func1 = add _   
  println(func1(1,1))
  
  
  //匿名函数
  var func2 = (x:Int) => {x + 2}
//  println(func2(1))
  
  
  //传递一个函数作为另外一个函数的参数类型
  def func3(a:Int , f:(Int) => (Int)) = {
    f(1) + 1
  }
//  println(func3(func2))  
  println(func3(1, (x:Int) => {x + 1}))
  println(func3(1, _ + 1))
/*  转换条件：
    1.只有一个形参
    2.匿名函数作为参数
    3.函数体只有一行代码*/
  
  
  //传递一个函数作为另外一个函数的应用场景
//  def GPU(a:Int) = {
//    a + 3
//  }
//  def CPU(b:Int) = {
//    b + 10
//  }
//  def compute(men:Int , CPU:(Int) => (Int),GPU:(Int) => (Int)) = {
//   men +  CPU(2) + GPU(1)
//  }
//  println(compute(4,CPU,GPU))
  
  // "_"所代表的意义 
//  1.用来取元组的值
//  2.指传递的是一个确切的函数
//  3.指每一个元素 
  
  
}

11、继承

/**
 * 继承
 */

abstract class Person {  //抽象类可以有抽象的方法和字段，也可以有非抽象的方法和字段
  val id:Int 
  var name:String 
  def show:Int 
}

//继承一个抽象类的时候 不需要写override
class Student extends Person{
  override val id:Int = 2    //val使用val覆盖
  override var name:String = "Jackson"  //抽象的var只能使用var覆盖 
  override val show = 2    //无参的def可以使用val 或def
}

object Test71 extends App{
  var c = new Student
  println(c.id)
  println(c.show)
}

12、文件和正则表达式

import scala.io.Source  //导包

 var source=Source.fromeFile("E:/BaiduYunDownload/aa.txt","utf-8")  //读取资源文件

 var it=source.getLines  //获取文件中的每一行

 for(i <- it)println(i)  //循环打印每一行

13、模式匹配

var ch="+"+

ch match{case "+"=>println(1) case "-"=>println(2) case _=>println("else"）}

14、actor

class HelloActor extends Actor{

//重写act方法
  def act(){
    while(true){
      receive{
        case name:String=>println("name is "+name);
        case age:Int=>println("age is "+age)
      }
    }
  }
  
}

object HelloActor {
  def main(args: Array[String]): Unit = {
    var hello=new HelloActor;
    hello.start();

//发送消息
    hello ! 11;
  }
}

15、隐士转换

/*
隐式转换
 */
class SpecialPerson(val name:String)
class Student(val name:String)
class Older(val name:String)

class Teacher(val name:String)

object Implicit01 {

  implicit def object2SpecialPerson(obj:Object): SpecialPerson ={
    if(obj.getClass == classOf[Student]){
      val stu = obj.asInstanceOf[Student]
      new SpecialPerson(stu.name)
    }else if (obj.getClass == classOf[Older]){
      val older = obj.asInstanceOf[Older]
      new SpecialPerson(older.name)
    }else{
      Nil
    }
  }

  var ticketNumber = 0
  
  def buySpecialTicket(p:SpecialPerson)={
    ticketNumber += 1
    "T-" + ticketNumber
  }

  def main(args: Array[String]) {
    val chengxiaoxiao = new Student("chengxiaoxiao")
    println(buySpecialTicket(chengxiaoxiao))
    val gaga = new Older("gaga")
    println(buySpecialTicket(gaga))
    val yasaka = new Teacher("yasaka")
    println(buySpecialTicket(yasaka))
  }
}
 

/**
使用隐式转换加强现有类型
  超人变身（装饰类型）
  类型没有方法的时候会尝试隐式转换
 */

class Man(val name:String)

class Superman(val name:String){
  def emitLaser = println("emit a pingpang ball!")
}

object Implicit02 {
  implicit def man2superman(man:Man):Superman = new Superman(man.name)

  def main(args: Array[String]) {
    val yasaka = new Man("yasaka")
    yasaka.emitLaser
  }
}

/*
 * 隐式参数
 */

class SignPen{
  def write(content: String) = println(content)
}

object ImplicitContext{
   implicit val signPen = new SignPen
}

object Implicit04 {

  def signForExam(name:String)(implicit signPen : SignPen): Unit ={
    signPen.write(name + " arrive in time.")
  }

  def main(args: Array[String]) {
    import ImplicitContext._
    signForExam("yasaka")
    signForExam("laoxiao")
  }
}

 

16、scala操作xml

1、xml节点类型

创建xml方式一

定义一个xml  val book = <books><book>book1</book></books>  等号两边要有空格

获得根节点名称 book.label

获得所有子元素  book.child

创建xml方式二

var bookBuffer= new scala.xml.NodeBuffer

bookBuffer += <book>book1</book>

bookBuffer += <book>book2</book>

var books: scala.xml.NodeSeq=bookBuffer

 for (i<- books) println(i)

2、xml属性信息

 val book = <books id="1" price="10.0"><book>book1</book></books>

var booId =book.attributes("id").text

var booId =book.attributes("price").text

遍历属性  for(i <- book.attributes)println(i)

把属性转换成map book.attributes.asAttrMap

3、在xml中嵌入scala代码

import scala.xml._

 var buffer=Array("book1","book2")

var books = <books><book>{buffer(0)}</book><book>{buffer(1)}</book></book></books>

var books = <books>{for (i <-buffer) yield <book>{i}</book>}</books>

4、在xml 节点属性里嵌入scala代码

 var books = <books><book id={buffer(1)}></book></books>

5、修改xml中的属性

 var books = <books><book>book1</book></books>

var booksCopy=books.copy(child=books.child ++ <book>book2</book>)

 booksCopy % Attribute (null,"id","2",Null)  给booksCopy的books节点加个id=2的属性

 booksCopy% Attribute(null,"id","3",Attribute(null,"price","10",Null))

 res22 % Attribute(null,"id","3",Attribute(null,"price","10",Attribute(null,"number","30",Null)))

6、scala加载外部xml和把xml导出到指定位置

import scala.xml._

import java.io._

使用scala加载xml

val info=XML.loadFile("C:\\Users\\zhougn\\Desktop\\new.xml")

使用java  FileInputStream 加载xml

 var books2=XML.load(new FileInputStream("C:\\Users\\zhougn\\Desktop\\new.xml"))

使用java InputStreamReader 加载xml

var books3=XML.load(new InputStreamReader(new FileInputStream("C:\\Users\\zhougn\\Desktop\\new.txt"),"UTF-8"))

把内存中的books3  xml保存到指定路径

 XML.save("C:\\Users\\zhougn\\Desktop\\new2.txt",books3)

转载于:https://my.oschina.net/xiaozhou18/blog/814247