各位。已知有一个ArrayLst 集合。里面有重复的值，现在的需求
是怎么把这个集合中的重复的值去掉，剩下的保留到原集合中。

1. package cn.itcast.list.test;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Iterator;
   
5. import java.util.List;
   
6. 
   
7. public class ArrayListTest2 {
   
8. 
   
9.         /**
   
10.          * @param args
    
11.          */
    
12.         public static void main(String[] args) {
    
13. 
    
14.                 /*
    
15.                  * 练习2：定义功能，请除去ArrayList集合中的重复元素。
    
16.                  *
    
17.                  *
    
18.                  */
    
19.                
    
20.                 List list = new ArrayList();
    
21.                
    
22.                 list.add("abc1");
    
23.                 list.add("abc4");
    
24.                 list.add("abc2");
    
25.                 list.add("abc1");
    
26.                 list.add("abc4");
    
27.                 list.add("abc4");
    
28.                 list.add("abc2");
    
29.                 list.add("abc1");
    
30.                 list.add("abc4");
    
31.                 list.add("abc2");
    
32.                
    
33.                 System.out.println(list);
    
34.                 singleElement2(list);
    
35.                 System.out.println(list);
    
36.         }
    
37.        
    
38.         /**
    
39.          * 去除重复元素方式二：
    
40.          * 思路：
    
41.          * 1，最后唯一性的元素也很多，可以先定义一个人容器用于存储这些唯一性的元素。
    
42.          * 2，对原有容器进行元素的获取，并到临时容器中去判断是否存在。容器本身就有这个功能，判断元素是否存在。
    
43.          * 3，存在就不存储，不存在就存储。
    
44.          * 4，遍历完原容器后，临时容器中存储的就是唯一性的元素。
    
45.          *
    
46.          */
    
47.         public static void singleElement2(List list){
    
48.                
    
49.                 //1, 定义一个临时容器。
    
50.                 List temp = new ArrayList();
    
51.                
    
52.                 //2, 遍历原容器。
    
53.                 for (Iterator it = list.iterator(); it.hasNext();) {
    
54.                         Object obj = (Object) it.next();
    
55.                        
    
56.                         //3, 在临时容器中判断遍历到的元素是否存在。
    
57.                         if(!temp.contains(obj)){
    
58.                                 //4,如果不存在，就存储到临时容器中。
    
59.                                 temp.add(obj);
    
60.                         }
    
61.                        
    
62.                 }
    
63.                 //5, 将原容器清空。
    
64.                 list.clear();
    
65.                 //6, 将临时容器中的元素都存储到原容器中。
    
66.                 list.addAll(temp);
    
67.                
    
68.         }
    
69.        
    
70.        
    
71.         /**
    
72.          *  定义功能。去除重复元素。
    
73.          */
    
74.         public static void singleElement(List list){
    
75.                 for(int x=0; x<list.size()-1; x++){
    
76.                         Object obj_x = list.get(x);
    
77.                         for(int y=x+1; y<list.size(); y++){
    
78.                                
    
79.                                 if(obj_x.equals(list.get(y))){
    
80.                                         list.remove(y);
    
81.                                         y--;
    
82.                                 }
    
83.                         }
    
84.                 }
    
85.                
    
86.         }
    
87.        
    
88. 
    
89. }
    

复制代码

import java.util.*;

/*
去除ArrayList集合中的重复元素。
思路:1先定义一个新的ArrayList集合,作为临时容器,


*/

class ArrayListTest
{

        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
        public static void main(String[] args)
        {
                ArrayList al = new ArrayList();
                al.add("java01");
                al.add("java02");
                al.add("java01");
                al.add("java02");
                al.add("java01");               
                sop(al);               
                al = singleElement(al);
                sop(al);               

        }

        public static ArrayList singleElement(ArrayList al)
        {
                //定义一个临时容器。
                ArrayList newAl = new ArrayList();

                Iterator it = al.iterator();

                while(it.hasNext())
                {
                        Object obj = it.next();

                        if(!newAl.contains(obj))
                                newAl.add(obj);

                }

                return newAl;
        }
}

刚才按错了,还没写完就按发表了,⊙﹏⊙b汗
import java.util.*;

/*
去除ArrayList集合中的重复元素。
思路:1先定义一个新的ArrayList集合,作为临时容器,
        2 对旧集合进行遍历,每次取出旧集合里面的元素时,先判断一下在临时容器中有没有存在这个元素.
        3如果没有存在就把这个元素存放到临时容器里面,如果存在了就不存了
       4 遍历完旧集合后,把临时容器(也就是新定义的集合)返回去给那个需要去掉重复元素的集合就OK了
          下面的例子可能对你有帮助,你看一下


*/

class ArrayListTest
{

        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
        public static void main(String[] args)
        {
                ArrayList al = new ArrayList();

                al.add("java01");
                al.add("java02");
                al.add("java01");
                al.add("java02");
                al.add("java01");               
                sop(al);               
                al = singleElement(al);
                sop(al);               

        }

        public static ArrayList singleElement(ArrayList al)
        {
                //定义一个临时容器。
                ArrayList newAl = new ArrayList();

                Iterator it = al.iterator();

                while(it.hasNext())
                {
                        Object obj = it.next();

                        if(!newAl.contains(obj))
                                newAl.add(obj);

                }

                return newAl;
        }
}

    思路
   1. 再定义一个ArrayList集合
   2. 迭代老集合 ，将迭代到的老集合中的元素，去新集合中 看看包含不包含
   3. 如果不包含，就将老集合中的元素，存储到新集合
   4. 如果包含，就不存
   5. 迭代老集合完毕，新集合中，就是去掉重复元素的结果

1. import java.util.*;
   
2. public class ArrayListTest {
   
3.         public static void main(String[] args) {
   
4.                 ArrayList al = new ArrayList();
   
5.                 al.add("mayi");
   
6.                 al.add("xiaoqiang");
   
7.                 al.add("xiaoming");
   
8.                 al.add("mayi");
   
9.                 al.add("xiaoqiang");
   
10.                 System.out.println(al);
    
11.                 al = method(al);
    
12.                 System.out.println(al);
    
13.         }
    
14.         public static ArrayList method(ArrayList al){
    
15.                 //1. 再定义一个ArrayList集合
    
16.                 ArrayList newal = new ArrayList();
    
17.              // 2. 迭代老集合 ，将迭代到的老集合中的元素，去新集合中 看看包含不包含
    
18.                 Iterator it = al.iterator();
    
19.                 while( it.hasNext()){
    
20.                 //        3. 如果不包含，就将老集合中的元素，存储到新集合
    
21.                         Object o = it.next();
    
22.                         if(!newal.contains(o)){
    
23.                                 newal.add(o);
    
24.                         }
    
25.                 }
    
26.                 return newal;
    
27.         }
    
28. }
    

复制代码