scala数据结构之List列表

 XML Code 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

package com.lyzx.day06

class T3{

  /**
   * List列表的创建和遍历
   */
  def f1(): Unit ={
    //创建列表唯一方式  List(item1,item2,....)
    val l = List(1,2,3,4,5)

    //遍历列表的第一种方式  foreach
    for(item <- l){
      println("foreach:"+item)
    }
    println("===================================")

    //遍历列表的第二种方式  for+until
    for(index <- 0 until l.size){
        println("for:"+l(index))
    }
  }

  //列表的过滤方法(1)
  def f2(): Unit ={
    val l = List(1,2,3,4,5)
    //过滤l中的元素 传入一个predicate类型的函数即f:(T)=>Boolean这里指 f:(Int)=>Boolean
    val l2 = l.filter(x=> x>2)

    for(item <- l2){
      println("filter:"+item)
    }

    for(item <- l){
      println("original:"+item)
    }
  }

  // 过滤后的元素和源列表中的元素是同一个元素只是过滤后的列表里面存放符合filter(f)中f函数的元素引用，该引用和原始列表中的引用指向同一个对象
  def f3(): Unit ={
    val ls = List[User](new User("蜘蛛侠",13),new User("绿巨人",22),new User("雷神",33))
    val l2s = ls.filter(item=>{item.getAge()>30})

    l2s(0).setName("我不是索尔")

    for(item <- l2s){
      println("fliter："+item)
    }

    for(item <- ls){
      println("original:"+item)
    }
  }


    /**
     *  map方法
     *  map值映射即把流中的元素准换为另一种类型的元素
     */
  def f4(): Unit ={
    val ls = List[User](new User("蜘蛛侠",13),new User("绿巨人",22),new User("雷神",33))
      /*
      通过把User=>User.name ,然后把转变后的元素遍历并打印
       */
    ls.map(item => item.getName())
      .foreach(item=>{
      println(item)
    })
  }

    /**
     *  Map和flatMap的区别
     */
  def f5(): Unit ={
    val ls = List("hello world","hello lyzx","hello china")
      /*
      1、把字符串转换为数组(通过String.split()方法)，此时的数据结构(["hello","world"],["hello","lyzx"],["hello","china"])然后遍历每一项(数组)并对数组再一次做遍历并打印
      注意这儿的flatMap和java8中flatMap效果一样但是函数的写法不太一样，scala的flatMap的参数直接返回映射后的结果，为java8中的flatMap返回一个包含结果的Stream流
       */
    ls.map(item=>item.split(" "))
    .foreach(arr => {
        arr.foreach(
          item => println("map:"+item)
        )
    })

      /*
      flatMap 把map后的数据押平了即把(["hello","world"],["hello","lyzx"],["hello","china"])的数据结构里面的所有数组里的元素全部提取出来放在一个数组里面
       */
    println("========================================")
    ls.flatMap(item=>item.split(" "))
      .foreach(item=>println("flatMap:"+item))
  }

}

object T3{
  def main(args: Array[String]) {
    val t3 = new T3
    //t3.f4()
    t3.f5()
  }
}

class User(_name:String,_age:Int){
  private var name = _name;
  private var age = _age;

  def getName():String={
    name
  }

  def getAge():Int={
    age
  }

  def setName(_name:String): Unit ={
    this.name=_name;
  }
  override  def toString= "name:"+name+" age:"+age
}

List的所有方法

1def +(elem: A): List[A]
前置一个元素列表
2 def ::(x: A): List[A]
在这个列表的开头添加的元素。
3 def :::(prefix: List[A]): List[A]
增加了一个给定列表中该列表前面的元素。
4 def ::(x: A): List[A]
增加了一个元素x在列表的开头
5 def addString(b: StringBuilder): StringBuilder
追加列表的一个字符串生成器的所有元素。
6 def addString(b: StringBuilder, sep: String): StringBuilder
追加列表的使用分隔字符串一个字符串生成器的所有元素。
7 def apply(n: Int): A
选择通过其在列表中索引的元素
8 def contains(elem: Any): Boolean
测试该列表中是否包含一个给定值作为元素。
9 def copyToArray(xs: Array[A], start: Int, len: Int): Unit
列表的副本元件阵列。填充给定的数组xs与此列表中最多len个元素，在位置开始。
10 def distinct: List[A]
建立从列表中没有任何重复的元素的新列表。
11 def drop(n: Int): List[A]
返回除了第n个的所有元素。
12 def dropRight(n: Int): List[A]
返回除了最后的n个的元素
13 def dropWhile(p: (A) => Boolean): List[A]
丢弃满足谓词的元素最长前缀。
14 def endsWith[B](that: Seq[B]): Boolean
测试列表是否使用给定序列结束。
15 def equals(that: Any): Boolean
equals方法的任意序列。比较该序列到某些其他对象。
16 def exists(p: (A) => Boolean): Boolean
测试谓词是否持有一些列表的元素。
17 def filter(p: (A) => Boolean): List[A]
返回列表满足谓词的所有元素。
18 def forall(p: (A) => Boolean): Boolean
测试谓词是否持有该列表中的所有元素。
19 def foreach(f: (A) => Unit): Unit
应用一个函数f以列表的所有元素。
20 def head: A
选择列表的第一个元素
21 def indexOf(elem: A, from: Int): Int
经过或在某些起始索引查找列表中的一些值第一次出现的索引。
22 def init: List[A]
返回除了最后的所有元素
23 def intersect(that: Seq[A]): List[A]
计算列表和另一序列之间的多重集交集。
24 def isEmpty: Boolean
测试列表是否为空
25 def iterator: Iterator[A]
创建一个新的迭代器中包含的可迭代对象中的所有元素
26 def last: A
返回最后一个元素
27 def lastIndexOf(elem: A, end: Int): Int
之前或在一个给定的最终指数查找的列表中的一些值最后一次出现的索引
28 def length: Int
返回列表的长度
29 def map[B](f: (A) => B): List[B]
通过应用函数以g这个列表中的所有元素构建一个新的集合
30 def max: A
查找最大的元素
31 def min: A
查找最小元素
32 def mkString: String
显示列表的字符串中的所有元素
33 def mkString(sep: String): String
显示的列表中的字符串中使用分隔串的所有元素
34 def reverse: List[A]
返回新列表，在相反的顺序元素
35 def sorted[B >: A]: List[A]
根据排序对列表进行排序
36 def startsWith[B](that: Seq[B], offset: Int): Boolean
测试该列表中是否包含给定的索引处的给定的序列
37 def sum: A
概括这个集合的元素
38 def tail: List[A]
返回除了第一的所有元素
39 def take(n: Int): List[A]
返回前n个元素
40 def takeRight(n: Int): List[A]
返回最后n个元素
41 def toArray: Array[A]
列表以一个数组变换
42 def toBuffer[B >: A]: Buffer[B]
列表以一个可变缓冲器转换
43 def toMap[T, U]: Map[T, U]
此列表的映射转换
44 def toSeq: Seq[A]
列表的序列转换
45 def toSet[B >: A]: Set[B]
列表到集合变换
46 def toString(): String
列表转换为字符串