erlang lists模块函数使用大全(copy)

一，带函数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) ->

如果list中至少有一个元素作为pred函数的参数执行，结果返回true，那么any函数返回true，

例子

lists:any(fun(e) -> is_integer(e)

end,[q,2,a,4]).

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) ->

将list1中的每个元素去在fun中执行，然后返回一个元素，最后返回的这些元素组成一个列表，

返回给list2

lists:map(fun(x)->[x,x] end,

[a,b,c]).

结果：[[a,a],[b,b],[c,c]]

6，flatmap(fun, list1) ->

这个函数和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,

这个函数相当于将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的元素组成。

注意，返回的是一个元组

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)

如果fun函数返回true，则排序是从小到大的顺序，否则，从大到小。

其中fun有两个参数。

lists:sort(fun(a,b)-> false 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) ->

按照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,

[4,3,2,2,1]

20，zipwith(combine, list1, list2)

将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() |

将这个列表里面的元素拼成一个字符串，然后返回

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() >=

我的理解是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) ->

就是将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) ->

这个函数适合处理列表里面的元素是元组的情况

删除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是一样。

lists:keyfind("zhangjing",2,list1)

结果：{name,"zhangjing"}

11，keymember(key, n, tuplelist) ->

如果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个元素进行排序的

list2 =

[{nick,"zj"},{nick,"zs"}].

lists:keymerge(2,list1,list2).

[{name,"zhangjing"},

 {name,"zhangsan"},

 {nick,"zj"},

 {nick,"zs"}]

13，keyreplace(key, n, tuplelist1, newtuple) ->

在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} |

这个函数和keyfind差不多，就是返回值的结构不一样

也是在tuplelist中找一个tuple，这个tuple的第n个元素和key一样。

[{name,"zhangjing"},{name,"zhangsan"}]

lists:keysearch("zhangjing",2,list1).

{value,{name,"zhangjing"}}

15，keysort(n, tuplelist1) ->

对tuplelist1中的tuple按照第n个元素进行排序，然后返回一个新的顺序的tuplelist。

不过这种排序是固定的。

list1 = [{name,"zhangsan"},{name,"zhangjing"}].

lists:keysort(2,list1).

16，keystore(key, n, tuplelist1, newtuple) ->

这个函数和keyreplace函数比较像，不同的是，这个keystore在没有找到对应的tuple时，

会将这个newtuple追加在这个tuplelist1的最后。

[{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} |

在tuplelist1中找tuple，这个tuple的第n个元素和key一致，如果找到了这么一个tuple

那么返回，{value,

tuple, tuplelist2} 其中tuplelist2是去掉tuple的tuplelist1.

[{name,"zhangjing"},{name,"zhangsan"},{name,"lisi"}].

lists:keytake("zhangjing",2,list1).

{value,{name,"zhangjing"},[{name,"zhangsan"},{name,"lisi"}]}

18，last(list) -> last

返回：list最后一个元素

lists:last(list1).

{name,"lisi"}

19，max(list)

-> max

取出list中最大的元素，一般list是整型时比较适合。

lists:max([1,10,15,6]).

15

20，member(elem, list) ->

如果elem和list中的某个元素匹配（相同），那么返回true，否则返回false

lists:member({sex,"1"},[{sex,"1"},{sex,"2"},{sex,"3"}]).

21，merge(listoflists) -> list1

listoflists是一个列表，里面由子列表构成

这个函数的功能就是将这些子列表合并成一个列表。

lists:merge([[{11}],[{22}],[{33}]]).

[{11},{22},{33}]

22，merge(list1, list2) -> list3

list1和list2分别是一个列表，这个函数的功能是将这两个列表合并成一个列表。

lists:merge([11],[22]).

[11,22]

 23,

merge3(list1, list2, list3) -> list4

将list1，list2，list3合并成一个列表

lists:merge3([11],[22],[33,44]).

[11,22,33,44]

24，min(list) -> min

返回list中的最小的元素，和max函数对应

lists:min([1,2,3]).

1

25，nth(n, list)

-> elem

返回list中的第n个元素。

lists:nth(2,[{name,"zhangsan"},{name,"lisi"},{name,"wangmazi"}]).

26，nthtail(n, list) -> tail

返回list列表中第n个元素后面的元素

lists:nthtail(3, [a, b, c, d, e]).

[d,e]

27，prefix(list1, list2) ->

如果list1是list2的前缀(也就是说list1和list2前部分相同)，那么返回true，否则返回false

28，reverse(list1) -> list2

将list1反转

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

[4,3,2,1]

29,reverse(list1, tail) -> list2

将list1反转，然后将tail接在反转list1的后面，然后返回

lists:reverse([1, 2, 3, 4], [a, b, c]).

[4,3,2,1,a,b,c]

30，seq(from, to) ->

seq

其中from和to都是整型，这个函数返回一个从from到to的一个整型列表。

lists:seq(1,10).

[1,2,3,4,5,6,7,8,9,10]

31，seq(from, to, incr) -> seq

返回一个整型列表，这个列表的后一个元素比前一个元素大incr。

lists:seq(1,10,4).

[1,5,9]

32，sort(list1) ->

将list1中的元素从小到大排序，然后返回新的一个列表。

lists:sort([3,2,1]).

33，split(n, list1) ->

{list2, list3}

将list1分成list2和list3

其中list2包括list1的前n个元素，list3包含剩余的。

lists:split(3,[1,2,3,4,5]).

{[1,2,3],[4,5]}

这个函数和partition数有区别，partition是遍历全部的list，而splitwith在遍历时遇到false的情况

则马上结束遍历，返回结果。

34，sublist(list1, len) ->

返回从第一个元素到第len个元素的列表，这个len大于list1的长度时，返回全部。

lists:sublist([1,2,3,4,5,6],3).

35，sublist(list1, start, len) ->

返回从list1的第start个位置开始，后面len个元素的列表。

lists:sublist([1,2,3,4], 2,

2).

[2,3]

36，subtract(list1, list2) ->

等同于 list1 --

这个函数功能是返回一个list1的副本，对于list2中的每个元素，第一次在list1副本中出现时被删掉。

lists:subtract("112233","12").

"1233"

37，suffix(list1, list2) ->

如果list1是list2的后缀，那么返回true，否则返回false

lists:suffix("22","1122").

38，sum(list) ->

number()

返回list中每个元素的和。其中list中的元素都应该是number()类型的。

lists:sum([1,2,3,4]).

10

39，ukeymerge(n, tuplelist1,

tuplelist2) -> tuplelist3

tuplelist1和tuplelist2里面的元素都是元组

将tuplelist1和tuplelist2合并，合并的规则是按照元组的第n个元素，如果第n个元素有相同的，那么保留tuplelist1中

的，删除tuplelist2中的。

40，ukeysort(n, tuplelist1) ->

tuplelist1里面的元素都是元组

这个函数也同样返回一个元素是元组的列表，返回的这个列表是按照元组的第n个元素来排序的，如果元组中有出现

第n个元素相同的情况，删除掉后面的一个元组。

lists:ukeysort(1,[{name,"zhangsan"},{sex,"male"},{name,"himan"}]).

[{name,"zhangsan"},{sex,"male"}]

41，umerge(listoflists) ->

list1

这个函数和merge唯一不同的就是，里面不能出现相同的元素，如果出现相同的，那么删除之，只保留一个唯一的

lists:umerge([[1,2],[2,3]]).

分析：由于[[1,2],[2,3]]中merge后是[1,2,2,3],这个时候有两个相同的元素2，所以只保存一个2，所以结果是[1,2,3].

42，umerge3(list1, list2, list3) -> list4

将list1, list2, list3合并

和merge3不同的是返回的list4中不能出现重复的元素

lists:merge3([1,2],[2,3],[3,4]).

[1,2,3,4]

43，unzip(list1) -> {list2, list3}

list1里面的元素是元组，每个元组由两个元素组成，返回值list2包含每个list1中每个元组的第一个元素

返回值list3包含每个list1中每个元组的第二个元素。

lists:unzip([{name,"zhangsan"},{sex,"male"},{city,"hangzhou"}]).

{[name,sex,city],["zhangsan","male","hangzhou"]}

44，unzip3(list1) -> {list2, list3, list4}

list1里面的元素是元组，每个元组由三个元素组成，返回值list2包含每个list1中每个元组的第一个元素；

返回值list3包含每个list1中每个元组的第二个元素；返回值list4包含每个list1中每个元组的第三个元素。

lists:unzip3([{name,"zhangsan","apple"},{sex,"male","banana"},{city,"hangzhou","orange"}]).

{[name,sex,city],

 ["zhangsan","male","hangzhou"],

 ["apple","banana","orange"]}

注意，最终返回的是一个元组。

45，usort(list1)

将list1按照从小到大的顺序排序，如果排序后有重复的元素，删除重复的，只保存一个唯一的。

lists:usort([4,3,2,1,2,3,4]).

46，zip(list1,

list2) ->

将两个长度相同的列表合并成一个列表

list3是里面的每一个元组的第一个元素是从list1获取的，而每个元组的第二个元素是从list2中获取的

lists:zip([name,sex,city],["zhangsan","male","hangzhou"]).

[{name,"zhangsan"},{sex,"male"},{city,"hangzhou"}]

注意，如果list1和list2长度不一致，那么这个函数将会报错。

47，zip3(list1,

list2, list3) ->

将三个长度相同的列表合并成一个列表

每个元组的第三个元素是从list3中获取的。

lists:zip3([name,sex,city],["zhangsan","male","hangzhou"],["nick","1","zhejiang"]).

[{name,"zhangsan","nick"},

 {sex,"male","1"},

 {city,"hangzhou","zhejiang"}]