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

系统 2061 0

在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.  }   

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


更多文章、技术交流、商务合作、联系博主

微信扫码或搜索:z360901061

微信扫一扫加我为好友

QQ号联系: 360901061

您的支持是博主写作最大的动力,如果您喜欢我的文章,感觉我的文章对您有帮助,请用微信扫描下面二维码支持博主2元、5元、10元、20元等您想捐的金额吧,狠狠点击下面给点支持吧,站长非常感激您!手机微信长按不能支付解决办法:请将微信支付二维码保存到相册,切换到微信,然后点击微信右上角扫一扫功能,选择支付二维码完成支付。

【本文对您有帮助就好】

您的支持是博主写作最大的动力,如果您喜欢我的文章,感觉我的文章对您有帮助,请用微信扫描上面二维码支持博主2元、5元、10元、自定义金额等您想捐的金额吧,站长会非常 感谢您的哦!!!

发表我的评论
最新评论 总共0条评论