erlang （Lists 操作模块）学习笔记(二)

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?中被删除