5> lists:member(3,[1,2,3]).
检查元素是否存在list中（这是个bif函数，效率较高）
lists:sort(List1) -> List2
6> lists:sort([2,3,1]).
[1,2,3]
lists元素排序，排序从小到大，如果想自定义排序规则，可以使用lists:sort/2
lists:sort(Fun, List1) -> List2
7> lists:sort(fun(A,B)-> A>=B end,[2,3,1]).
[3,2,1]
处理TupleList的lists函数
TupleList是元素是tuple的list，erlang提供了一些接口专门处理这类数据。
lists:keymember(Key, N, TupleList) -> boolean()
8> lists:keymember(b,1,[{a,1,1},{b,1,1},{c,1,1}]).
true
检查list中是否有第N位置为Key的tuple（这是个
bif函数，效率较高）
lists:keyfind(Key, N, TupleList) -> Tuple | false
9> lists:keyfind(b,1,[{a,1,1},{b,1,1},{c,1,1}]).
{b,1,1}
返回list中第N位置为Key的tuple，找不到返回false
1. 找到第一个匹配的tuple就返回，找不到返回false
2. 这个接口可以替代lists:keysearch(Key, N, TupleList) 使用
3. 这是个bif函数，效率较高
lists:keysearch(Key, N, TupleList)的官方文档中有这么一句：
This function is retained for backward compatibility. The function lists:keyfind/3 (introduced in R13A) is in most cases more convenient.
意思就是说lists:keysearch/3只是为了保持向后兼容，使用lists:keyfind/3会更方便
lists:keytake(Key, N, TupleList1) -> {value, Tuple, TupleList2} | false
10> lists:keytake(b,1,[{a,1,1},{b,1,1},{c,1,1}]).
{value,{b,1,1},[{a,1,1},{c,1,1}]}
返回list中第N位置为Key的tuple，并返回找到的tuple和剩下的TupleList，找不到返回false
注：找到第一个匹配的tuple就返回
lists:keyreplace(Key, N, TupleList1, NewTuple) -> TupleList2
11> lists:keyreplace(b,1,[{a,1,1},{b,1,1},{c,1,1}], {b,2,2}).
[{a,1,1},{b,2,2},{c,1,1}]
替换list中第N位置为Key的tuple（只替换找到的第一个tuple）
lists:keystore(Key, N, TupleList1, NewTuple) -> TupleList2
12> lists:keystore(b,1,[{a,1,1},{b,1,1},{c,1,1}],{b,2,2}).
[{a,1,1},{b,2,2},{c,1,1}]
替换list中第N位置为Key的tuple，返回新的TupleList。没找不到将NewTuple附加到原有TupleList后面并返回，这是和lists:keyreplace/4的区别
注： 只替换找到的第一个tuple
lists函数小评
BIF函数
lists函数有一些已经被优化成bif函数，效率较高。有以下几个：
lists:member/2, lists:reverse/2, lists:keymember/3, lists:keysearch/3, lists:keyfind/3
性能不佳的函数
下面是一些实现性能不佳的函数，不建议比较长的list使用，短的list无所谓了：
1）lists:foldr/3
非尾递归实现，如果顺序很重要的话，可以lists:reverse/1后lists:foldl/3，或者lists:foldl/3后lists:reverse/1
lists:foldr类似lists:foldl，不同的是foldr从列表最后一个元素开始，非尾递归实现，不建议长列表使用
foldr(F, Accu, [Hd|Tail]) ->
F(Hd, foldr(F, Accu, Tail));
foldr(F, Accu, []) when is_function(F, 2) ->
Accu.
2）lists:append/2
实现为append(L1, L2) -> L1 ++ L2. 其中，L1 ++ L2会遍历 L1，如果一定要使用就把短的list放左边
3）lists:subtract/2
实现为subtract(L1, L2) -> L1 -- L2. 其中，--的复杂度和它的操作数的长度的乘积成正比，替代方案如下：
Set = gb_sets:from_list(L2),
[E || E <- L1, not gb_sets:is_element(E, Set)].
注：如果L1中包含重复的元素，那么以上代码跟--的效果不同，--不会删掉所有重复的元素
13> [1,2,3,4,2] -- [2,3].
[1,4,2]
4）lists:flatten/1
这个是list扁平化函数，这个存在性能开销，erlang的官方文档也有说明：
lists:flatten/1 builds an entirely new list. Therefore, it is expensive, and even more expensive than the ++ (which copies its left argument, but not its right argument).
它会拷贝DeepList中所有嵌套的元素，生成一个新的列表，代价比较高，长列表不建议使用。
flatten(List) when is_list(List) ->
do_flatten(List, []).
flatten(List, Tail) when is_list(List), is_list(Tail) ->
do_flatten(List, Tail).
do_flatten([H|T], Tail) when is_list(H) ->
do_flatten(H, do_flatten(T, Tail));
do_flatten([H|T], Tail) ->
[H|do_flatten(T, Tail)];
do_flatten([], Tail) ->
Tail.
5）lists中非尾递归实现的函数：
lists:map/2, lists:flatmap/2, lists:zip/2, lists:delete/2, lists:sublist/2, lists:sublist/3, lists:takewhile/2, lists:concat/1
lists:flatten/1, lists:keydelete/3, lists:keystore/4, lists:zf/2, lists:mapfoldl/3, lists:mapfoldr/3, lists:foldr/3
带匿名函数的lists函数
lists有很多函数都带有匿名函数的参数项，有以下几个函数：
lists:foldl/3, lists:foldr/3, lists:foreach/2, lists:sort/2, lists:usort/2, lists:merge/3, lists:umerge/3, lists:keymap/3, lists:flatmap/2
匿名函数的使用有什么问题呢？
普通函数在erlang编译期就做了优化，匿名函数则要在代码执行期动态生成，造成一定的消耗。虽然现在匿名函数的过程已优化成本地函数了，但根据上下文取值，地址跳转还是不能避免。可能以后erlang会继续对匿名函数做改进
对lists匿名函数的处理的优化：
1）函数赋值
第一个问题就是不要在循环中写这样的代码：
14> [lists:foldl(fun(X, Sum) -> X + Sum end, 0, [1,2,3,4,5]) || X <- lists:seq(1,5)].
[15,15,15,15,15]
以上代码中，每次循环匿名函数都会重新生成，可以如下修改：
17> Fun = fun(X, Sum) -> X + Sum end.
#Fun<erl_eval.12.82930912>
18> [lists:foldl(Fun, 0, [1,2,3,4,5]) || X <- lists:seq(1,5)].
[15,15,15,15,15]
匿名函数Fun只要生成一次，作为参数放到lists函数即可
2）函数实体化
所谓实体化就是把匿名函数写成本地函数，然后再作为参数传给lists函数，如下：
test() ->
lists:foldl(fun sum/2, 0, [1,2,3,4,5]).
sum(X, Sum) ->
X + Sum.
这里也有匿名函数动态生成的问题，有兴趣的可以打印汇编码看看具体情况
2015/4/22补充：经测试，这种方式效率稍微变低，原因是，每次调用时对比多一次函数调用[ i_call_only_f ]
这里讨论另一种调用方式 fun M:F/A
test() ->
lists:foldl(fun ?MODULE:sum/2, 0, [1,2,3,4,5]).
sum(X, Sum) ->
X + Sum.
如果是这种调用，执行过程中，会先调用bif函数 erlang:make_fun/3 找到这个导出函数的代码地址，然后生成匿名函数结构数据，再像函数外部调用一样执行代码。如果将匿名函数赋值，然后再执行，单算执行效率的话就要比前面两种高。不过整体计算是比较低效的，因为erlang:make_fun/3 是根据函数名，方法名，参数个数去查找导出函数表，导出函数表是哈希桶实现，还是有一点效率开销。
说到lists，不得不说列表解析，在之前的文章也谈过列表解析。列表解析的基本形式如下：
[Expr(E) || E <- List]
简单的例子如下：
19> [X+1||X<-[1,2,3,4,5]].
[2,3,4,5,6]
在列表解析表达式中，|| 左边用以生成列表元素，相当于构造器；右边由赋值语句和条件语句构成，也可以只有赋值语句。实际上，列表解析在编译时会优化一个本地函数，没必要过于担心它的性能。
使用列表解析注意以下问题就好：
20> [X+1||X<-[1,2,3,4,5]],ok.
ok
在上面的例子中，erlang对列表解析做了优化，如果列表解析的结果明显不会被用到，列表根本不会被构建。在这里，列表解析后加个ok可以激活erlang的优化
list列表元素打乱
列表元素打乱，就是将列表中元素的顺序随机化，打乱原来的顺序。
方法很简单，如下：
shuffle(L) ->
List1 = [{random:uniform(), X} || X <- L],
List2 = lists:keysort(1, List1),
[E || {_, E} <- List2].
注：random:uniform() 的随机化种子放在进程字典中。为了提高随机化，以上函数调用前或调用进程启动时执行一次 random:seed(erlang:now())
2016/2/29 补充 list列表元素打乱
参考：http://blog.csdn.net/mycwq/article/details/32160581
http://www.erlang.org/doc/efficiency_guide/listHandling.html
erlang有两种复合结构，tuple和list，两者的区别是tuple子元素的个数是固定不变的，声明后就不能改变了；而list是可变的，可以通过[H|T]来取出或插入新元素。上篇文章讲了tuple相关的内容，本篇就讲erlang list方面的知识，主要说一些基本操作和常用的list函数，再讲一些可以优化的点。
文章目录列表（list）1. 概念2. 定义3. 拼接列表定义案例解释情景1：向列表中加入 一个元素情景2：向列表中加入 多个元素4. 提取列表元素
列表（list）
1. 概念
列表的作用通常是将相同种类的物体放到一起，比如：
我们去超市买的东西，买了10个苹果，3个牛奶，1本书
一个商品就是列表中的一个元素，那么我们用列表来表示一下
> ThingsToBuy = [{apple, 10}, {milk, 3}, {book, 1}].
2. 定义
用 [...] 来创建列表
列表中元素
一，带函数Pred
1, all(Pred, List) -> boolean()
如果List中的每个元素作为Pred函数的参数执行，结果都返回true，那么all函数返回true，
否则返回false
lists:all(fun(E) -> true end,[1,2,3,4]).
2, any(Pred, List) -> boolean()
为探索erl内部的tuple和list的构造和内部实现，我们可以从list_to_tuple/1这个erlang的bif函数说起。
先看看$ERL_TOP/erts/emulator/beam/bif.c文件中list_to_tuple/1函数的C源码。
为了便于说明，对源码做了少量修改，并增加了一些变量打印。
list_to_tuple/1的内部实现
...
Erlang里通过尾递归方式对列表中元素依次进行操作时，程序员们采用的方法总是先在尾递归中将处理后的元素加在已处理列表的头部，最后通过lists:reverse(List)来恢复原来次序。为什么不直接以自然顺序将表头元素加到已处理列表的尾部呢？这里面都是有故事的。先看两个函数：1
-module(list_time).
lists ，maps和record是erlang最为常用的数据结构，lists使用方便简单，maps则查询高效，record则需要预定义，可扩展性差，各有各的优。本文做一下lists和maps的性能对比（再对比一下dict），代码如下（record操作不便则不做比较）。
%%通过注释部分代码做以下测试
%%timer:tc(lib_test, test_struct, [10000...
今天无聊写了一个列表拼接两种方式的对比，主要是对比一下用“++”和“|”拼接列表的速度，书上说，“++”拼接列表是极为低效的操作。这里我用代码实现了一下，分别用两种方法生成N个零的列表：
%%列表拼接对比
listsTimeCon(N)->
{TimeOne,_} = timer:tc(test,listsCon1,[N]),
{TimeTwo,_} = timer:tc(te...
当提到Erlang中list的++操作符时，我们常会想到它的性能问题。
有些人知道++操作比较耗时，就改用函数append来代替。
到底++操作和append函数之间有什么区别？
我们来查看一下它们在Erlang源码及C源码中的实现。
在$ERL_TOP/lib/stdlib/src/lists.erl可以找到如下代码：
[plain] view
不要放任列表自右侧增长！此外还应该注意++运算符只是lists:append/2的一个别名，这个问题对该函数同样适用。
2）、- -运算符
- -运算符是lists:substract/2 的别名。这个运算符不常用：它的作用是从左侧列表中删除右侧列表中的元素。
如果元素顺序不是很重要，那么更为高效的方法是先排序，再调用ordersets:su
声明：本文章是对erlang手册的部分内容的中文翻译(有些地方没有完全按原文翻译)，版权归原作者所有……由于本人的英语水平有限（翻译此手册的目的之一就是提高英语水平^0^），所以翻译有误乃正常现象，如有发现请及时提醒，THX……
谨以此文献给初学erlang并且不喜欢看英文手册的朋友……
Lists
lists
之所以先从lists说起，因为大部分erlang的使用都离不开list，就连erlang中的string类型的数据其实也不过是一个list，erlang为什么对list那么情有独钟，作为一个并不深入这种语言的使用者我也说不好，不过我个人感觉，相比数组，list更方便于这种函数型语言对一个数据进行解析创建和修改，搭配于tuple（元组）也更利于一个数据的封装。
