erlanglists系列函数功能
⼀，带函数Pred
1, all(Pred, List) -> boolean()
如果List中的每个元素作为Pred函数的参数执⾏，结果都返回true，那么all函数返回true，
否则返回false
例⼦：
lists:all(fun(E) -> true end,[1,2,3,4]).
结果
true
2, any(Pred, List) -> boolean()
如果List中⾄少有⼀个元素作为Pred函数的参数执⾏，结果返回true，那么any函数返回true，
否则返回false
例⼦
lists:any(fun(E) -> is_integer(E) end,[q,2,a,4]).
结果
true
3，dropwhile(Pred, List1) -> List2
将List1列表中的元素作为参数执⾏Pred函数，如果返回true，将其丢弃，最后返回剩余元素
组成的列表
例⼦
lists:dropwhile(fun(E) -> is_atom(E) end,[a,1,2,a,b]).
结果
[1,2,a,b]
4，filter(Pred, List1) -> List2
返回⼀个列表，这个列表是由List1中执⾏Pred函数返回true的元素组成。
lists:filter(fun(E) -> is_integer(E) end,[q,2,a,4]).
结果：
[2,4]
5，map(Fun, List1) -> List2
将List1中的每个元素去在Fun中执⾏，然后返回⼀个元素，最后返回的这些元素组成⼀个列表，
返回给List2
例⼦：
lists:map(fun(X)->[X,X] end, [a,b,c]).
结果：[[a,a],[b,b],[c,c]]
6，flatmap(Fun, List1) -> List2
这个函数和map⽐较类似，相当于执⾏了
lists:append(lists:map(List1)).
也就是把map的结果进⾏append处理
例⼦：
lists:flatmap(fun(X)->[X,X] end, [a,b,c]).
结果：[a,a,b,b,c,c]
7，foldl(Fun, Acc0, List) -> Acc1
Fun这个函数有两个参数
第⼀个参数是List中的元素，第⼆个参数是Fun函数执⾏完后的返回值，这个参数第⼀次执⾏时
就是Acc0
例⼦：对[1,2,3,4,5]求和
lists:foldl(fun(X, Sum) -> X + Sum end, 0, [1,2,3,4,5]).
结果：15
执⾏过程：⾸先，Fun第⼀次执⾏时，X的值取列表List的第⼀个元素1，Sum取0,
Fun第⼆次执⾏时，X的值取列表List的第⼆个元素2，Sum取Fun第⼀次的返回值
依次轮推，直到List中每个元素执⾏完，最后foldl返回最后⼀次的结果。
8，foldr(Fun, Acc0, List) -> Acc1
foldr这个函数和foldl⽐较相似
不过是Fun执⾏时，X的值先取List的最后⼀个，然后取倒数第⼆个。
9，foreach(Fun, List) -> ok
以List中的每个元素为参数执⾏Fun函数，执⾏顺序按照List中元素的顺序，这个函数最后返回ok。是单边的例⼦ lists:foreach(fun(X)->
%%using X to do somethings
%%
end,List)
10，keymap(Fun, N, TupleList1) -> TupleList2
对TupleList1中的每个元素的第N项作为参数在Fun中处理，然后这个第N项最后就被替换为Fun执⾏完返回的值
例⼦：
List1 = [{name,"zhangjing"},{name,"zhangsan"}].
lists:keymap(fun(X)->
list_to_atom(X)
end,2,List1).
结果：
[{name,zhangjing},{name,zhangsan}]
11，mapfoldl(Fun, Acc0, List1) -> {List2, Acc1}
这个函数等于是把map和foldl函数结合起来。将List1中的每⼀个元素执⾏Fun函数，执⾏后花括号的第⼀个值作为返回值返回，第⼆个值作为参数传给Fun，作为下⼀次⽤。
例⼦：
lists:mapfoldl(fun(X, Sum) -> {2*X, X+Sum} end,
0, [1,2,3,4,5]).
{[2,4,6,8,10],15}
12，mapfoldr(Fun, Acc0, List1) -> {List2, Acc1}
这个函数相当于将map和foldr结合起来
13，merge(Fun, List1, List2) -> List3
这个函数的功能也是把List1和List2合并到⼀起，只不过是List1和List2的元素要作为参数在Fun中执⾏，如果
Fun返回true，那么返回值就是List1在前，List2在后。否则，反之。
例⼦
lists:merge(fun(A,B)-> false end, [3,4],[2,1]).
结果
[2,1,3,4]
14，partition(Pred, List) -> {Satisfying, NotSatisfying}
这个函数的功能是将List分成两个List1和List2，List1是将List元素作为参数去Pred函数中执⾏返回true的元素组成，
List2由Pred返回false的元素组成。
注意，返回的是⼀个元组
例⼦merge函数
lists:partition(fun(A) -> A rem 2 == 1 end, [1,2,3,4,5,6,7]).
结果
{[1,3,5,7],[2,4,6]}
15，sort(Fun, List1) -> List2
如果Fun函数返回true，则排序是从⼩到⼤的顺序，否则，从⼤到⼩。
其中Fun有两个参数。
例⼦
lists:sort(fun(A,B)-> A>B end,[1,2,3]).
结果
[3,2,1]
16，splitwith(Pred, List) -> {List1, List2}
将List分成List1和List2，
List1由List中元素在Pred函数返回true的组成，但是有⼀点，如果遇到为false的，则将剩下的元素
全部放到List2中，List1中就只有前⾯为true的。
例⼦
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]}
17，takewhile(Pred, List1) -> List2
List1中的元素element依次执⾏Pred(element)，如果返回true，则获取这个元素，直到有元素执⾏Pred(element)返回false
例⼦
lists:takewhile(fun(E)-> is_atom(E) end,[a,b,1,e,{c},[d]]).
结果
[a,b]
18,umerge(Fun, List1, List2) -> List3
这个函数和merge不同的是当Fun返回true时，返回的List3中不能出现相同的元素
疑问：但是当Fun返回false时，List3中可以有相同的元素。
例⼦(Fun返回true的情况)
lists:umerge(fun(A,B)-> true end,[1,2],[2,3]).
结果
[1,2,3]
(Fun为false的情况)
lists:umerge(fun(A,B)-> false end,[1,2],[2,3]).
[2,3,1,2]
好神奇，竟然2有重复
19，usort(Fun, List1) -> List2
按照Fun函数进⾏排序，如果Fun返回true，那么只返回List1的第⼀个元素
如果Fun返回false，那么List1从⼤到⼩排序
例⼦1
lists:usort(fun(A,B) -> true end, [1,2,2,3,4]).
结果
[1]
例⼦2
lists:usort(fun(A,B) -> false end, [1,2,2,3,4]).
结果
[4,3,2,2,1]
20，zipwith(Combine, List1, List2) -> List3
将List1和list2中的每个元素执⾏Combine函数，然后返回⼀个元素，List3就是由Combine函数返回的⼀个个元素组成的。
功能和map有点像，但是这⾥是对两个列表的操作。
例⼦
lists:zipwith(fun(X, Y) -> X+Y end, [1,2,3], [4,5,6]).
结果
[5,7,9]
21，zipwith3(Combine, List1, List2, List3) -> List4
将List1和list2，list3中的每个元素执⾏Combine函数，然后返回⼀个元素，List4就是由Combine函数返回的⼀个个元素组成的。功能和map有点像，但是这⾥是对三个列表的操作。
例⼦
lists:zipwith3(fun(X, Y, Z) -> X+Y+Z end, [1,2,3], [4,5,6],[7,8,9]).
结果
[12,15,18]
⼆，不带函数Pred
1，append(ListOfLists) -> List1
ListOfLists都是由List组成的，⽽List⼀个列表，⾥⾯可以是任何类型的元素
这个函数就是将ListOfLists⾥⾯的所有列表的元素按顺序编成⼀个列表
提⽰：ListOfLists⾥⾯的元素必须都是列表才能⽤这个函数
例⼦
lists:append([[1, 2, 3], [a, b], [4, 5, 6]]).
结果：
[1,2,3,a,b,4,5,6]
2，append(List1, List2) -> List3
将List1和List2两个列表连接起来，组成⼀个列表，然后返回新的这个列表
这个函数的功能等同于List1 ++ List2
例⼦
lists:append("abc", "def").
结果
"abcdef"
3，concat(Things) -> string()
这⾥的Things是⼀个列表，⾥⾯由atom() | integer() | float() | string()
将这个列表⾥⾯的元素拼成⼀个字符串，然后返回
例⼦
lists:concat([doc, '/', file, '.', 3]).
结果
doc/file.3"
4，delete(Elem, List1) -> List2
List1是由很多Element组成的，这个函数的功能是在List1中寻第⼀个和Elem元素⼀样的，
然后删除之，返回删除后新的列表。
例⼦
lists:delete({name,"zhangsan"},[{name,"lisi"},{name,"zhangsan"},{name,"wangmazi"})).
结果
[{name,"lisi"},{name,"wangmazi"}]
5，duplicate(N, Elem) -> List
返回⼀个由N个Elem组成的列表。
例⼦
lists:duplicate(5,"test").
结果
["test","test","test","test","test"]
6，flatlength(DeepList) -> integer() >= 0
我的理解是DeepList就是列表⾥⾯套列表
计算列表的长度，即⽤flatten函数将DeepList转化成List后元素的个数
这个函数和length()的区别就是：
length函数是得到列表元素的个数，
⽽flatlength函数是先将DeepList转化成List后的个数
譬如说List = [1,2,[3,4]]这个列表⽤
length(List)求的值是：3
lists:flatlength(List)求的值是：4
其实lists:flatlength(List) = length(flatten(List))
7，flatten(DeepList) -> List
将DeepList变成只有term()的list
例⼦：
lists:flatten([[a,a],[b,b],[c,c]]).
结果：
[a,a,b,b,c,c]
8，flatten(DeepList, Tail) -> List
就是将DeepList变成只有term的List后，在后⾯再加⼀个Tail。
例⼦：
lists:flatten([[a,a],[b,b],[c,c]],[dd]).
结果：
[a,a,b,b,c,c,dd]
9,keydelete(Key, N, TupleList1) -> TupleList2
这个函数适合处理列表⾥⾯的元素是元组的情况
删除TupleList1中元素第N个元素和Key⼀致的元素，只删除第⼀个⼀样的，后⾯⼀样的不删除例⼦：
List = [{name,"zhangjing"},{sex,"male"},{name,"zhangsan"},{sex,"male"}],
lists:keydelete("male",2,List)
结果：
[{name,"zhangjing"},{name,"zhangsan"},{sex,"male"}]
10,keyfind(Key, N, TupleList) -> Tuple | false
查TupleList中的⼀个Tuple，如果查到，返回，如果没有查到，则返回false
这个Tuple必须满⾜第N个元素和key是⼀样。
例⼦：
List1 = [{name,"zhangjing"},{name,"zhangsan"}].
lists:keyfind("zhangjing",2,List1)
结果：{name,"zhangjing"}
11，keymember(Key, N, TupleList) -> boolean()
如果TupleList中的元素中存在第N个元素和key⼀致，则返回true，否则返回false
例⼦：
List1 = [{name,"zhangjing"},{name,"zhangsan"}].
lists:keymember("zhangjing",2,List1).
结果：true
12，keymerge(N, TupleList1, TupleList2) -> TupleList3
将TupleList1和TupleList2进⾏混合，组成⼀个TupleList，
新组成的TupleList是按照Tuple的第N个元素进⾏排序的
例⼦：
List1 = [{name,"zhangjing"},{name,"zhangsan"}].
List2 = [{nick,"zj"},{nick,"zs"}].
lists:keymerge(2,List1,List2).
结果：
[{name,"zhangjing"},
{name,"zhangsan"},
{nick,"zj"},
{nick,"zs"}]
13，keyreplace(Key, N, TupleList1, NewTuple) -> TupleList2
在TupleList1的Tuple中出第N个元素和Key⼀致，然后⽤NewTuple将这个Tuple替换掉，如果没有到，则返回原来的TupleList1
例⼦：
List1 = [{name,"zhangjing"},{name,"zhangsan"}]
lists:keyreplace("zhangjing",2,List1,{nickname,"netzj"}).
结果：
[{nickname,"netzj"},{name,"zhangsan"}]
14，keysearch(Key, N, TupleList) -> {value, Tuple} | false
这个函数和keyfind差不多，就是返回值的结构不⼀样
也是在TupleList中⼀个Tuple，这个Tuple的第N个元素和Key⼀样。
例⼦：
List1 = [{name,"zhangjing"},{name,"zhangsan"}]
lists:keysearch("zhangjing",2,List1).
结果：
{value,{name,"zhangjing"}}
15，keysort(N, TupleList1) -> TupleList2
对TupleList1中的Tuple按照第N个元素进⾏排序，然后返回⼀个新的顺序的TupleList。
不过这种排序是固定的。
例⼦：
List1 = [{name,"zhangsan"},{name,"zhangjing"}].
lists:keysort(2,List1).
结果：
[{name,"zhangjing"},{name,"zhangsan"}]
16，keystore(Key, N, TupleList1, NewTuple) -> TupleList2
这个函数和keyreplace函数⽐较像，不同的是，这个keystore在没有到对应的Tuple时，
会将这个NewTuple追加在这个TupleList1的最后。
例⼦：
List1 = [{name,"zhangsan"},{name,"zhangjing"}].
到了的情况
lists:keystore("zhangjing",2,List1,{name,"netzhangjing"}).
[{name,"netzhangjing"},{name,"zhangsan"}]
没有到的情况
lists:keystore("zhanging",2,List1,{name,"netzhangjing"}).
[{name,"zhangjing"},{name,"zhangsan"},{name,"netzhangjing"}]
17，keytake(Key, N, TupleList1) -> {value, Tuple, TupleList2} | false
在TupleList1中Tuple，这个Tuple的第N个元素和Key⼀致，如果到了这么⼀个Tuple
那么返回，{value, Tuple, TupleList2} 其中TupleList2是去掉Tuple的TupleList1.
例⼦：
List1 = [{name,"zhangjing"},{name,"zhangsan"},{name,"lisi"}].
lists:keytake("zhangjing",2,List1).
结果：
{value,{name,"zhangjing"},[{name,"zhangsan"},{name,"lisi"}]}
18，last(List) -> Last
返回：List最后⼀个元素
例⼦：
List1 = [{name,"zhangjing"},{name,"zhangsan"},{name,"lisi"}].
lists:last(List1).
结果：
{name,"lisi"}
19，max(List) -> Max
取出List中最⼤的元素，⼀般List是整型时⽐较适合。
例⼦：
lists:max([1,10,15,6]).
结果：
15
20，member(Elem, List) -> boolean()
如果Elem和List中的某个元素匹配（相同），那么返回true，否则返回false
例⼦
lists:member({sex,"1"},[{sex,"1"},{sex,"2"},{sex,"3"}]).

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。