两个例子:
1.ArrayList存储字符去重
2.ArrayList存储自定义对象去重




一 .   ArrayList存储字符串去重。
思路：
a、重新new一个新的List集合。
b、然后遍历旧集合，然后获取旧集合中的每一个元素。
c、判断新集合中是否有 当前遍历到的元素。
      有：就不添加。
     没有：就添加。


代码(导包和类 我就不写了):

1. public static void main(String[] args) {
   
2.                 ArrayList<String> al = new ArrayList<>();
   
3.                 al.add("111");
   
4.                 al.add("111");
   
5.                 al.add("222");
   
6.                 al.add("222");
   
7.                 al.add("111");
   
8.                 al.add("333");
   
9.                 al.add("444");
   
10.                 //此时集合为[111,111,222,222,111,333,444] 接下来我们进行去重操作
    
11.                 show(al);        //调用方法去重
    
12.         }
    
13. 
    
14.         //写一个去重的方法 show();
    
15.         private static void show(ArrayList<String> al) {
    
16.                 //1、重新new一个新的List集合。
    
17.                 ArrayList<String> list1 = new ArrayList<>();
    
18.                 //2、然后遍历旧集合，然后获取旧集合中的每一个元素。
    
19.                 for (int i = 0; i < al.size(); i++) {
    
20.                         //3.判断 如果新集合不包含遍历到的元素 就将该元素添加到新集合中
    
21.                         if (!list1.contains(al.get(i))) {
    
22.                                 //就将该元素添加到新集合中
    
23.                                 list1.add(al.get(i));
    
24.                         }
    
25.                 }
    
26.                 //输出结果
    
27.                 System.out.println(list1);
    
28.         }

复制代码

二 .   ArrayList存储存储自定义对象去重


这个和第一种情况思路大同小异,不同之处是集合内存储的是对象,代码上有些不同,这里我们写一个Student类来演示

代码:
首先写一个Student类,定义成员属性name和age,写上构造方法和get set 方法 此处省略


需要注意的是,还要重写toString()方法和equals()方法,
如果不重写toString()方法,当我们打印集合的时候,输出的就会是地址值
重写equals()方法,是因为一会儿要用到ArrayList的contains()方法,它底层依赖是equals()方法,
而实际开发中，我们认为如果对象的 各个属性值都相同，那么他们就是同一个对象,
所以在这里,我们队equals()方法进行重写,判断两个对象的name和age如果相同的话,就认为他们是同一个对象
所以，如果去重对象是： 自定义类型，不要忘了重写equals().

1. public String toString() {
   
2.                 return "Student [nameString=" + name + ", age=" + age + "]";
   
3.         }
   
4. 
   
5.         public boolean equals(Object obj) {
   
6.                 Student stu = (Student)obj ;
   
7.                 return this.name.equals(stu.name) && this.age ==stu.age ;
   
8.         }

复制代码

集合的代码:
这里是用的迭代器配合它的hasNext()方法还有Next()方法对需要去重的集合进行遍历,
这里有个地方需要注意:一定要定义一个变量接收Next()方法获取到的元素.后面用这个变量进行操作,而不要一直用Next()方法,因为每用一次Next()方法,指针就会向后移动,最后的结果就是错误的
如果新集合里没有遍历到的元素,就把该元素加入新集合.

1. public static void main(String[] args) {
   
2.                 ArrayList<Student> al = new ArrayList<>();
   
3.                 al.add(new Student("张三",23));
   
4.                 al.add(new Student("张三",23));
   
5.                 al.add(new Student("李四",24));
   
6.                 al.add(new Student("张三",22));
   
7.                 al.add(new Student("王五",26));
   
8.                 al.add(new Student("王五",26));
   
9.                 //System.out.println(al);
   
10.                
    
11.                 show(al);
    
12.         }
    
13. 
    
14.         private static void show(ArrayList<Student> al) {
    
15.                 //创建新集合alt
    
16.                 ArrayList<Student> alt = new ArrayList<>();
    
17.                 //获取迭代器
    
18.                 Iterator<Student> lit = al.iterator();
    
19.                 //遍历旧集合 并进行判断
    
20.                 while (lit.hasNext()) {
    
21.                         Student s = lit.next();
    
22.                         //如果新集合不包含遍历到的元素,就把该元素添加到新集合
    
23.                         if (!al.contains(s)) {
    
24.                                 //把该元素添加到新集合
    
25.                                 al.add(s);
    
26.                         }
    
27.                 }
    
28.                 System.out.println(al);
    
29.         }
    
30. }
    

复制代码

技术含量还是挺高的

顶一下、