1.  OLAP和OLTP的特点
 
     OLAP (联机分析处理)  和 OLTP (联机事务处理) 在查询方面的特点：
      1) OLTP  单次查询返回数据量小，但是经常会涉及服务器端简单的聚合操作，要求查询响应速度快，一般应用于在线处理；
      2) OLAP 单次查询返回数据量巨大，服务器端进行的处理复杂，经常包含上卷(从细粒度数据向高层的聚合)、下钻(将汇总数据拆分到更细节的数据)类似的操作；
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 
 

 

 
 
 什么是交互式报表
 
 
 
 

  传统报表是以一种相对静态的数据表现形式，辅助决策服务的。主要以显示、打印及导出数据功能为主。现代商业智能更需要智能的展现和分析数据，传统的报表并不能适应商业智能的需求。
 

  交互式报表是一种为实现智能化的业务分析的报表解决方案，使静态的报表尽可能动态化，即报表数据动态化和报表形式动态化，从而提升报表的实际使用价值。根据用户的分析角度和数据选择的不同而出现不同的报表展现形式。
 

  交互式报表为用户提供交互功能，用户可以在运行报表之前输入或选择值，从而决定报表数据和形式。用户使用交互式报表不仅可以显示或隐藏报表中的内容，也可以通过点击其中的链接访问其他报表或对象。交互式报表是动态的，用户也可以按照自身的需求动态定义数据呈现。简而言之交互式报表是在静态报表上添加用户可操作的功能，使报表变得可交互。
 
 
 
 
 
 
 
 
 使用交互式报表的好处
 
 
 
 
 
  

    智能：交互式报表让用户随时可改变报表条件，从而改变报表呈现的数据内容。不再以静态形式展示,通过在静态的报表中增加用户操作如动态排序、过滤，钻取等操作，使报表变得可交互。让报表变得可交互是为解决最终用户分析数据的需求，交互式报表能够为商业智能提供所需的智能分析数据的功能，用户可以主动控制数据的呈现，让报表更生动更智能。
  
 
 
  

    灵活性：在用户对数据集不了解时，可根据数据源动态加载报表，而不是采用固定的报表形式，可灵活适应不同结构的数据源。
  
 
 
  

    动态性：用户可进行个性化调整的，不同的用户可自行配置需要的报表运行方式。
  
 
 
  

    提高效率：有选择的查看数据，报表加载数据时会根据用户需求加载数据，节省加载时间，仅显示用户关心的数据，帮助用户快速决策，提高用户工作效率。
  
 
 
 
 
 
 
 
 
 
 实现交互式报表的常用方法
 
 
 
 
数据可视化
 
 
       数据可视化技术是将数据以图形化的方式进行显示，让数据更易于阅读、理解和分析。早期的数据可视化以图表（Chart）为主，现代商业报表中逐渐加入迷离图（Sparkline）、数据条（Bullet）、图标集（Icon）、仪表盘（Gauge）、地图（Map）用于数据可视化，而数据可视化常用作交互式报表的基本载体。
 
 
 
 
 数据钻取报表
 
 

  钻取功能会显示另一张与正在分析的数据相关的报表，当用户使用报表观察汇总数据时，当对某个数据感兴趣或是察觉异常时，往往需要调阅汇总值，以仔细深入分析。
 

  常用的数据钻取方式两种：多维钻取，主从联动。
 
 
  
 
   多维钻取
  
 
  

    通过多层向下钻取，查找信息的根本原因，钻取维度是无限制的，可进行无限制的维度钻取。
  
 
 
 
  
 
   主从联动（隐藏或显示钻取）
  
 
  

    主从联动是交互式报表中常见的功能，通常是由上一级的选择决定下一级报表的显示结果。
  
 
 
 
 
 
 
 
 
 
 数据深化报表
 
 

  深化是根据终端用户的需求，动态的显示或隐藏报表数据，常用于汇总类型报表。深化层数无限制，可进行无限制层的数据深化。
 

  常用的深化方式有三种：横向深化、纵向深化、混合深化。
 
 
 
 
 
 
 
 
 动态过滤
 
 

  面对大规模的企业，单个报表中经常会有成千上万条的数据量，逐行查看数据是不切实际且非常耗时的，并且不同类型的客户关心的数据或分析数据的角度不同，因此通过数据过滤和筛选来帮助用户选择各自符合条件的数据，从而节省大量浏览数据的时间，避免一些无用的工作。
 

  动态过滤根据用户的输入的条件筛选数据。报表解决方案获取用户的输入有三种方式：1. 提示用户直接输入，2.通过报表参数传递，3.报表应用窗体上直接获取。
 

  常见的动态过滤方式有三种：
 多条件单值，多条件多值，级联过滤。
 
 
  
 
   多条件单值是指用户通过输入多个条件值，得到唯一对应的信息。
  
 
 
  
 
   多条件多值：是指用户输入多个条件值，查询符合多个条件值的数据。
  
 
 
  
 
   级联过滤：在大量数据展示下，常遇到这种情况用户的多个选择是存在业务联系的,如在全球性规模的企业,全球的销售业务包含中国，美国，日本，英国，法国等，选择查看中国，城市的可选项的就有西安，上海，北京、大连等城市，城市的选项是由选择的国家决定的，将该操作过程称为级联过滤。
  
 
 
 
 
 
 
 
 
 
 动态排序
 
 

  最终用户可以对报表进行区域内排序。动态排序是最常用的交互功能。
 
 
 
 
 
 
 
 
 动态表格
 
 

  指可根据用户选择动态显示表格数据，常用的功能包括：动态列，动态选择列，动态选择表。
 
 
  

    根据数据源动态添加列
  
 
 
  

    根据用户选择显示相应列
  
 
 
  

    根据用户选择显示相应表格
  
 
 
 
 
 
  
 
  
 
  
 
  
 
 
 
 
 
 
 
 
 
 
 
 文档目录（TOC）
 
 

  文档目录能够有效组织报表内容，用户可以非常清晰的查看报表数据结构，并能帮助用户快速导航至指定数据所在位置。
 
 
 
 
 
 
 
 

Redis
 
官网:https://redis.io
 
特点:
 
    (1)它是一个基于Key-Value的存储,单线程
    (2)可用作Cache and store(既可以用作缓存服务,也可以用作存储服务)
    (3)工作在内存中
 
支持:
 
    1 持久化(redis会在一定时间内将内存中的数据写入到硬盘中从而实现数据持久化)
        基于Snapshotting方式(数据异步从内存传输到硬盘中)
        基于AOF方式(把每一次的写操作都存放在现有的文件中)
    2 主从(借助于sentine实现一定意义上的高可用,可像Mysql主从一样,主实现写操作,从实现读操作)
    3 cluster(分布式集群,读写操作可在多节点进行)
    4 就地更新(可在内存中直接更新)
 
数据结构服务器
 
    支持存储:
        string(字符串)、list(列表)、hash(关联数组)、set(集合)、sorted_set(有序集合)、Bitmaps、Hyperloglog
1 Memcached是一个分布式的内存对象缓存系统
    Redis是可以实现持久存储的
2 Memcached是一个LRU的缓存,会把最近最少使用的数据都清理掉
    Redis拥有更多特性,支持存储更多的类型(string,lists,hash,set....)
3 Memcached是多线程的
    Redis是单线程的
4 二者性能几乎不相上下
 
存储系统常见分类
 
1 RDBMS(关系型数据库):Mysql、Oracle、DB2、SQL Server....
2 NoSQL(非关系型数据库):Redis、MongoDB、HBase.....
3 NewSQL(支持分布式的关系型数据库):Aerospike、FoundationDB....
 
NoSQL常见有四种流派
 
1 Key-Value NoSQL(键值存储NoSQL)
    Memcached、Redis...
2 Column family NoSQL(列式存储NoSQL)
    HBase... 
3 Documentation NoSQL(文档存储NoSQL)
    MongoDB...
4 Graph NoSQL(图式存储NoSQL)
    Neo4j...
 
Redis的组件
 
1 redis-server
2 redis-cli
3 redis-benchmark(性能压力测试)
4 redis-check-dump & redis-check-aof(检查Redis持久化之后的文件中(AOF/RDB)是否出现错误)
 
安装Redis:(有两种方式,此处采用yum安装,前面文章有编译安装)
 
[root@bogon ~]# yum search epel           #在yum中搜索epel源
[root@bogon ~]# yum install epel-release  #安装epel源
[root@bogon ~]# yum install redis         #直接用yum安装,在Centos7上,现在的redis版本应该都是3.2
[root@bogon ~]# cat redis.conf   
    全局配置:
    daemonize no                      #redis默认启动后会运行在前台界面,默认是关闭守护进程的,开启后redis会在后台以守护进程方式运行
    pidfile /var/run/redis_6379.pid   #指定了redis启动后pid的存放位置
    port 6379                         #redis默认监听端口为TCP的6379
    tcp-backlog 511                   #tcp-backlog长度
                        tcp-backlog:任何tcp服务都有可能用到此功能,等待队列功能
                            例:当并发量过高,访问过多的时候,redis忙不过来的话,就会将新的请求存放在tcp-backlog中
    bind 127.0.0.1                   #redis的监听地址,默认监听在127.0.0.1上
    unixsocket /tmp/redis.sock       #定义socket的文件位置,当在同一台服务器上进行通信时,采取sock方式就不用去走tcp/ip等协议了,在内存中直接交换,更加快捷
    unixsocketperm 700               #socket的访问权限
    timeout 0                        #当客户端连接空闲多久后显示超时,默认不开启

    持久化配置
    save 900 1      #在900秒内,如果有一个键发生改变,那么就做一次快照,做一次持久化
    save 300 10     #在300秒内,有十个键发生改变,那么就做一次快照,做一次持久化
    save 60 10000   #在60秒内,有10000个键发生改变,那么就做一次快照,做一次持久化
    Note:如果要禁用redis的持久化功能,在配置文件中输入save "" 就是代表禁用

    主从配置
    slaveof <masterip> <masterport> #这项不启用的话,此redis就是主,这项取消注释启用的话,这台就是从,后边跟主redis的ip和端口
    主从复制配置(当然前提是slaveof要开启的)
    slave-read-only yes  #从redis采用只读模式

    安全相关配置
    maxclients 10000  #最大客户端并发数量,默认此选项为注释
    maxmemory <bytes> #最多允许redis在当前主机上使用多少内存

    APPEND ONLY MODE:一有修改就将修改的数值存储在一个文件中,类似Mysql的二进制日志
    appendonly no #默认是禁用的,可以同时启用此模式和snapshotting模式
 
Redis命令操作
 
# systemctl start redis              #使用yum安装的话则可以直接启动
# redis-cli -h                       #查看此命令的帮助
  -h:指定服务器地址
  -p:指定端口
  -s:指定socket位置
  -a:指定密码
# redis-cli                          #什么选项都不加的话,则说明连接本地的redis
127.0.0.1:6379>exit                  #这就是登录进redis后的提示符(exit是退出)
 
Redis交互式帮助用法
 
127.0.0.1:6379>help                  #这样会获取help指令的用法,因为redis支持多种数据类型,所以查看帮助的话也是需要指定
redis-cli 3.2.10
To get help about Redis commands type:
      "help @<group>" to get a list of commands in <group>
      "help <command>" for help on <command>
      "help <tab>" to get a list of possible help topics
      "quit" to exit

To set redis-cli perferences:
      ":set hints" enable online hints
      ":set nohints" disable online hints
Set your preferences in ~/.redisclirc
127.0.0.1:6379>help @string          #查看到的是关于string数据类型的一系列帮助信息(敲完help @之后按tab键会有补全功能)
                    @list
                    @hash
                    ....
127.0.0.1:6379> HELP append          #就是获取数组中单个指令的帮助信息
127.0.0.1:6379> HELP @server         #获取关于服务的帮助信息
    CLIENT LIST                      #可以查看当前客户端的连接信息
    CLIENT KILL                      #杀掉客户端进程
    SLAVEOF                          #后面直接跟master的IP以及端口就可以直接作为master的从了
 
Redis基于键值存储,下面说一下Key(键)
 
1 可以使用ASCII编码中的字符当键,键的长度不要太长(键越长消耗空间越多)
2 键可以实现自动过期
3 在同一个名称空间内,键名是不允许重复的,我们对同一个键操作的话意味的是我们要改键值了并不是要创建新键
    例:
        127.0.0.1:6379>SELECT 1 (打开1号名称空间)
                              2 (打开2号名称空间,0是我们默认的名称空间,最多可以打开16个)
 
Redis众多数据类型中的常用命令
 
Strings:
    (1) SET    :是定义值的时候用的
    (2) GET    :获取键的值时候用的
    (3) EXISTS :判断键是否存在
    (4) INCR   :整数+1
    (5) DECR   :整数减-1
127.0.0.1:6379> HELP SET                 #查看SET的用法
127.0.0.1:6379> SET name test            #定义一个键名为name,而name对应的值为test
OK
127.0.0.1:6379> GET name                 #可以换取name这个键的值
"test"
127.0.0.1:6379> SET name centos          #如果再次定义的话,新的值就会覆盖旧的值,所以同一个名称空间中键不允许重复
OK
127.0.0.1:6379> GET name
"centos"
127.0.0.1:6379> APPEND name rhel         #追加新的值到name键中
(integer) 10                             #显示了追加后的name键对应值的字符串长度
127.0.0.1:6379> GET name
"centosrhel"
127.0.0.1:6379> STRLEN name              #手动获取name键对应值的字符串长度
(integer) 10
127.0.0.1:6379> SET count 0              #定义名为count的键,值为0
OK
127.0.0.1:6379> INCR count               #使count的值加1,执行一次加一次1,你可以多执行几次再看看值,此处就不再重复演示
(integer) 1
127.0.0.1:6379> DECR count               #使count的值减1,执行一次减一次1,也会达到负数,多执行几次看一下
(integer) 2                              #我上面执行了三遍INCR所以执行一次DECR就是2,在执行就是1,在执行就是0
127.0.0.1:6379> SET name centos NX       #执行会失败,NX的意思是当键中没有值的时候才会设定键,否则不会设定
(nil)
127.0.0.1:6379> SET name2 centos XX      #执行会失败,XX的意思就是当键中有值的时候才会设定键,否则不会设定
(nil)
127.0.0.1:6379> SET name centos XX EX 10 #表示name键有值的时候才会赋值,并且赋值完成后过10秒后自动过期
 
 
list(列表):
    (1) RPUSH  :从右侧添加一个值到列表中
    (2) LPUSH  :从左侧添加一个值到列表中
    (3) LPOP   :从左侧逐一删除值
    (4) RPOP   :从右侧逐一删除值
    (5) LINDEX :指明索引位置并且获取值
    (6) LSET   :修改列表中的值
127.0.0.1:6379> HELP @list               #查看list数组中的相关帮助
127.0.0.1:6379> LPUSH l1 mon             #从左侧生成一个名为l1的列表
(integer) 1
127.0.0.1:6379> LINDEX l1 0              #查看名为l1的列表,并且指定第一个值的位置
"mon"
127.0.0.1:6379> LPUSH l1 sun             #从左侧新添加一个值为sun到l1列表中
(integer) 2
127.0.0.1:6379> LINDEX l1 1              #此时原本在0这个位置的mon位置就会变成了1,因为前面挤了一个sun
"mon"
127.0.0.1:6379> LINDEX l1 0              #获取的就是sun的值,因为从左侧新添加的,所以第一个必定是新添加的值
"sun"
127.0.0.1:6379> RPUSH l1 tue             #从右侧新添加一个值为tue到l1列表中
(integer) 3
127.0.0.1:6379> LINDEX l1 2              #查看到的结果就是tue,因为从左侧添加,则0必定是新添加的值,而从右侧添加,则最后一个值必定是新添加的值
"tue"
127.0.0.1:6379> LSET l1 1 fri            #修改l1列表中位置在1上的值为fri,那么原本在1上面的mon就会被替换为fri
OK
127.0.0.1:6379> RPOP l1                  #删除从右侧开始的第一个值,执行后会删除tue
"tue"
 
 
Sets(集合):
    (1) SADD     :创建新的集合
    (2) SINTER   :求两个集合的交集
    (3) SUNION   :求两个集合的并集,就是两个集合中都存在的,并且打印出来一份
    (4) SISMEMBER:判断集合中指定的元素是否存在
    (5) SPOP     :从集合中随机删除一个元素
127.0.0.1:6379> HELP @set                              #查看set数组中的相关帮助
127.0.0.1:6379> SADD v1 mon tue wen thu fri sat sun    #创建一个名为v1的集合,并且包含的内容为"mon,tue,wen...sun"
(integer) 7
127.0.0.1:6379> SADD v2 tue thu day                    #创建一个名为v2的集合,并且包含的内容为"tue,thu,day"
(integer) 3
127.0.0.1:6379> SINTER v1 v2                           #对比两个集合中是否存在交集
1) "thu"                                               #如果两个集合中有相同的值,那么会显示在屏幕上
2) "tue"
127.0.0.1:6379> SUNION v1 v2                           #对比两个集合中的并集
1) "sun"
2) "mon"
3) "tue"
4) "thu"
5) "wed"
6) "fri"
7) "sat"                                               #这个值只在v1中,但是还是打印出来了,就是v1中存在的打印出来
8) "day"                                               #这个值只在v2中,但是还是打印出来了,就是v2中存在的也打印出来
127.0.0.1:6379> SPOP v1                                #删除并弹出v1中的其中一个值,这个值是随机的
"wed"
127.0.0.1:6379> SISMEMBER v1 wed                       #判断集合中的wed是否还是一个元素
(integer) 0                                            #因为上面SPOP随机在v1中删除了一个元素,所以此时判断则为0
 
 
Sorted Sets(有序集合):
    (1) ZADD     :添加一个有序集合
    (2) ZCARD    :查看有序集合的元素个数
    (3) ZRANK    :查看指定元素对应的SCORE号
    (4) ZRANGE   :按照内置索引显示从"min-max"之间的索引
127.0.0.1:6379> HELP @sorted_set                                #查看sorted_set中的相关帮助
127.0.0.1:6379> ZADD weekday1 1 mon 2 tue 3 wed                 #添加名为weekday1的集合,值用(1,2,3)来指定SCORE,SCORE后面跟值
(integer) 3
127.0.0.1:6379> ZCARD weekday1                                  #获取有序集合的元素个数
(integer) 3
127.0.0.1:6379> ZRANK weekday1 tue                              #查看weekday1中tue元素对应的索引号
(integer) 1
127.0.0.1:6379> ZRANK weekday1 mon                              #SCORE数字大小决定了你的排序(因为我们有内置索引),如果从1开始定义,那么1对应的mon就会是0
(integer) 0
127.0.0.1:6379> ZSCORE weekday1 tue                             #根据元素来获取SCORE
"2"
127.0.0.1:6379> ZRANGE weekday1 0 1                             #显示weekday1中按照内置索引从0到1之间的所有元素
0)"mon"
1)"tue"
 
 
Hashes(哈希):
    (1) HSET     :定义一个hash
    (2) HGET     :获取键中子键对应的值
    (3) HDEL     :删除键中子键
    (4) HKEYS    :获取h1键中所有的子键名称
    (5) HVALES   :获取h1键中所有子键对应的值
    (6) HLEN     :获取h1键中拥有的hash个数
127.0.0.1:6379> HELP @hash                            #查看Hash数组的相关帮助
127.0.0.1:6379> HSET h1 a mon                         #创建一个h1键,定义当中有名为a对应mon的hash
(integer) 1
127.0.0.1:6379> HGET h1 a                             #获取h1键中a对应的值,定义的时候对应的是什么这里显示就会是什么
"mon"
127.0.0.1:6379> HSET h1 b tue                         #在h1键中重新添加一个名为b对应tue的hash
(integer) 1
127.0.0.1:6379> HDEL h1 b                             #删除某一个键下的子键对应的值
"tue"
127.0.0.1:6379> HKEYS h1                              #能够获取h1键中所有的子键名称
1) "a" 
127.0.0.1:6379> HVALS h1                              #能够获取h1键中所有的子键对应的值
1) "mon"
127.0.0.1:6379> HLEN h1                               #获取h1键中拥有的hash个数
(integer) 1

    今天接着学习scala，我是按照《scala编程中文版》这本书来进行学习的，感觉书中讲的很不错，也差不多都能弄明白，跟着书中的章节来一步一步的学下来，书中提到代码全部都是自己实践敲一遍，很多问题都是在不经意间出现，动手实践一方面可以加强自己对一门新的语言的学习理解程度，另一方面可以帮助自己体会语言的语法和书写方式，再者，也是最重要的就是自己在写每一句代码的时候不可能会全部按照书中的来写，那么就会产生一些新的东西了，这就是动手去实践的重要性，可以说，读研给我最大的收获之一吧，就是：遇事在没有自己动手去做之前都不敢轻易说不，遇上问题在没有动手去差很多资料解决之前不敢轻易说不会，这也是因为自己在本科的时候太过于安逸了吧，现在希望尽量去多学多做少说话。
 
    好了，扯远了，下面是今天的学习笔记，所有内容均来源于底部参考书籍，自己动手实践的时候加了东西，如有冒犯请告知。
 
 
1.Scala 里可以使用 new 实例化对象或类实例
当你在 Scala 里实例化对象， 可以使用值和类型把它参数化： parameterize。 参数化的意思是在你创建实例的时候“设置” 它。通过把加在括号里的对象传递给实例的构造器的方式来用值参数化实例，如：实例化一个数字：
val big = new java.math.BigInteger("12345")
也可以使用类似于java中的数组方式赋值
val str_list = new Array[String](4)
等价于：val str_list: Array[String] = new Array[String](3)
str_list(0) = "沂"
str_list(1) = "水"
str_list(2) = "寒"
str_list(3) = "城"
for (i <- 0 to 3)
print(str_list(i))
在这里需要注意的是()和[]，这是一个scala区别于java的地方，使用()来存放数组、列表之类的元素下标
当你用val定义一个变量如上面的str_list数组，那么这个变量就不能重新赋值，但它指向的对象却仍可以暗自改变，如str_list(0)是可以重新被赋予新的数值的，即数组本身是不能再变化的但是其中的每个具体的元素可以改变
在scala的交互式shell也可以简单的像写python一样如下：
scala> for(i<- 0 to 5)
     | println(i)
0
1
2
3
4
5
等价于：
>>> for i in range(6):
...     print i
...
0
1
2
3
4
5
个人觉得，至于简洁性不相上下
Scala的一个通用规则：如果方法仅带一个参数，你可以不带点或括号的调用它。本例中的to实际上是带一个Int参数的方法。代码 0 to 2 被
转换成方法调用(0).to(2)。
从技术上讲，Scala没有操作符重载，因为它根本没有传统意义上的操作符。取而代之的是，诸如+，-，*和/这样的字符可以用来做方法名。因此，当第一步里你在 Scala 解释器里输入 1 + 2，你实际上正在 Int 对象 1 上调用一个名为+的方法，并把 2 当作参数传给它
当对带有括号并包括一到若干参数的变量赋值时，编译器将把它转化为对带有括号里参数和等号右边的对象的 update 方法的调用
则上面的语句等价为：
val str_list = new Array[String](4)
等价于：val str_list: Array[String] = new Array[String](3)
str_list.update(0,"沂")
str_list.update(1,"水")
str_list.update(2,"寒")
str_list.update(2,"城")
for (i <- 0 to 3)
print(str_list.apply(i))
初始化一个字符串数组同样可以这样写：
val str_list = Array.apply("沂", "水", "寒","城")
如下：
scala> val str_list=Array.apply("yi","shui","han","cheng")
str_list: Array[String] = Array(yi, shui, han, cheng)

2.方法不应该有副作用是函数风格编程的一个很重要的理念。方法唯一的效果应该是计算并返回值。用这种方式工作的好处就是方法之间很少纠缠在一起，因此就更加可靠和可重用。另一个好处（静态类型语言里）是传入传出方法的所有东西都被类型检查器检查，因此逻辑错误会更有可能把自己表现为类型错误。把这个函数式编程的哲学应用到对象世界里意味着使对象不可变。
在scala中数组Array是可变的对象，而list却是不可变的，这个区别于java的可变的list
创建一个list也很简单如下：
scala> val num_list=List(23,45,67,89)
num_list: List[Int] = List(23, 45, 67, 89)

scala> var num_list0=List(12,34,56,78)
num_list0: List[Int] = List(12, 34, 56, 78)
scala可以将两个列表拼接到一起就像python中的一样如下：
scala> val merge_list=num_list:::num_list0
merge_list: List[Int] = List(23, 45, 67, 89, 12, 34, 56, 78)将num_list0拼在了num_list后面
如果说操作符：：：相当于python中的extend的话那么操作符：：就相当于python中的append方法了如下：
scala> val new_list=100::num_list0
new_list: List[Int] = List(100, 12, 34, 56, 78)  将新数值100添加到了num_list0前面
一个简单的需记住的规则：
如果一个方法被用作操作符标注，如 a* b，那么方法被左操作数调用，就像 a.*(b)——除非方法名以冒号结尾。这种情况下，方法被右操作数
调用。因此， 1 :: twoThree 里， ::方法被 twoThree 调用，传入 1，像这样： twoThree.::(1)
由于定义空类的捷径是Nil，所以一种初始化新List的方法是把所有元素用cons操作符串起来， Nil作为最后一个元素，如下：
scala> val new_list=100::99::88::77::66::55::44::33::22::11::Nil
new_list: List[Int] = List(100, 99, 88, 77, 66, 55, 44, 33, 22, 11)
要在最后用到 Nil 的理由是
::是定义在 List 类上的方法。如果你想只是写成 1 :: 2 :: 3，由于 3 是Int 类型，没有::方法，因此会导致编译失败
为什么列表不支持 append？
类List没有提供append操作，因为随着列表变长append的耗时将呈线性增长，而使用::做前缀则仅花费常量时间。如果你想通过添加元素来构造列表，你的选择是把它们前缀进去，当你完成之后再调用 reverse；或使用 ListBuffer，一种提供 append 操作的可变列表，当你完成之后调用 toList。
3.元组： tuple
与列表一样，元组也是不可变的，但与列表不同，元组可以包含不同类型的元素。而列表应该是List[Int]或List[String]的样子，元组可以同时拥有Int和String。元组很有用，比方说，如果你需要在方法里返回多个对象。Java里你将经常创建一个JavaBean样子的类去装多个返回值，Scala里你可以简单地返回一个元组。而且这么做的确简单：实例化一个装有一些对象的新元组，只要把这些对象放在括号里，并用逗号分隔即可，元组的实际类型取决于它含有的元素数量和这些元素的类型
如下：
scala> val new_tuple=("20123456","沂水寒城")
new_tuple: (String, String) = (20123456,沂水寒城)
访问元祖中的元素的话可以使用点号，下划线和一个基于 1 的元素索引访问它，如下：
scala> println(new_tuple._1)
20123456
scala> println(new_tuple._2)
沂水寒城
不能用类似数组下标的方式访问元祖原因：
因为 List 的 apply 方法始终返回同样的类型，但是元组里的或许类型不同，_N 数字是基于 1 的，而不是基于 0 的，因为对于拥有静态类型元组的其他语言，从1开始是传统的设定
4.set和map
Scala 致力于帮助你充分利用函数式和指令式风格两方面的好处，它的集合类型库于是就区分了集合类的可变和不可变。
数组始终是可变的，而列表始终不可变。
Scala 同样提供了可变和不可变的替代品，不过用了不同的办法。对于集和映射， Scala 把可变性建模在类继承中。
Scala 的 API 包含了集的一个基本特质： trait，特质这个概念接近于 Java 的接口
Scala 于是提供了两个子特质，一个是可变的集，另一个是不可变的集。
三个特质都共享同样的简化名， Set。然而它们的全称不一样，因为每个都放在不同的包里。 如下：
scala> var test_set=Set("沂", "水", "寒","城")
test_set: scala.collection.immutable.Set[String] = Set(沂, 水, 寒, 城)
scala> println(test_set.contains("ABC"))
false
scala> test_set+="ABC"
scala> println(test_set.contains("ABC"))
true
上述代码简单创建了一个缺省的不可变集合test_set，查询test_set是否包含某个元素，不包含的话将这个元素添加进去再次查询是否包含
对于set的+：
可变的和不可变的集都提供了+方法，但它们的行为不同。可变集将把元素加入自身，不可变集将创建并返回一个包含了添加元素的新集
如果想显式地定义可变集可以这样写：
import scala.collection.mutable.Set
对，没看错，这个就是上面的代码在scala的交互式shell中创建了test_set之后返回值的类型相对的类型在mutable和immutable之间的差别
如果你需要一个不可变的HashSet可以这么做：
import scala.collection.immutable.HashSet
val test_set0 = HashSet("张三", "李四","张飞","赵云","马岱")
println(test_set0 + "关羽")
如下：
scala> import scala.collection.immutable.HashSet
import scala.collection.immutable.HashSet
scala> val test_set0 = HashSet("张三", "李四","张飞","赵云","马岱")
test_set0: scala.collection.immutable.HashSet[String] = Set(张飞, 李四, 马岱, 赵云, 张三)
scala> println(test_set0 + "关羽")
Set(张飞, 李四, 马岱, 赵云, 关羽, 张三)
Map 是 Scala 里另一种有用的集合类。和集一样， Scala 采用了类继承机制提供了可变的和不可变的两种版本的 Map
scala.collection 包里面有一个基础 Map 特质和两个子特质 Map：可变的 Map 在scala.collection.mutable 里，不可变的在 scala.collection.immutable 里
简单的代码演示如下：
（1）可变版本的map创建
import scala.collection.mutable.Map
val test_map = Map[String, String]()
test_map("id_123")="刘备"
test_map("id_124")="孙权"
test_map("id_125")="曹操"
test_map+=("id_001"->"吕布")
test_map+=("id_002"->"关羽")
test_map+=("id_003"->"张飞")
结果如下：
scala> import scala.collection.mutable.Map
import scala.collection.mutable.Map
scala> val test_map = Map[String, String]()
test_map: scala.collection.mutable.Map[String,String] = Map()                        
scala> test_map("id_123")="刘备"
scala> test_map("id_124")="孙权"
scala> test_map("id_125")="曹操"
scala> test_map+=("id_001"->"吕布")
res10: test_map.type = Map(id_124 -> 孙权, id_001 -> 吕布, id_123 -> 刘备, id_125 -> 曹操)
scala> test_map+=("id_002"->"关羽")
res11: test_map.type = Map(id_124 -> 孙权, id_001 -> 吕布, id_123 -> 刘备, id_125 -> 曹操, id_002 -> 关羽)
scala> test_map+=("id_003"->"张飞")
res12: test_map.type = Map(id_124 -> 孙权, id_001 -> 吕布, id_003 -> 张飞, id_123 -> 刘备, id_125 -> 曹操, id_002 -> 关羽)
上面简单的代码中使用了两种方式赋值，前三个使用的是类似于字典键值对的方式赋值，因为映射原理就是这个，在scala的交互式shell中前三个输入后均没有返回结果，后三个使用的是书中的赋值方式直接使用操作方法+来添加元素，可以看到：每一次的添加元素之后都有返回在添加完该元素后当下的map是什么内容
（2）不可变版本的map创建
不可变版本的map在scala中是缺省的也就是说默认的创建的map如果没有显式地指明类型（即导入模块）那么都认为是不可变的map
val test_map0=Map("id_123"->"刘备","id_124"->"孙权","id_125"->"曹操","id_001"->"吕布","id_002"->"关羽","id_003"->"张飞")
结果如下：
scala> val test_map_new=Map(3->"刘备",4->"孙权",5->"曹操",0->"吕布",1->"关羽",2->"张飞")
test_map_new: scala.collection.immutable.Map[Int,String] = Map(0 -> 吕布, 5 -> 曹操, 1 -> 关羽, 2 -> 张飞, 3 -> 刘备, 4 -> 孙权)
简单的实现遍历输出：
scala> for (i<- 0 to 5)
     | println (test_map_new(i))
吕布
关羽
张飞
刘备
孙权
曹操
 

 
 
参考书籍：
 
 
 Scala编程中文完整版
 

 
 
    keep learning...
 
    上述提供的链接可以下载使用这本书，欢迎交流学习！