一，帶函數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"}]
![GridView終極用法(一)[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)