在Java中利用set特性删除重复的数组元素

Set(): 存入Set的每个元素必须是唯一的，因为Set不保存重复元素。加入Set的Object必须定义equals()方法以确保对象的唯一性。Set与Collection有完

全一样的接口。Set接口不保证维护元素的次序。

　　HashSet: 为快速查找而设计的Set。存入HashSet的对象必须定义hashCode()。

　　TreeSet: 保持次序的Set，底层为树结构。使用它可以从Set中提取有序的序列。

　　LinkedHashSet: 具有HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。

　　HashSet采用散列函数对元素进行排序，这是专门为快速查询而设计的；TreeSet采用红黑树的数据结构进行排序元素；LinkedHashSet内部使用散列以加快查

询速度，同时使用链表维护元素的次序，使得看起来元素是以插入的顺序保存的。需要注意的是，生成自己的类时，Set需要维护元素的存储顺序，因此要实现

Comparable接口并定义compareTo()方法。

 

Java代码

1. import java.util.LinkedList;   
2.   
3. public class TestArray01 {   
4.     
5.  public static void main(String args[]) {   
6.   
7.   Integer[] a1 = { 1, 2, 4, 3, 5, 7, 8 };   
8.   Integer[] a2 = { 8, 2, 4, 7, 9 };   
9.   LinkedList<Integer> list1 = new LinkedList<Integer>();   
10.   LinkedList<Integer> list2 = new LinkedList<Integer>();   
11.   
12.   // 将数组转换成list   
13.   for (int i = 0; i < a1.length; i++) {   
14.    list1.add(a1[i]);   
15.   }   
16.   // 将数组转换成list   
17.   for (int i = 0; i < a2.length; i++) {   
18.    list2.add(a2[i]);   
19.   }   
20.   
21.   int size_1 = list1.size();   
22.   int size_2 = list2.size();   
23.      
24.   // 根据list中长度最长的设置list要循环的长度   
25.   if (size_1 >= size_2) {   
26.    // 逐个比较两个list中的值是否相同   
27.    for (int i = 0; i < list1.size(); i++) {   
28.     Integer temp = list1.get(i);   
29.                    
30.     // 如果两个数组中有相同的值   
31.     // 则将此值在两个list中删除   
32.     //  注意此处不能使用remove方法   
33.     if (list2.contains(temp)) {   
34.      list1.set(i, null);   
35.      int pos = list2.indexOf(temp);   
36.      list2.set(pos, null);   
37.     }   
38.    }   
39.   } else {   
40.    // 逐个比较两个list中的值是否相同   
41.    for (int i = 0; i < list2.size(); i++) {   
42.     Integer temp = list1.get(i);   
43.   
44.     // 如果两个数组中有相同的值   
45.     // 则将此值在两个list中删除   
46.     //  注意此处不能使用remove方法   
47.     if (list1.contains(temp)) {   
48.      list1.remove(temp);   
49.      list2.remove(temp);   
50.     }   
51.    }   
52.   }   
53.   
54.   System.out.println("   剩余的数组的信息 list1 :");   
55.   for (int i = 0; i < list1.size(); i++) {   
56.    System.out.println("----------------- :  " + list1.get(i));   
57.   }   
58.   
59.   System.out.println("   剩余的数组的信息 list2 :");   
60.   for (int i = 0; i < list2.size(); i++) {   
61.    System.out.println("----------------- :  " + list2.get(i));   
62.   }   
63.   
64.   // 将删除掉重复元素的两个list合并到第三个list中   
65.   LinkedList<Integer> list3 = new LinkedList<Integer>();   
66.   for (int i = 0; i < list1.size(); i++) {   
67.   
68.    if (list1.get(i) != null) {   
69.     list3.addLast(list1.get(i));   
70.    }   
71.   }   
72.   for (int i = 0; i < list2.size(); i++) {   
73.    if (list2.get(i) != null) {   
74.     list3.addLast(list2.get(i));   
75.    }   
76.   }   
77.   
78.   for (int i = 0; i < list3.size(); i++) {   
79.    System.out.println("-------list3---------- :  " + list3.get(i));   
80.   }   
81.  }   
82. }  

import java.util.LinkedList;

public class TestArray01 {
 
 public static void main(String args[]) {

  Integer[] a1 = { 1, 2, 4, 3, 5, 7, 8 };
  Integer[] a2 = { 8, 2, 4, 7, 9 };
  LinkedList<Integer> list1 = new LinkedList<Integer>();
  LinkedList<Integer> list2 = new LinkedList<Integer>();

  // 将数组转换成list
  for (int i = 0; i < a1.length; i++) {
   list1.add(a1[i]);
  }
  // 将数组转换成list
  for (int i = 0; i < a2.length; i++) {
   list2.add(a2[i]);
  }

  int size_1 = list1.size();
  int size_2 = list2.size();
  
  // 根据list中长度最长的设置list要循环的长度
  if (size_1 >= size_2) {
   // 逐个比较两个list中的值是否相同
   for (int i = 0; i < list1.size(); i++) {
    Integer temp = list1.get(i);
                
    // 如果两个数组中有相同的值
    // 则将此值在两个list中删除
    //  注意此处不能使用remove方法
    if (list2.contains(temp)) {
     list1.set(i, null);
     int pos = list2.indexOf(temp);
     list2.set(pos, null);
    }
   }
  } else {
   // 逐个比较两个list中的值是否相同
   for (int i = 0; i < list2.size(); i++) {
    Integer temp = list1.get(i);

    // 如果两个数组中有相同的值
    // 则将此值在两个list中删除
    //  注意此处不能使用remove方法
    if (list1.contains(temp)) {
     list1.remove(temp);
     list2.remove(temp);
    }
   }
  }

  System.out.println("   剩余的数组的信息 list1 :");
  for (int i = 0; i < list1.size(); i++) {
   System.out.println("----------------- :  " + list1.get(i));
  }

  System.out.println("   剩余的数组的信息 list2 :");
  for (int i = 0; i < list2.size(); i++) {
   System.out.println("----------------- :  " + list2.get(i));
  }

  // 将删除掉重复元素的两个list合并到第三个list中
  LinkedList<Integer> list3 = new LinkedList<Integer>();
  for (int i = 0; i < list1.size(); i++) {

   if (list1.get(i) != null) {
    list3.addLast(list1.get(i));
   }
  }
  for (int i = 0; i < list2.size(); i++) {
   if (list2.get(i) != null) {
    list3.addLast(list2.get(i));
   }
  }

  for (int i = 0; i < list3.size(); i++) {
   System.out.println("-------list3---------- :  " + list3.get(i));
  }
 }
}

 

 

Java代码

1. import java.util.ArrayList;   
2. import java.util.HashMap;   
3. import java.util.Iterator;   
4. import java.util.List;   
5. import java.util.Map;   
6.   
7. public class TestArray02 {   
8.   
9.  public static void main(String args[]) {   
10.   Integer[] a1 = { 1, 2, 3 };   
11.   Integer[] a2 = { 4, 2, 3 };   
12.   
13.   Map<Integer, Object> map = new HashMap<Integer, Object>();   
14.   
15.   for (int i = 0; i < a1.length; i++) {   
16.    // 因为我们要获取的是set集合，所以   
17.    // 只在此处设置map的key   
18.    map.put(a1[i], null);   
19.   }   
20.   
21.   for (int i = 0; i < a2.length; i++) {   
22.    // 因为我们要获取的是set集合，所以   
23.    // 只在此处设置map的key   
24.    map.put(a2[i], null);   
25.   }   
26.   
27.   List<Integer> list = new ArrayList<Integer>();   
28.   Iterator<Integer> it = map.keySet().iterator();// 在此处获取set的集合   
29.   while (it.hasNext()) {   
30.    Integer ob = (Integer) it.next();   
31.    list.add(ob);   
32.   }   
33.   
34.   // 将list集合转换成Integer数组   
35.   Integer[] a3 = (Integer[]) list.toArray(new Integer[list.size()]);   
36.   
37.   for (int i = 0; i < a3.length; i++) {   
38.    System.out.println(a3[i]);   
39.   }   
40.  }   
41. }  

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class TestArray02 {

 public static void main(String args[]) {
  Integer[] a1 = { 1, 2, 3 };
  Integer[] a2 = { 4, 2, 3 };

  Map<Integer, Object> map = new HashMap<Integer, Object>();

  for (int i = 0; i < a1.length; i++) {
   // 因为我们要获取的是set集合，所以
   // 只在此处设置map的key
   map.put(a1[i], null);
  }

  for (int i = 0; i < a2.length; i++) {
   // 因为我们要获取的是set集合，所以
   // 只在此处设置map的key
   map.put(a2[i], null);
  }

  List<Integer> list = new ArrayList<Integer>();
  Iterator<Integer> it = map.keySet().iterator();// 在此处获取set的集合
  while (it.hasNext()) {
   Integer ob = (Integer) it.next();
   list.add(ob);
  }

  // 将list集合转换成Integer数组
  Integer[] a3 = (Integer[]) list.toArray(new Integer[list.size()]);

  for (int i = 0; i < a3.length; i++) {
   System.out.println(a3[i]);
  }
 }
}