一，帶函式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的元素組成。
注意，返回的是一個元組
例子
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)-> 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) -> 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"}]).
結果：
true

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]
[2,1,3,4]

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"}]).
結果
{name,"lisi"}

 

26，nthtail(N, List) -> Tail
返回List列表中第N個元素後面的元素
例子
lists:nthtail(3, [a, b, c, d, e]).
結果
[d,e]

27，prefix(List1, List2) -> boolean()
如果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) -> List2
將List1中的元素從小到大排序，然後返回新的一個列表。
例子
lists:sort([3,2,1]).
結果
[1,2,3]

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) -> List2
返回從第一個元素到第Len個元素的列表，這個Len大於List1的長度時，返回全部。
例子
lists:sublist([1,2,3,4,5,6],3).
結果
[1,2,3]

 

35，sublist(List1, Start, Len) -> List2
返回從List1的第Start個位置開始，後面Len個元素的列表。
例子
lists:sublist([1,2,3,4], 2, 2).
結果
[2,3]

 

36，subtract(List1, List2) -> List3
等同於 List1 -- List2
這個函式功能是返回一個List1的副本，對於List2中的每個元素，第一次在List1副本中出現時被刪掉。
例子
lists:subtract("112233","12").
結果
"1233"

 

37，suffix(List1, List2) -> boolean()
如果List1是List2的字尾，那麼返回true，否則返回false
例子
lists:suffix("22","1122").
結果
true

 

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) -> TupleList2
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,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) -> List2
將List1按照從小到大的順序排序，如果排序後有重複的元素，刪除重複的，只儲存一個唯一的。
例子
lists:usort([4,3,2,1,2,3,4]).
結果
[1,2,3,4]

46，zip(List1, List2) -> List3
將兩個長度相同的列表合併成一個列表
List3是裡面的每一個元組的第一個元素是從List1獲取的，而每個元組的第二個元素是從List2中獲取的
例子
lists:zip([name,sex,city],["zhangsan","male","hangzhou"]).
結果
[{name,"zhangsan"},{sex,"male"},{city,"hangzhou"}]
注意，如果List1和List2長度不一致，那麼這個函式將會報錯。

 

47，zip3(List1, List2, List3) -> List4
將三個長度相同的列表合併成一個列表
List4是裡面的每一個元組的第一個元素是從List1獲取的，而每個元組的第二個元素是從List2中獲取的
每個元組的第三個元素是從List3中獲取的。
例子
lists:zip3([name,sex,city],["zhangsan","male","hangzhou"],["nick","1","zhejiang"]).
結果
[{name,"zhangsan","nick"},
 {sex,"male","1"},
 {city,"hangzhou","zhejiang"}]