Scala 2.11.7 학습 노트 (4) 상용 데이터 구조

노 춘 리 의 업무 노트 는 기억력 이 나 쁜 필치 보다 못 하 다.
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[    ](     );

     설명: 배열 이 설명 할 때 초기 값 을 제시 하면 스칼라 는 형식 을 추정 할 수 있 기 때문에 배열 의 유형 과 길 이 를 설명 하지 않 아 도 됩 니 다.

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 클래스 를 제공 합 니 다. 자바 의 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
    자바 에서 set 와 유사 합 니 다. Key 는 두 개의 가방 으로 나 누 어 정의 합 니 다.
    가 변: scala. collection. mutable
    가 변 하지 않 음: scala. collection. immutable    결 성 된 상황 을 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
    스칼라 의 또 다른 유용 한 용기 류 는 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)