向量的元素要求都是同类型的，而列表（list）与向量不同，可以组合多个不同类型的对象。类似于C语言中的结构体（struct）类型。
1、创建列表
从技术上讲，列表就是向理。之前我们接触过的普通向量都称为“原子型”（atomic）向量，就是说，向量的元素已经是最小的、不可再分的。而列表则属于“递归型”（recursive）向量。
以一个雇员数据库作为第一个例子。对于每个雇员，我们存储其姓名、工资，以及一个布尔变量，表示是否工会成员。这三个变量有三个不同的类型：字符串、数值
> j <- list(name="joe", salary=55000,union=T)
> j
$name
[1] "joe" $salary
[1] 55000 $union
[1] TRUE >
R语言中列表各个组件的名称叫做标签（tags），如上面的代码salary。实际上标签是可选的，也可以不指定。如下：
> jalt <- list("joe",5500,T)
> jalt
[[1]]
[1] "joe"
[[2]]
[1] 5500
[[3]]
[1] TRUE
>
但一般来说都会给各个部分取名，而不使用这些默认的数值，这样使代码更清晰而且不容易犯错误，在使用的时候，标签的名字可以简写，只写出前几个字母，只要不引起歧议，R都能识别：
> j
$name
[1] "joe" $salary
[1] 55000 $union
[1] TRUE > j$sal
[1] 55000
>
因为列表是向理，因此可以用vector（）来创建列表。
> z <- vector(mode = "list")
> z
list()
> z[["abc"]] <- 3
> z
$abc
[1] 3 >
2、列表的常规操作
#列表索引 （访问列表的组件有很多种方法）返回值是c的数据类型
> j$name
[1] "joe"
> j[["name"]]
[1] "joe"
> j[[1]]
[1] "joe"
>
使用单中括号和双重中括号都可以提取列表的元素，但是与普通（原子型）向量索引相比，两者存在很大的不同。使用单中括号[]返回的是一个新的列表，它是原列表的子列表。
> j[1:2]
$name
[1] "joe" $salary
[1] 55000 > j2 <- j[2]
> j2
$salary
[1] 55000 > class(j2)
[1] "list"
> str(j2)
List of 1
$ salary: num 55000
>
对原列表的取子集操作返回一个新的列表，新的列表由原列表的前两个元素组成。这里说“返回”是因为中括号也是一个函数。就类似于“+”这种操作符，看起来不像函数，但实际上是函数。
而双重中括号“[[]]”一次只能提取列表的一个组件，返回值是组件本身的类型，而不是列表。
> j[[1:2]]
Error in j[[1:2]] : subscript out of bounds
> j2a <- j[[2]]
> j2a
[1] 55000
> class(j2a)
[1] "numeric"
>
#增加或删除列表元素
很多情况下，需要增加和删除元素，尤其是涉及由列表组成的数据类型时，比如数据框和R中的类（class）。
>#增加新的元素
> z <- list(a="abc",b=12)
> z
$a
[1] "abc" $b
[1] 12 > z$c <- "sailing" #增加新的组件
> z
$a
[1] "abc" $b
[1] 12 $c
[1] "sailing" >
使用索引增加元素
> z
$a
[1] "abc" $b
[1] 12 $c
[1] "sailing" > z[[4]] <-28
> z
$a
[1] "abc" $b
[1] 12 $c
[1] "sailing" [[4]]
[1] 28 > z[5:7] <- c(FALSE,TRUE,TRUE)
> z
$a
[1] "abc" $b
[1] 12 $c
[1] "sailing" [[4]]
[1] 28 [[5]]
[1] FALSE [[6]]
[1] TRUE [[7]]
[1] TRUE >
删除列表元素，直接将元素NULL就可以了
> z
$a
[1] "abc" $b
[1] 12 $c
[1] "sailing" [[4]]
[1] 28 [[5]]
[1] FALSE [[6]]
[1] TRUE [[7]]
[1] TRUE > z[[2]] <- NULL
> z
$a
[1] "abc" $c
[1] "sailing" [[3]]
[1] 28 [[4]]
[1] FALSE [[5]]
[1] TRUE [[6]]
[1] TRUE
删除z$b之后，它之后的元素索引全部减1，如原来的z[[4]]变成了z[[3]]。还可以把多个列表拼接成一个。
> c(list("joe",55000,T),list(5))
[[1]]
[1] "joe"
[[2]]
[1] 55000
[[3]]
[1] TRUE
[[4]]
[1] 5
#获取列表长度
> j
$name
[1] "joe" $salary
[1] 55000 $union
[1] TRUE > length(j)
[1] 3
>
3、访问列表元素和值
如果一个列表和各个元素含有标签，就可以使用names（）获取它的标签
> names(j)
[1] "name" "salary" "union"
还可以使用unlist()函数获取列表的值
> ulj <- unlist(j)
> ulj
name salary union
"joe" "55000" "TRUE"
> class(ulj)
[1] "character"
unlist()返回值是一个向量，在本例中是一个字符向量。而且向量的元素名就来自原列表的标签。若列表内都是数值，哪么unlist()返回的也就是数值向量，若列表内是字符与数值混合，哪unlist()返回的是字符类型的向量。
> ulj <- unlist(j)
> ulj
name salary union
"joe" "55000" "TRUE"
> class
function (x) .Primitive("class")
> class(ulj)
[1] "character"
各种类型的优先级排序是：
NULL<raw<逻辑类型<整型<实数类型<复数类型<列表<表达式(把配对列表（pairlist）当作普通列表)
去除元素的名称的方法如下：
>#方法一
> wu <- list(a=5,b="xyz")
> names(wu) <-NULL
> wu
[[1]]
[1] 5 [[2]]
[1] "xyz" >#方法二
> wu <- list(a=5,b="xyz")
> wu
$a
[1] 5 $b
[1] "xyz" > wu <- unname(wu)
> wu
[[1]]
[1] 5 [[2]]
[1] "xyz"
4、在列表上使用apply系列函数
使用lapply()和sapply()这两个函数，可以很方便地在列表上应用函数。
#lapply()和sapply()的使用
lapply()代表list apply，与矩阵的apply()函数的用法相似，对列表（或强制转换成列表的向量）的每个组件执行给定的函数，并返回另一个列表。
> lapply(list(1:3,25:29),median)
[[1]]
[1] 2 [[2]]
[1] 27
R分别对1：3和25：29求中位数，返回由2，27组成的列表。
如果想得到lapply()返回的列表可以转化为矩阵或向量的形式，这时候可以选择使用sapply()代表simplified lapply）：
> sapply(list(1:3,25:29),median)
[1] 2 27
在以上的例子中，我们在一个向量上执行一个向量化的函数，返回一个新的向量，然后将向量整理成矩阵的形式。如果使用sapply()函数就可以直接输出矩阵。
5、递归型列表
列表可以是递归的（recursive)，即列表的组件也可以是列表。
> b <-list(u=5, v= 12)
> c <-list(w = 13)
> a <-list(b,c)
> a
[[1]]
[[1]]$u
[1] 5 [[1]]$v
[1] 12 [[2]]
[[2]]$w
[1] 13 > length(a)
[1] 2
这段代码生成一个包含两个组件的列表，每个组件本身也都是列表。
> c(list(a=1,b=2,c=list(d=5,e=9)))
$a
[1] 1 $b
[1] 2 $c
$c$d
[1] 5 $c$e
[1] 9 > c(list(a=1,b=2,c=list(d=5,e=9)),recursive=T)
a b c.d c.e
1 2 5 9
>
拼接函数c()有一个可选参数recursive，决定在拼接列表的时候，是否把原列“压平”，就是把所有组件的元素都提取出来，组合成一个向量。
第一条命令中，recursive参数取黙认值FALSE，得一个递归型列表，其中组件c是另一个列表。
第二条命令中，recursive参数值为TRUE，得到一个向量（也可以说是列表），只有名称还带有原来递归的特征。（注意recursive参数为TRUE反而得到非递归的列表，不要弄混）
end.