unity的list列表操作（结合Linq整理的一些高级写法SortWhere等）
Posted 苍狼王unity学院
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了unity的list列表操作（结合Linq整理的一些高级写法SortWhere等）相关的知识，希望对你有一定的参考价值。
简单的就不介绍了，增删改查等都是最基础的，下面讲一些高级写法和实用的
1、List.Sort（）
Unity的List.Sort有三种结果 1,-1,0分别是大，小，相等。默认List的排序是升序排序，如果要降序排序，也很简单，只需要在前面加一个负号即可。
List<int> m_temp = new List<int>()6,1,3,5,4;
// 升序
m_temp.Sort((x, y) => x.CompareTo(y));
// 降序
m_temp.Sort((x, y) => -x.CompareTo(y));
Console.WriteLine(m_temp);
// 6,5,4,3,1
2、2个列表比较
//对比相等(顺序也要相同)
List<int> listA1 = new List<int> 1, 2, 3, 4, 5, 6 ;
List<int> listA2 = new List<int> 1, 2, 3, 4, 5, 6 ;
//SequenceEqual方法需引用using System.Linq;
if (listA1.SequenceEqual(listA2))
Debug.Log("A1==A2");
else
[知识整理]Java集合 - List
一、实现List的几个类：
ArrayList、LinkedList、CopyOnWriteArrayList、Vector
二、几个List底层的数据结构：
ArrayList - 数组列表
LinkedList - 双链表列表和队列(同时实现List和Queue接口)
Vector - 数组列表(加锁)
CopyOnWriteArrayList - 数组列表(读写分离)
三、List的几种基本操作比较
1、add操作比较
1 /** 2 * 比较add操作 3 * @param minTimes 最小次数 4 * @param maxTimes 最大次数 5 * @param stepLen 步长 6 */ 7 public static void compareAddMethod(int minTimes, int maxTimes, int stepLen) { 8 Date begin = null; 9 Date end = null; 10 int times = minTimes; 11 while(times < maxTimes) { 12 13 //add: Vector 14 Vector<Integer> vector = new Vector<Integer>(); 15 begin = new Date(); 16 for(int i=0; i<times; i++) { 17 vector.add(i); 18 } 19 end = new Date(); 20 System.out.println("Vector add "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms"); 21 22 //add: ArrayList 23 ArrayList<Integer> arrayList = new ArrayList<Integer>(); 24 begin = new Date(); 25 for(int i=0; i<times; i++) { 26 arrayList.add(i); 27 } 28 end = new Date(); 29 System.out.println("ArrayList add "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms"); 30 31 //add: LinkedList 32 LinkedList<Integer> linkedList = new LinkedList<Integer>(); 33 begin = new Date(); 34 for(int i=0; i<times; i++) { 35 linkedList.add(i); 36 } 37 end = new Date(); 38 System.out.println("LinkedList add "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms"); 39 40 //add: CopyOnWriteArrayList 41 if(times<=100000) { 42 CopyOnWriteArrayList<Integer> copyOnWriteArrayList = new CopyOnWriteArrayList<Integer>(); 43 begin = new Date(); 44 for(int i=0; i<times; i++) { 45 copyOnWriteArrayList.add(i); 46 } 47 end = new Date(); 48 System.out.println("CopyOnWriteArrayList add "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms"); 49 } 50 51 System.out.println("-------------------------------"); 52 times+=stepLen; 53 }
运算结果：
minTimes = 0, maxTimes = 100000, stepLen = 30000
| times | Vector(ms) | ArrayList(ms) | LinkedList(ms) | CopyOnWriteArrayList(ms) |
| 0 | 0 | 0 | 0 | 0 |
| 30000 | 3 | 2 | 2 | 339 |
| 60000 | 3 | 4 | 1 | 992 |
| 90000 | 1 | 1 | 0 | 2257 |
结果分析：这里可以看出随着增加执行次数的增加CopyOnWriteArrayList所耗时增加较多，这是由于CopyOnWriteArrayList的读写策略造成。CopyOnWriteArrayList进行写操作，先对原底层数组进行复制，然后在复制数组进行写操作，最后复制数组对原数组引进行替换。这里的耗时消耗在复制数组上面，数组元素越多，所消耗的时间就越多。
minTimes = 0, maxTimes = 10000000, stepLen = 1000000
| times | Vector(ms) | ArrayList(ms) | LinkedList(ms) |
| 0 | 0 | 0 | 0 |
| 1000000 | 37 | 20 | 29 |
| 2000000 | 613 | 396 | 603 |
| 3000000 | 80 | 56 | 174 |
| 4000000 | 169 | 27 | 112 |
| 5000000 | 195 | 44 | 91 |
| 6000000 | 235 | 43 | 80 |
| 7000000 | 261 | 56 | 103 |
| 8000000 | 287 | 60 | 226 |
| 9000000 | 362 | 64 | 209 |
结果分析：这里ArrayList的插入比LinkedList快的原因是每次添加元素都是从数组末尾添加，数组直接通过索引在数组末尾添加元素，和LinkedList链表相比省却了寻找节点的时间，若是换成随机添加删除节点的操作，ArrayList就会比LinkedList慢了。而Vector虽然和ArrayList的底层数据结构一样(可变长的数组)，但是由于Vector是线程安全的，这导致执行效率会比较慢。
2、remove操作比较
1 /** 2 * 比较remove操作 3 * @param minTimes 最小次数 4 * @param maxTimes 最大次数 5 * @param stepLen 步长 6 */ 7 public static void compareRemoveMethod(int minTimes, int maxTimes, int stepLen) { 8 Date begin = null; 9 Date end = null; 10 int times = minTimes; 11 while(times < maxTimes) { 12 13 //remove: Vector 14 Vector<Integer> vector = new Vector<Integer>(); 15 for(int i=0; i<times; i++) 16 vector.add(i); 17 begin = new Date(); 18 for(int i=0; i<times; i++) 19 vector.remove(0); 20 end = new Date(); 21 System.out.println("Vector remove "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms"); 22 23 //remove: ArrayList 24 ArrayList<Integer> arrayList = new ArrayList<Integer>(); 25 for(int i=0; i<times; i++) 26 arrayList.add(i); 27 begin = new Date(); 28 for(int i=0; i<times; i++) 29 arrayList.remove(0); 30 end = new Date(); 31 System.out.println("ArrayList remove "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms"); 32 33 //remove: LinkedList 34 LinkedList<Integer> linkedList = new LinkedList<Integer>(); 35 for(int i=0; i<times; i++) 36 linkedList.add(i); 37 begin = new Date(); 38 for(int i=0; i<times; i++) 39 linkedList.remove(0); 40 end = new Date(); 41 System.out.println("LinkedList remove "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms"); 42 43 //remove: CopyOnWriteArrayList 44 if(times<=100000) { 45 CopyOnWriteArrayList<Integer> copyOnWriteArrayList = new CopyOnWriteArrayList<Integer>(); 46 for(int i=0; i<times; i++) 47 copyOnWriteArrayList.add(i); 48 begin = new Date(); 49 for(int i=0; i<times; i++) 50 copyOnWriteArrayList.remove(0); 51 end = new Date(); 52 System.out.println("CopyOnWriteArrayList remove "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms"); 53 } 54 55 System.out.println("-------------------------------"); 56 times+=stepLen; 57 } 58 }
运算结果：
minTimes = 0, maxTimes = 100000, stepLen = 30000
| times | Vector(ms) | ArrayList(ms) | LinkedList(ms) | CopyOnWriteArrayList(ms) |
| 0 | 0 | 0 | 0 | 0 |
| 30000 | 90 | 90 | 5 | 229 |
| 60000 | 356 | 351 | 1 | 921 |
| 90000 | 832 | 834 | 0 | 3199 |
结果分析：不出意外，CopyOnWriteArrayList的插入删除操作依旧是耗时最长的。值得注意的是，这里LinkedList的优势体现出来了，删除插入随机节点时链表操作比数组操作是更有效率的。
3、读取操作比较
1 /** 2 * 比较读取操作 3 * @param minTimes 最小次数 4 * @param maxTimes 最大次数 5 * @param stepLen 步长 6 */ 7 public static void compareReadMethod(int minTimes, int maxTimes, int stepLen) { 8 Date begin = null; 9 Date end = null; 10 int times = minTimes; 11 while(times < maxTimes) { 12 13 //remove: Vector 14 Vector<Integer> vector = new Vector<Integer>(); 15 for(int i=0; i<times; i++) 16 vector.add(i); 17 begin = new Date(); 18 for(int i=0; i<times; i++) 19 vector.get(i); 20 end = new Date(); 21 System.out.println("Vector get "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms"); 22 23 //get: ArrayList 24 ArrayList<Integer> arrayList = new ArrayList<Integer>(); 25 for(int i=0; i<times; i++) 26 arrayList.add(i); 27 begin = new Date(); 28 for(int i=0; i<times; i++) 29 arrayList.get(i); 30 end = new Date(); 31 System.out.println("ArrayList get "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms"); 32 33 //get: LinkedList 34 if(times<=100000) { 35 LinkedList<Integer> linkedList = new LinkedList<Integer>(); 36 for(int i=0; i<times; i++) 37 linkedList.add(i); 38 begin = new Date(); 39 for(int i=0; i<times; i++) 40 linkedList.get(i); 41 end = new Date(); 42 System.out.println("LinkedList get "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms"); 43 } 44 45 //get: CopyOnWriteArrayList 46 CopyOnWriteArrayList<Integer> copyOnWriteArrayList = new CopyOnWriteArrayList<Integer>(); 47 for(int i=0; i<times; i++) 48 copyOnWriteArrayList.add(i); 49 begin = new Date(); 50 for(int i=0; i<times; i++) 51 copyOnWriteArrayList.get(i); 52 end = new Date(); 53 System.out.println("CopyOnWriteArrayList get "+times+" times, cost: "+(end.getTime()-begin.getTime())+"ms"); 54 55 System.out.println("-------------------------------"); 56 times+=stepLen; 57 } 58 }
运算结果：
minTimes = 0, maxTimes = 100000, stepLen = 30000
| times | Vector(ms) | ArrayList(ms) | LinkedList(ms) | CopyOnWriteArrayList(ms) |
| 0 | 0 | 0 | 0 | 0 |
| 30000 | 2 | 2 | 334 | 0 |
| 60000 | 1 | 1 | 1313 | 0 |
| 90000 | 0 | 0 | 2945 | 0 |
结果分析：这里为什么LinkedList耗时比较长就不需要说明，这里Vector如果在同时频繁写操作的时候读写耗时便会比较长，而由于CopyOnWriteArrayList使用读写分离测的策略（写操作在复制数组中进行，读操作在原数组里面进行）平衡了线程安全和执行性能的矛盾。
四、小结
1、在List元素数量比较少的时候没必要纠结采用哪个List，因为规模小时根本体现不出什么差别，此时要注意是否选取线程安全的List，一般情况是不采取线程安全的List，而是在ArrayList和LinkedList之间选择。
2、Vector - 底层数据结构为可变长数组，数组长度按100%增长，线程安全，写效率低，读效率在多线程环境下也低。
3、ArrayList - 底层数据结构为可变长数组，数组长度按50%增长，线程不安全，随机插入删除操作效率低，随机读取修改元素效率高。
4、LinkedList - 底层数据结构为双向链表，线程不安全，随机插入删除操作效率高，随机读取修改元素效率低。
5、CopyOnWriteArrayList - 底层数据结构为可变长数组，线程安全，写效率低，读效率在多线程环境下也高，但是由于读写分离，读数据可能出现过时的情况（不可重复读）
6、这里CopyOnWriteArrayList读写分离的思想值得我学习。
以上是关于unity的list列表操作（结合Linq整理的一些高级写法SortWhere等）的主要内容，如果未能解决你的问题，请参考以下文章