鲁春利的工作笔记好记性不如烂笔头



1、Array

    http://www.scala-lang.org/api/current/#scala.Array

Arrays are mutable, indexed collections of values. Array[T] is Scala's representation for Java's T[]. 

var array = new Array[数据类型](数组长度);

    说明:数组成员初始化,Int类型默认会初始化为0,String类型会初始化为Null。

var array = Array[数据类型](数组元素值);

     说明:数组声明时若给出初值,Scala能够进行类型推断,因此可以不用声明数组类型和长度。

package com.lucl.scala

import scala.collection.mutable.ArrayBuffer

/**
 * @author luchunli
 */
object ArrayDataStructure {
  def main(args: Array[String]): Unit = {
    /**
     * 定长数组
     */
    // new时指定类型及长度,指定变量类型: Array[Int],可以省略
    var array1 = new Array[Int](5);
    {
      for (i <- 0 until 5) array1(i) = i + 1;  
    }
    // 5, 4, 3, 2, 1, 
    for (i <- array1.reverse) print(i + ", ");
    println();
    
    // 直接赋固定值,Scala能够进行类型推导
    var array2 = Array(1, 2, 3, 4, 5);
    // 1, 2, 3, 4, 5, 
    array2.foreach { x => print(x + ", ") }
    println();
    println(array2.max + "\t" + array2.min)  // 5 1
    
    /**
     * 变长数组,scala.collection.mutable包
     */
    var arrBuffer = new ArrayBuffer[String](5);
    println(arrBuffer.length)    // 0
    arrBuffer ++= Array("hello");
    println(arrBuffer.length)    // 1
    
    /**
     * 定长数组转变长数组
     */
    println(array2.toBuffer);
    
    /**
     * 变长数组转定长数组
     */
    println(arrBuffer.toArray);
    
    /**
     * zip操作
     */
    var array3 = Array(1, 2, 3);
    var array4 = Array("a", "b", "c");
    
    var tuple = array3 zip array4;  // 得到tuple
    // (1,a) (2,b) (3,c) 
    for (i <- tuple) print(i + " ");  //
    println();
    
     // 
    val array5 = Array("hello you", "hello me");
    val retVal = array5.flatMap { x => x.split(" ") }
    // hello you, hello me
    println(array5.mkString(", "));
    // hello, you, hello, me
    println(retVal.mkString(", ")); 
  }
}

    多维数组

val matrix = Array.ofDim[Int](3, 4);        // 三行四列的二维数组
matrix(2)(1) = 42;
    
val triangle = new Array[Array[Int]](10);
for (i <- 0 until triangle.length) { 
    triangle(i) = new Array[Int](i + 1);
}


2、Lists

http://www.scala-lang.org/api/current/#scala.collection.immutable.List

    Scala中提供了List类,和Java的List不同,Scala的List对象是不可修改的。

A class for immutable linked lists representing ordered collections of elements of type.

    构建列表的两个基础是:

        scala.Nil表示空列表;

        scala.::从已有的列表构建新列表。

        ::读作cons,cons操作符有两个参数:一个类型为T的元素和一个类型为List(T)的对象,它会把两个参数合到一起创建一个新的List(T)值。

val list = List(元素值列表);

    说明:元素必须为同一类型。

package com.lucl.scala

import scala.collection.mutable.ListBuffer

/**
 * @author luchunli
 */
object ListDataStructure {
  def main(args: Array[String]): Unit = {
    // : List[String] 是可以省略的
    val list : List[String] = List("hello", "you", "hello", "me");
    /**
     * 代码块
     */
    list.foreach 
    { x => 
      {
        if (x.equals("hello")) 
        {
          print(x + ", ");
        }
      }
    }
    println();
    println("----------------------------");
    println();
    
    /**
     * Nil空列表和::构建新的列表
     */
    val list2 = 1 :: 2 :: 3 :: Nil;  // 只能用在尾部
    val list3 = "hello you" :: "hello me" :: List();
    
    val retVal = list3.flatMap 
    { x => 
      {
        x.split(" ");
      } 
    }
    // List(hello, you, hello, me)
    println(retVal);
    val retMap = retVal.map { x => (x, 1) }
    
    /**
      hello : 1
      you : 1
      hello : 1
      me : 1
     */
    for ((k, v) <- retMap) println(k + " : " + v);
    
    /**
     * 可变List,ListBuffer
     */
    var listBuf = ListBuffer(1, 2, 3, 4, 5);
  }
}


3、Set

http://www.scala-lang.org/api/current/#scala.collection.mutable.Set

    和java中Set类似,Key,分两个包定义:

    可变: scala.collection.mutable

    不可变: scala.collection.immutable

    缺省情况Set为immutable Set 。
package com.lucl.scala

/**
 * @author luchunli
 */
object SetDataStructure {
  def main(args: Array[String]): Unit = {
    // 说明:Set中数据是会去重的,也就是两个hello实际使用的时候只会有一个
    val sset = Set("hello", "world", "hello", "me");
    // hello, world, me, 
    sset.foreach { x => print(x + ", "); }
    println();
    sset.+("new");  // 不可对sset重新赋值,这里实际返回了一个新的set
    
    // 不可变set
    var iset = scala.collection.mutable.Set("hello", "world", "hello", "me");
    iset += "new";    // 可调用+=
  }
}


4、Map

scala.collection.Map
    scala.collection.immutable.Map      # 可变映射
        scala.collection.immutable.HashMap
    scala.collection.mutable.Map        # 不可变映射
        scala.collection.mutable.HashMap

    说明:默认为不可变映射。

// 不可变映射
val map = Map(key1 -> value1, key2 -> value2, key3->value3);
//
val map = Map((key1, value1), (key2, value2), (key3, value3))
// 可变映射需指定全类名 
val map = scala.collection.mutable.Map((key1, value1), (key2, value2), (key3, value3));
// 
val map = new scala.collection.mutable.Map[T1, T2]()

    获取对应键的值

val value = Z(key);        // 返回值
val value = Z.get(key);    // 返回对象

    说明:

    当映射中不包含对应的键时,会抛出异常。

    利用contains方法检查映射中是否有某个键,val c = Z.contains(key); // 返回boolean值

    或者通过组合调用val d = Z.getOrElse(key, 0); 存在则返回否则返回0

package com.lucl.scala

/**
 * @author luchunli
 */
object MapDataStructure {
  def main(args: Array[String]): Unit = {
    /**
     * 不可变 ,scala.collection.immutable.Map
     */
    val map1 = Map( 1-> "I", 2 -> "II", 3 -> "III", 4 -> "IV");
    for ((k, v) <- map1) println(k + " : " + v);  // 显示key和value
    for ((k, _) <- map1) println(k);              // 只显示key
    for ((_, v) <- map1) println(v);              // 只显示value
    
    val map2 = Map[String, Int]();
    map2 + (("zhangsan", 18), ("wangwu", 21));  // 可以添加元素,但是不能+=
    map2 + ("lisi" -> 20, "zhaoliu" -> 19);
    
    /**
     * 可变
     */
    val hm = scala.collection.mutable.HashMap(1 -> "hi", 2 -> "there");
    hm += ((3, "three"), (4, "four"));    // 增加元素
    hm -= 1;                              // 删除元素
    
    map2.keys.foreach { x => println(x); }    // 获取key
    map2.values.foreach { x => println(x); }  // 获取value
    
  }
}

  

5、Tuples

    Scala 中另外一个很有用的容器类为Tuples,和List不同的Tuples可以包含不同类型的数据,而List只能包含同类型的数据。
    一旦定义了一个元组,可以使用._和索引来访问员组的元素(矢量的分量,注意和数组不同的是,元组的索引从1开始)。

scala> val paris=(123, "abc")
paris: (Int, String) = (123,abc)

scala> println (paris._1);
123

scala> println (paris._2);
abc

scala> var tuple = (1, 2.1, "spark");
tuple: (Int, Double, String) = (1,2.1,spark)

scala> val (first, second, third) = tuple;
first: Int = 1
second: Double = 2.1
third: String = spark

scala> val (fa, _, _) = tuple;
fa: Int = 1

scala> "Rocky Spark".partition(_.isUpper);
res0: (String, String) = (RS,ocky park)

scala>


6、zip方法

    把几个集合结合起来

scala> val one = Array('a', 'b', 'c');
one: Array[Char] = Array(a, b, c)

scala> val two = Array(1, 2, 3);
two: Array[Int] = Array(1, 2, 3)

// 生成一个新的数组
scala> val three = one zip two;
three: Array[(Char, Int)] = Array((a,1), (b,2), (c,3))

scala> val three01 = two zip one;
three01: Array[(Int, Char)] = Array((1,a), (2,b), (3,c))

// 生成一个以数组one为键,数组two为值的映射
scala> val four = one zip two toMap;
warning: there were 1 feature warning(s); re-run with -feature for details
four: scala.collection.immutable.Map[Char,Int] = Map(a -> 1, b -> 2, c -> 3)

scala> four.toMap;
res58: scala.collection.immutable.Map[Char,Int] = Map(a -> 1, b -> 2, c -> 3)