1.原始的for循环删除集合元素的时候有可能会漏掉某个元素
测试代码：
/**
* 假设需要删除集合中的所有的"A"元素
* 如果使用原始的for循环，那么就可能会漏删
*/
List<String> list = new ArrayList<>();
		
		list.add("A");
		list.add("A");
		list.add("B");
		for(int i=0; i<list.size(); i++) {
			if("A".equals(list.get(i))) {
				list.remove(i);
			}
		}
		System.out.println(list);

输出结果：

[A, B]

可以看到集合中只有一个"A"被删了，第二个"A"却还在。


其实解决办法也很简单，在删除元素之后再加一行代码i--就解决了
2.增强型for循环删除集合元素会报出ConcurrentModificationException异常
修改一下上面的测试代码
List<String> list = new ArrayList<>();
		
		list.add("A");
		list.add("A");
		list.add("B");
		for(String item : list) {
			if("A".equals(item)) {
				list.remove(item);
			}
		}
		System.out.println(list);

打印结果是ConcurrentModificationException异常。

增强型for循环其实是编译器认可的语法，在到了虚拟机那边只认迭代器循环，所以在编译为.class文件的时候，最终还是变成了迭代器循环。通过反编译得到如下代码：
List<String> list = new ArrayList();
        list.add("A");
        list.add("A");
        list.add("B");
        Iterator var3 = list.iterator();

        while(var3.hasNext()) {
            String item = (String)var3.next();
            if ("A".equals(item)) {
                list.remove(item);
            }
        }

迭代器这块比较复杂，我们从源码上慢慢探索。

list.iterator()其实际上是获得了一个内部类Itr对象,这个类实现了Iterator接口。循环所用到的hasnext()，next()方法都是在这个类中实现的。

以下代码来自openJDK1.8的AbstractList类中



以下代码来自ArrayList


大概理一下抛出异常的思路：

迭代器循环每次调用next方法，next方法中第一步会先调用checkForComodification方法，checkForComodification方法中会校验modCount和expectedModCount两个变量是否一样（我把这两个变量理解为版本号），如果不一样就会抛出ConcurrentModificationException异常。

modCount是集合的成员变量，初始值为1，当创建迭代器对象的时候，modCount会赋值给expectedModCount。当调用了list本身的remove方法的时候，会让expectedModCount自增，却不改变modCount。于是到了下一次迭代器的next方法去取集合元素的时候会先执行checkForComodification()方法判断版本号是否一致，这时候集合的版本号和迭代器的版本号不一致就抛出了异常。

而如果是调用迭代器的remove方法，它会先调用集合的remove方法，然后执行cursor- -，再把modCount赋值给expectedModCount。这样一来既保证了下一次迭代的时候不会漏过任何元素，也避免了next方法校对版本号的时候抛出异常
3.在循环中删除集合元素的正确方法
在循环中删除元素的正确方法是用迭代器的remove方法
List<String> list = new ArrayList<>();
        list.add("A");
        list.add("A");
        list.add("B");
        for(Iterator<String> i = list.iterator(); i.hasNext(); ) {
            String item = i.next();
            if ("A".equals(item)) {
            	//这里调用迭代器的rermove方法而不是集合的remove方法
                i.remove();
            }
        }
        System.out.println(list);

也许你会觉得上面的写法太麻烦，“我只是想删除集合中的所有A元素，有没有更优雅的写法呢”。答案是有的，在Java8以后，我们就可以用一行代码来完美代替上面的写法了：
list.removeIf(item -> "A".equals(item));

实际上removeIf方法内部也是用了迭代器循环


4.为什么要设计“快速报错”机制
这是一种集合的保护机制，为了防止多个线程同时修改同一个集合的内容。我们先假设没有快速失败机制，当一条线程正在迭代遍历某个集合的过程中，另一个线程介入其中，并且删除了集合内的某个对象，那么就出问题了：就像上面说过的一样，元素被删除后，集合缩容，第一个线程要进行下一次迭代时，就会漏掉一个元素。这种数据不同步所带来的问题可能再当前步骤下不会出现异常，直到在后续的某个代码环节中才会暴露出问题，从而给我们排查定位异常带来难度。



而有了快速失败机制后，一个线程的删除了集合中的某个元素，集合的modCount+1，另一个集合调用迭代器的next方法，发现版本号不一致，于是就直接抛出异常，终止迭代，让我们能够快速的定位到问题所发生的时间和位置。
ConcurrentHashMap、CopyOnWriteArrayList、CopyOnWriteArraySet都使用了可以避免ConcurrentModificationException的机制。这个话题我们下次再研究吧。

本文来自：http://www.cnblogs.com/TrueElement/archive/2012/01/13/2321328.html









int[] num0 = { 28, 32, 14 };
int[] num1 = {14,15,16};


如上，我想把num0中不包含于num1的元素都找出来，其正确结果应该是28,32。早上看到原来linq可以写多个from字句，之后就想到了这样的写法：


int[] num0 = { 28, 32, 14 };
int[] num1 = {14,15,16};

var qq = from n1 in num0
from n2 in num1
where n1 != n2
select n1;



结果，我错了，调试了一下才知道自己想当然了。结果如下：



总共进行了3 * 3,9次比较，那个语句把所有成立的n1都选进去了。

所以还是老老实实用contains好了

int[] num0 = { 28, 32, 14 };
int[] num1 = { 14, 15, 16 };

var bb = from n1 in num0
where num1.Contains(n1) == false
select n1;


另外，推荐一个工具：LinqPad，我的这个例子就是用linqPad 调试的，上面那个结果显示使用了语句：qq.Dump();

网址：http://www.linqpad.net/

下载:

      for .net 3.5:http://www.linqpad.net/GetFile.aspx?LINQPad.exe

      for .net 4.0:http://www.linqpad.net/GetFile.aspx?LINQPad4.zip

这个工具还不错，自带了许多例子，还可以写入自己的语句运行。

另外，微软官方的Official Visual Studio 2008 C# Samples里面的LINQ - Sample Queries也是不错的，带了许多例子，几乎所有的linq特性都有，还可以执行。

网址：http://code.msdn.microsoft.com/csharpsamples

LINQ - Sample Queries 截图：



 

2012年1月13日16:56:23 更新：

后来又找到了Except、Intersect、Union、Distinct等方法，终于可以排除一个集合中那些某个属性的值存在于另一个几个中元素属性的方法了。

按照Example上的例子，大概可以如此实现：


public void Linq53() {
    List<Product> products = GetProductList();
    List<Customer> customers = GetCustomerList();

var productFirstChars =
from prod in products
select prod.ProductName[0];
var customerFirstChars =
from cust in customers
select cust.CompanyName[0];

var productOnlyFirstChars = productFirstChars.Except(customerFirstChars);

    Console.WriteLine("First letters from Product names, but not from Customer names:");
foreach (var ch in productOnlyFirstChars) {
        Console.WriteLine(ch);
    }
}

初学python，因为需要，就用 python 简单实现了下，各种语言都一样，需要递归。
# A Recursion function 递归函数

def RecursionFunc(arr1,arrList):
    if (arrList):
        string = []
        for x in arr1:
            for y in arrList[0]:
                string.append(x + y)
        result = RecursionFunc(string,arrList[1:])
        return result
    else:
        return arr1


line_List = [['aa','bb','cc'],['dd','ee','ff'],['gg','hh']]

caseslist = RecursionFunc(line_List[0], line_List[1:])

#每条case
for ele in caseslist:
    print(ele)
    print('***************************************\n')

前几天，有个同事问我说怎么找出两个List集合中重复的元素，我当时就说一个集合在外面循环，一个集合在内循环，如果两个元素相等了，就找出来了，我回来一想还是不对，要是数据非常多，这样循环下去，服务器会卡死的，最后我想了想，用以下两种方法:
   List<String> list1 = new ArrayList<>();
            List<String> list2 = new ArrayList<>();
            list1.add("a");
            list1.add("b");
            list1.add("c");
            list1.add("d");
            list2.add("d");
            list2.add("f");
            list2.add("g");
            list2.add("h");
            list2.add("k");

第一种方法：这是把list1集合放到list2中
 list2.addAll(list1);
        HashMap<String,Integer> mapList=new HashMap<>();
        for(String str:list2){
            int count=0;
            if(mapList.get(str)!=null){
                count=mapList.get(str)+1;
            }
            mapList.put(str,count);
        }
        System.out.println("重复的元素是：");
        for(String key:mapList.keySet()){
            if(mapList.get(key)!=null && mapList.get(key)>0){
                System.out.println(key);
            }
        }

第二种方法：
   Map<String,String> map=new HashMap<>();
        String str=null;
        String stp=null;
        String psp=null;
        for(int i=0;i<list1.size();i++){
            str=list1.get(i);
            map.put(str,str);
        }
        for(String spt:map.keySet()){
            System.out.println("key:"+spt+"-----------value:"+map.get(spt));
        }
        System.out.println("==========="+map.entrySet());
        for(int i=0;i<list2.size();i++){
            stp=list2.get(i);
            if(stp.equals(map.get(str))){
                System.out.println("重复的元素："+stp);
            }
        }

以上就是我用的两种方法,由于是个菜鸟，所以大神们有更好的方法望指点，在下感激不尽！

补充：

下面是java8新特性去list集合重复的方法，非常简单，比前的方法简单多了，

首先是将两个集合合并在一起，然后就是下面的方法：（list2是合并以后的集合，spa是去重复的新集合）
 List<String> spa = list2.stream()
                    .distinct()
                    .collect(Collectors.toList());

这种方法最简单，代码少，清晰明了！！！！

补充：

java8的方法中可以找出相同的元素 代码如下：
	public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("a");
        list.add("b");
        System.out.println(getDuplicateElements(list.stream()));
    }

    public static <T> List<T> getDuplicateElements(Stream<T> stream) {
        return stream.collect(Collectors.groupingBy(p -> p,Collectors.counting()))
                .entrySet().stream() // Set<Entry>转换为Stream<Entry>
                .filter(entry -> entry.getValue() > 1) // 过滤出元素出现次数大于 1 的 entry
                .map(entry -> entry.getKey()) // 获得 entry 的键（重复元素）对应的 Stream
                .collect(Collectors.toList()); // 转化为 List
    }

执行结果如下：
[a, b]

由于在方法中使用了泛型，所以可以接收任意类型的流，注意在如果是对象，别忘了重写其 hashCode() 和 equals() 方法。