SOS： for循环List 集合 删除集合数据的问题

Question

本帖最后由 my860310 于 2009-10-18 22:44:33 编辑

Answer 1

for (int i = 0; i < list.size(); i++) {
        for (int j = 0; j < list.size(); j++) {
}
}这样做不太合适,因为list.size()在你做了remove以后会改成。你可以先将碰到相同的数设置成null(list.set(i,null)).
到最后再遍历把所有null值remove掉.这个我很早就做过了

Answer 2

map的key不是不能重复吗？你把这个加到map里行吗？

Answer 3

你这个完全可以换种方式实现：
迭代List，放在一个Set里(因为set无法存在相同元素)，然后set.toArray()转换成数组，再转list。
至于效率问题，几千条也不国0.几秒的功夫，几百条也不在话下。
同样是两层循环，为什么非要自己去判断是否相同呢？

Answer 4

  汗  ，不是啊   那个   list 里面的  阿拉伯数字 在  应用中不是阿拉伯数字的，是其他的 我只是举得个简单点的例子，那里里面还有东西呢      一楼的 我在等你，
      二楼的 你说的方法我试了，for (int i = 0; i < list.size(); i++) {
if(0 == list.get(i)){
System.out.println("删除  0  的时候  "+ i);
list.remove(i);

}
}但是结果 怎么让list 压缩下啊，现在结果成了[5, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0]  返回去的list  三楼四楼 这个里面 阿拉伯数字代替的其他东西，是不能用map的，而且 大的架子都固定了  

Answer 5

我说的是set，不是map，请看好～～

Answer 6

Set set = new HashSet();
set.add("任何数1");
set.add("任何数2");
set.add("任何数3");
set.add("任何数2");
set.add("任何数5");
System.out.println(set);
输出 任何数1 任何数2 任何数3 任何数5不知道楼主是不是这个意思。
再用 set.toArray(); 就是一个 Object obj = {"任何数1","任何数2","任何数3","任何数5"};
再用for循环，放到一个list里不就行了马？

Answer 7

        
           .... Set  我不会用。

Answer 8

Object []obj = {"任何数1","任何数2","任何数3","任何数5"}上面那个写错了。

Answer 9

    汗  高手同志，用Set不行啊，set.add()之前是要先把里面的东西拿出来做判断的才行啊        到了这个应用中  set.add(一个实体类)，   .add()进去之前 是需要判断实体类里的一个条件的先。

Answer 10

//这个方法有问题
public static List removeSame(List<Integer> list)
你要实现的是什么功能?

Answer 11

   就是说  要在里面进行判断，把 重复的数据有选择的删掉  要用List  做

Answer 12

package com.bluefish.hr.wage.input.service;import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;public class Test {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(5);
list.add(2);
list.add(5);
list.add(2);
list.add(5);
list.add(5);
list.add(5);
list.add(5);
list.add(2);
list.add(5);
list.add(2);
list.add(5);
list.add(5);
list.add(5);
list.add(5);
list.add(2);
list.add(5);
list.add(2);
list.add(5);
list.add(5);
new Test().removeSame(list);
for (Integer i : list) {
System.out.println(i);
}
} public void removeSame(List<Integer> list) {
HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
if (list == null || list.isEmpty()) {
return;
} else {
for (Iterator<Integer> it = list.iterator(); it.hasNext();) {
Integer i = it.next();
if (map.get(i) == null) {
map.put(i, i);
} else {
it.remove();
}
}
map = null;
}
}
}
你那种删除方式太危险 用迭带器 如果不用的话 元素不一定需要是删除 把那个位置的元素换成-1 然后你在其他地方使用的时候判断下就可以了

Answer 13

import java.util.ArrayList;
import java.util.List;/**
 * 测试 系统整理数据的时候 删除相同数据的
 * @author dongAdmin
 *
 */
public class Remove {
    
    public static void main(String[] args) {
        
        List<Integer> list = new ArrayList<Integer>();
        list.add(5);
        list.add(2);
        list.add(5);
        list.add(2);
        list.add(5);
        list.add(5);
        list.add(5);
        list.add(5);
        list.add(2);
        list.add(5);
        list.add(2);
        list.add(5);
        list.add(5);
        list.add(5);
                      list.add(5);
        list.add(2);
        list.add(5);
        list.add(2);
        list.add(5);
        list.add(5);
                   //这个地方会有 很多很多很多的list.add(阿拉伯数字);
        
        list = Remove.removeSame(list);  //调用下面那个方法                    //这样打印出来的结果
                    //list 是 ：最后  [2, 2, 5, 5]
                    //希望的结果是： [2,5],  就是说 把所有的重复数据都删掉
                    //求教高手回答，深感涕零
        System.out.println("最后  "+list);
    }//这个方法有问题
public static List removeSame(List<Integer> list){
    for (int i = 0; i < list.size(); i++) {
        for (int j = 0; j < list.size(); j++) {
 //           System.out.println("list 长度  "+list.size() +"  i当前 "+i +"  j 当前："+j);
            if (i != j) {                try {
 //                   System.out.println(i < list.size()
 //                           && j < list.size());
                    if (i < list.size() && j < list.size()) {
                        if (list.get(i) == list.get(
                                j)) { // 相同
                            
                            if(list.get(i) > 5){
                                list.remove(i);
                                removeSame(list);
                            }else if(list.get(i)<5){
                                list.remove(j);
                                removeSame(list);
                            }else{
                                list.remove(i);
                                removeSame(list);
                            }
                            
                        }
                    }
                } catch (IndexOutOfBoundsException e) {
                    e.printStackTrace();
                }            }else{
                System.out.println(i+"  i不等于 j  "+j);
            }        }
    }
    return list;
}
}这是我的解决方案，你看看是你想要的吗？

Answer 14

循环删除东西的时候，循环最好是倒序循环。
本例就是
for (int i = list.size()- 1;i <0; i--){
    for (int j = list.size()- 1;j <0; j--){
       .......
这样应该就不会有遗漏了。

Answer 15

继承 java.util.AbstractCollection<E>比较合适。

Answer 16

不是很明白，觉得用HASHMAP或者INDEXOF也可以！

Answer 17

if(list.get(i) > 5){
    list.remove(i);
    i--;
    j--;
}else if(list.get(i)<5){
    list.remove(j);
    i--;
    j--;
}else{
   list.remove(j);
   i--;
   j--;
}

Answer 18

15楼是通过map中key的唯一性来判断是否重复,Iterator删除重复元素影响List            if (map.get(i) == null) { // 判断map中是否还没出现过这个key
                    map.put(i, i);  // 添加key
                } else {
                    it.remove(); // Iterator中删除操作对底层Collection也有影响
                }

Answer 19

把list中的数据转换成string添加入set中，再获取set中的数据添加入全新的list中；
set有相同字符串过滤功能。也就是set中只能存在一个"888"再增加"888" set也只有一个"888";

Answer 20

for (int i = 0; i < list.size(); i++) {
        /**判断此元素在list里面的存在的首位置和未位置是否相等,不等则remove
           如果i不设为0,i会一直递增,有些重复数据就会遗漏
        */
if(list.indexOf(list.get(i))!=list.lastIndexOf(list.get(i))){ 
list.remove(list.get(i));
i=0;
}
}
这代码就能实现你要的效果

Answer 21

import java.util.ArrayList;
import java.util.List;/**
 * 测试 系统整理数据的时候 删除相同数据的
 * @author dongAdmin
 *
 */
public class Remove {
    
    public static void main(String[] args) {     List<Integer> list = new ArrayList<Integer>();
        list.add(5);
        list.add(2);
        list.add(5);
        list.add(2);
        list.add(5);
        list.add(5);
        list.add(5);
        list.add(5);
        list.add(2);
        list.add(5);
        list.add(2);
        list.add(5);
        list.add(5);
        list.add(5);
        list.add(5);
        list.add(2);
        list.add(5);
        list.add(2);
        list.add(5);
        list.add(5);
        list.add(4);
        list.add(3);
        list.add(4);
        list.add(3);
        list.add(4);
        list.add(3);
        list.add(4);
        list.add(3);
        list.add(4);
        list.add(3);
        list.add(4);
        list.add(3);
        list.add(4);
        list.add(3);
                   //这个地方会有 很多很多很多的list.add(阿拉伯数字);
        System.out.println("原本  "+list);
        list = Remove.removeSame(list);  //调用下面那个方法                    //这样打印出来的结果
                    //list 是 ：最后  [2, 2, 5, 5]
                    //希望的结果是： [2,5],  就是说 把所有的重复数据都删掉
                    //求教高手回答，深感涕零
        System.out.println("最后  "+list);
    }//这个方法有问题
public static List removeSame(List<Integer> list){

for(int i=0;i<list.size();i++){ for(int j=i;j<list.size();j++){//从每一个索引开始比对其之后的所有内容

                        if(list.get(i)==list.get(j) && i!=j){//如果内容相同并且不是相同索引
list.remove(j);
j=0;//这里一定要清零
      }
}
}    return list;
}
}楼主你好,我根据你的需求在你的代码基础上改动了一下..比较简洁,希望能帮到你

Answer 22

楼主 ,你将 removeSame方法实现换成
public static List removeSame(List<Integer> list){
        for (int i = 0; i < list.size(); i++) { 
               /**判断此元素在list里面的存在的首位置和未位置是否相等,不等则remove 
                  如果i不设为0,i会一直递增,有些重复数据就会遗漏 
                */ 
              if(list.indexOf(list.get(i))!=list.lastIndexOf(list.get(i))){ 
              list.remove(list.get(i)); 
              i=0; 
              } 
       }
       return list;
}

Answer 23

不好意思,我更正一下
 
    j=0;//这里一定要清零
   这里改一下,其实不用一定清零,j=i;就可以了,只要能保证j是从i开始比对的就可以了..而且j=i;会比我之前清零速度更快一点

Answer 24

楼主 你在
                                         if(list.get(i) > 5){
                                        list.remove(i);
                            }else if(list.get(i)<5){
                                list.remove(j);
                            }else{
                                list.remove(j);
                            }
                            j=i;
                                    i=0;
两行红色的随便加一行都可以

Answer 25

   iterator.remove();  //这句话 在程序中 是什么意思？？？  代表什么？？  
  
 我用的这个方法  结果做出来的 总是 结果不准       而  
Haibo0321  和  liuqinblue 的 那个方法 放进去 总是报  越界

Answer 26

剔除重复数据 有2种方法 第一种 
//这个方法有问题
public static List removeSame(List<Integer> list){
    
    for(int i=0;i<list.size()-1;i++){        for(int j=i;j<list.size()-1;j++){//从每一个索引开始比对其之后的所有内容
        
      
         if(list.get(j).equals(list.get(i)))
         {
           list.remove(j);
         }
        }
    }    return list;
}    if(list.get(j).equals(list.get(i)))
         {
           list.remove(j);
         }
换掉
     if(list.get(i)==list.get(j) && i!=j){//如果内容相同并且不是相同索引
            list.remove(j);
            j=0;//这里一定要清零
              }
 
equeals与==区别？
http://hi.baidu.com/airyoung/blog/item/f43629faa3ffa2d4b48f31bd.html第二种
HashSet踢除重复元素public static List removeSame(List<Integer> list){
  Hashset h=new HashSet(list);
   list.clear();
   list.addAll(h);
return list;
}

Answer 27

  ...   这几个方法 都挨个 试了下  用在 list<Integer>  是都没问题   但是用在网站上 增加了很多条件判断之后 都会出现   数据不正确的现象  
   还有 BearKin  的迭代方法 的确不错 只可惜 小弟才疏学浅  无法将其融于应用。   最后 只好 借鉴   #2   blliy117  的 set(i,null)方法，  但是这个方法明显影响性能  用了之后 在 这个数据处理的地方很慢很慢 要每次都先判断 这个方法里有连续三个地方都用到了for,for循环   寻求各位高手 ，有没有 更妥善的方法。。

Answer 28

请问下楼主你那list中存放的是什么东西？listSame方式是不是仅仅为了去除重复的数据呢？
要根据你的实际需求，才能好给你想个高效点的方法

Answer 29

另外 不要在循环中直接对LIST里面的值进行操作 替换可以 但是remove会导致list里面索引值的变化 你现在只是删除 光那么写说不定可以 但是如果有时候要进行其他操作那就麻烦了 所以我的建议还是那两个 一个是用迭代器来完成移除元素的操作 另一个就是不要删除那个元素 把他指定为一个特殊的数 当页面需要使用该LIST的时候进行下判断

Answer 30

package com.bluefish.hr.wage.input.service;import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;public class Test {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(5);
list.add(2);
list.add(5);
list.add(2);
list.add(5);
list.add(5);
list.add(5);
list.add(5);
list.add(2);
list.add(5);
list.add(2);
list.add(5);
list.add(5);
list.add(5);
list.add(5);
list.add(2);
list.add(5);
list.add(2);
list.add(5);
list.add(5);
new Test().removeSame(list);
for (Integer i : list) {
System.out.println(i);
}
} public void removeSame(List<Integer> list) {
HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
for (int i = 0; i < list.size(); i++) {
if (map.containsKey(list.get(i))) {
list.remove(i);
--i;
} else {
map.put(list.get(i), list.get(i));
}
}
}
}
另一种的..

Answer 31

if(list !=null  && list.size() > 0){
  
  for(int mm=0;mm<list.size();mm++){
    List list1 = list;
    list.get(mm);  
    
    for(int nn=mm+1;nn<list1.size();nn++){
      VO vo1=(VO)list.get(nn);
      if(list.get(mm).equals(list.get(nn))){   // 比较list和list1中的数据是否相等
        list.remove(nn);  //此处如果两值相等，则删除list1中的相等的数据
        nn--;              // 同时list1的长度减 1
      }
    }
  }
}LZ就按这种思想自己改动下  应该可以  如果你可以把数据封装到一个类里的话  运用上面的方法把这些值塞给这个类   你直接从类里读取数据就可以了

Answer 32

   if(list.get(i) > 5){
                                list.remove(i);
                            }else if(list.get(i)<5){
                                list.remove(j);
                            }else{
                                list.remove(j);
                            }
                            
                        }这段代码不是罗嗦吗？ 双重for循环，4层if嵌套。楼主，重构吧。呵呵。

Answer 33

还没看高手们的回复，不过既然只要去掉重复，直接放到Set里面不就可以了吗？List中删除数据最好用Iterator来remove。

Answer 34

数组转为List不需要做循环的，Arrays类中提供了方法。

Answer 35

一边循环一边删除,size()大小改变
切忌　　

Answer 36

还是用Map好，楼上已经有人谢了，我就不用了

Answer 37

你换一个思路不行吗？你新开一个List（newList），然后遍历原来的List，往newList里面一个一个加。在加之前，如果！newList.contain(obj)，就add进去，否则就跳过。

Answer 38

改下这个方法吧 很多种  
public static List<Integer> removeSame(List<Integer> list){
List<Integer> result = new ArrayList<Integer>();

for(int i = 0,j = list.size();i<j;i++){
boolean flag = false;
Integer a = list.get(i);
for(Integer in:result){
if(in == a){
flag = true;
}
}
if(!flag){
result.add(a);
}
}
   
    return result;
}

Answer 39

我也支持用Map的Key来存，方便快捷，效率高，用Set的效率不高

Answer 40

用hashmap  hashset  最好用hashmap好点

Answer 41

package leeBid;
import java.util.ArrayList;
import java.util.List;/**
 * 测试 系统整理数据的时候 删除相同数据的
 * @author dongAdmin
 *
 */
public class DelData {
    
    public static void main(String[] args) {
        
        List<Integer> list = new ArrayList<Integer>();
        list.add(5);
        list.add(2);
        list.add(5);
        list.add(2);
        list.add(5);
        list.add(5);
        list.add(5);
        list.add(5);
        list.add(2);
        list.add(5);
        list.add(2);
        list.add(5);
        list.add(5);
        list.add(5);
        list.add(5);
        list.add(2);
        list.add(5);
        list.add(2);
        list.add(5);
        list.add(5);
        list = DelData.removeSame(list);  //调用下面那个方法
        for(int l=0;l<list.size();l++){
          System.out.println(list.get(l));
        }
       
        
    }
public static List removeSame(List<Integer> list){    for (int i = 0; i < list.size(); i++) {
        for (int j = i+1; j < list.size(); j++) {
            System.out.println("list 长度  "+list.size() +"  i当前 "+i +"  j 当前："+j);
            if (list.get(i)==list.get(j)) {
                try {
                       list.remove(j);  
                       j--;
                    }
                 catch (IndexOutOfBoundsException e) {
                    e.printStackTrace();
                }            }
        }
    }// /   System.out.println("list.size="+list.size());
    return list;
}
}

Answer 42

      Map  没弄出来。。  
            现在这个方法效率不好。    结贴

Answer 43

晕这么简单的问题搞这么复杂，不就是循环标记的问题吗，你每删除list中的一个数就把循环标记后退一下不就可以了吗，就是i--;

Answer 44

哎呀，给个例子吧，public class Test{
public static void main(String args[]){
List<String> list=new ArrayList<String>();
for(int i=0;i<9;i++)
list.add("test"+i);
for(int i=0;i<list.size();i++){
String o=list.get(i);
System.out.println("o1="+o);
if(o.toString().equals("test2")){
list.remove(o);
i--;
}

}

}

}
如果不用i--;打印结果如下：
o1=test0
o1=test1
o1=test2
o1=test4
o1=test5
o1=test6
o1=test7
o1=test8
看看遗漏了一个test3吧；test3没打出来；
如果加了i--;test3就出来了，想想什么原因吧。