keysearch

42> lists:keysearch(1, 1, [{1,hello},{2,value}]).
{value,{1,hello}}
43> lists:keysearch(3, 1, [{1,hello},{2,value}]).
false

在元组 TupleList 列表中搜索 第 N个元素比较等于 Key 的元组。 如果找到这样的元组，则返回 {value， Tuple}， 否则为 false。 

keysort 

44> lists:keysort(1, [{2,hello},{3,value},{1,key}]).     
[{1,key},{2,hello},{3,value}]
45> lists:keysort(2, [{2,hello},{3,value},{1,key}]).
[{2,hello},{1,key},{3,value}]

 返回一个列表，其中包含列表 TupleList1 的排序元素。排序是在元组的第 N个元素上执行的。排序是稳定的。

 keystore

46> lists:keystore(1,1, [{2,hello},{3,value},{1,key}],{4,none}).
[{2,hello},{3,value},{4,none}]
47> lists:keystore(5,1, [{2,hello},{3,value},{1,key}],{4,none}).
[{2,hello},{3,value},{1,key},{4,none}]

 返回 TupleList1 的副本，其中第一个 出现一个元组 T，其第 N个元素 如果存在这样的元组 T，则将等于 Key 替换为 NewTuple。 如果没有这样的元组 T，则 TupleList1 的副本，其中 [NewTuple] 已附加到末尾是 返回。

 keytake

48> lists:keytake(1,1, [{2,hello},{3,value},{1,key}]).          
{value,{1,key},[{2,hello},{3,value}]}
49> lists:keytake(4,1, [{2,hello},{3,value},{1,key}]).
false

 在元组 TupleList1 列表中搜索 第 N个元素比较等于 Key 的元组。返回 {value， Tuple， 如果找到这样的元组，则为 TupleList2}，否则为 false。TupleList2 是一个副本 的 TupleList1，其中第一次出现的元组已被删除。

 last

50> lists:last([{2,hello},{3,value},{1,key}]).        
{1,key}

 返回 List 中的最后一个元素。

 map

51> lists:map(fun(X)->X+2 end,[1,2,3,4]).
[3,4,5,6]

 获取从 A s 到 Bs 的函数，以及 As 和 通过应用生成 B的列表 列表中每个元素的函数。此功能是 用于获取返回值。评估顺序取决于 实现。

 mapfoldl 和 mapfoldr

52> lists:mapfoldl(fun(X, Sum) -> {2*X, X+Sum} end,0, [1,2,3,4,5]).
{[2,4,6,8,10],15}
53> lists:mapfoldr(fun(X, Sum) -> {2*X, X+Sum} end,0, [1,2,3,4,5]).
{[2,4,6,8,10],15}

 将 map/2和 foldl/3(或foldr/3) 的操作合并到一个通道中。

  max

54> lists:max([1,2,3,4,5]).                                        
5

 返回 List 的第一个元素，该元素比较 大于或等于 List 的所有其他元素。

member 

55> lists:member(2,[1,2,3,4,5]).
true
56> lists:member(6,[1,2,3,4,5]).
false

 如果 Elem 与某个元素匹配，则返回 true 的 List，否则为 false。

 merge3

60> lists:merge3([2,4],[1,2,3,4,5],[3,7]).
[1,2,2,3,3,4,4,5,7]

 返回通过合并 List1、List2 和 List3 形成的排序列表。在计算此值之前，必须对 List1、List2 和 List3 的所有内容进行排序 功能。当两个元素比较相等时，List1 中的元素，如果有这样的元素， 在另一个元素之前选取，否则该元素 from List2 在 List3 中的元素之前被选中。

min 

61> lists:min([1,2,3,4,5]).               
1

 返回 List 的第一个元素，该元素比较 小于或等于 List 的所有其他元素。

nth 

62> lists:nth(3,[1,2,3,4,5]).
3
63> lists:nth(3, [a, b, c, d, e]).
c

 返回 List 的第 N个元素。

 nthtail

64> lists:nthtail(3, [a, b, c, d, e]).
[d,e]
65> tl(tl(tl([a, b, c, d, e]))).
[d,e]
66> lists:nthtail(0, [a, b, c, d, e]).
[a,b,c,d,e]
67> lists:nthtail(5, [a, b, c, d, e]).
[]

 返回 List 的第 N个尾部， 即 List 的子列表从 N+1 开始，一直持续到列表末尾。

 partition

68>  lists:partition(fun(A) -> A rem 2 == 1 end, [1,2,3,4,5,6,7]).
{[1,3,5,7],[2,4,6]}
69> lists:partition(fun(A) -> is_atom(A) end, [a,b,1,c,d,2,3,4,e]).
{[a,b,c,d,e],[1,2,3,4]}

 Partitions List 分为两个列表，其中第一个列表 list 包含 Pred（Elem） 返回 true 的所有元素， 第二个列表包含 Pred（Elem） 返回 false 的所有元素。

prefix 

71> lists:prefix([1,2,3], [1,2,3,4,5]). 
true
72> lists:prefix([1,4,3], [1,2,3,4,5]). 
false

 如果 List1 是 List2 的前缀，则返回 true，否则返回 false

 reverse

73> lists:reverse([1,2,3,4,5]).                                    
[5,4,3,2,1]

 返回一个列表，其中包含 List1 中的元素，顺序相反。

74> lists:reverse([1,2,3,4,5],[6,7,8]). 
[5,4,3,2,1,6,7,8]

 返回一个列表，其中包含 List1 中的元素，顺序相反，并附加了 tailTail。

search 

75> lists:search(fun(X)->X>3 end,[1,2,3,4]). 
{value,4}
76> lists:search(fun(X)->X>3 end,[1,2,3]).   
false

 如果列表中有一个 Value，使得 Pred（Value） 返回 true，则为第一个这样的 Value 返回 {value， Value}， 否则返回 false。Pred 函数必须返回 布尔值。

seq 

77> lists:seq(1, 10).
[1,2,3,4,5,6,7,8,9,10]
78> lists:seq(1, 20, 3).
[1,4,7,10,13,16,19]
79> lists:seq(1, 0, 1). 
[]
80> lists:seq(10, 6, 4).
[]
81> lists:seq(1, 1, 0). 
[1]

 返回以 From 开头的整数序列，其中包含 将 Incr 添加到前一个元素，直到到达或传递 To（在后一种情况下，To 不是 序列）。Incr 默认为 1。

sort 

82> lists:sort([1, 4, 2,5,7,6]).
[1,2,4,5,6,7]

 返回一个列表，其中包含 List1 的已排序元素。

 split

83> lists:split(3,[1, 4, 2,5,7,6]).
{[1,4,2],[5,7,6]}

 将 List1 拆分为 List2 和 List3。List2 包含 前 N 个元素和 List3 剩余的元素（第 N个尾巴）。

 splitwith

84> lists:splitwith(fun(A) -> A rem 2 == 1 end, [1,2,3,4,5,6,7]).
{[1],[2,3,4,5,6,7]}
85> lists:splitwith(fun(A) -> is_atom(A) end, [a,b,1,c,d,2,3,4,e]).
{[a,b],[1,c,d,2,3,4,e]}

 根据 Pred 将 List 划分为两个列表。splitwith/2 的行为就好像是 定义如下：

 sublist

86> lists:sublist([1,2,3,4], 2, 2).
[2,3]
87> lists:sublist([1,2,3,4], 2).   
[1,2]
88> lists:sublist([1,2,3,4], 2, 5).
[2,3,4]
89> lists:sublist([1,2,3,4], 5, 2).
[]

 返回 List1 的子列表，从 位置 1 和（最大）Len 元素。是的 Len 不会出现超过 list，在这种情况下，将返回整个列表。

返回 List1 的子列表，该子列表从 Start 开始，并具有（最大）Len 元素。Start+Len 超过 列表。

subtract 

90> lists:subtract("123212", "212").
"312"

 返回一个新列表 List3，它是 List1 的副本，并遵循以下过程： 对于 List2 中的每个元素，它第一次出现 在 List1 中被删除