请问消除List中的重复数据有哪些方法？谢谢_百度知道
请问消除List中的重复数据有哪些方法？谢谢
我有更好的答案
1，把list里的对象遍历一遍，存入一个MAP中2，把list里的对象遍历一遍，用list.contain(obj)，如果不存在，就放入另外一个list中
采纳率：21%
遍历放入一个哈希容器中.然后再用哈希容器的values方法取出成对象数组,再用Arrays的asList方法转化成List
为您推荐：
其他类似问题
您可能关注的内容
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。java中 List&&泛型 去除有重复数据的对象_百度知道
java中 List&&泛型 去除有重复数据的对象
我有一个List&UserInfo&
里面放了很多UserInfo对象 每个对象里面有很多字段 userid，username什么的 其中很些对象的字段数据都一样
我像去除一样的 只保留一个 该怎么做
我有更好的答案
List&UserInfo&换成Sef&UserInfo& info = new HashSet&UserInfo&();重写UserInfo的equals方法和hashCode方法
采纳率：18%
把List换成Set,Set容器里的元素不能重复,然后通过重写equals方法和hashCode方法来定义2个对象相等的条件
楼上方法都可以吧。userinfo
你指定一个ID 岂不更好。重写下 equals
hascode //OK
大时代暑 正解。 支持
foreach循环遍历下。有碰到相同的就删。
大时代暑 正解。
其他3条回答
为您推荐：
其他类似问题
您可能关注的内容
泛型的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。List重复数据合并问题，要求不建新的List，合并后的数据还是在原先的List里，求算法思想和代码。 - ITeye问答
List重复数据合并问题，要求不建新的List，合并后的数据还是在原先的List里，求算法思想和代码。
Distinct d1 = new Distinct("东莞", "长安沙头南区",1);
Distinct d2 = new Distinct("东莞", "长安沙头南区",1);
Distinct d3 = new Distinct("东莞", "桥头",1);
Distinct d4 = new Distinct("东莞", "桥头",1);
Distinct d5 = new Distinct("东莞", "桥头",1);
Distinct d6 = new Distinct("东莞", "长安镇步步高",1);
List&Distinct& oldList = new ArrayList&Distinct&();
oldList.add(d1);
oldList.add(d2);
oldList.add(d3);
oldList.add(d4);
oldList.add(d5);
oldList.add(d6);
如以上的oldList，重复的数据合并，且数量加1，如：东莞", "长安沙头南区",2
要求是不要新建的List，直接在oldList里操作，
Distinct.java:
public class Distinct {
private String distictN
private String distictA
public Distinct() {
public Distinct(String distictName, String distictAddress, int count) {
this.distictName = distictN
this.distictAddress = distictA
this.count =
public String getDistictAddress() {
return distictA
public void setDistictAddress(String distictAddress) {
this.distictAddress = distictA
public String getDistictName() {
return distictN
public void setDistictName(String distictName) {
this.distictName = distictN
public int getCount() {
public void setCount(int count) {
this.count =
public boolean equals(Object obj) {
if (obj instanceof Distinct) {
Distinct t = (Distinct)
if (this.distictName.equals(t.distictName)
&& this.distictName.equals(t.distictName)) {
public String toString() {
return this.distictName + "\t" + this.distictName + "\t" + this.
}
MyArrayList.java:
import java.util.ArrayL
public class MyArrayList extends ArrayList&Distinct& {
private static final long serialVersionUID = 1L;
public boolean add(Distinct e) {
for(int i=0;i&super.size();i++){
Distinct d=super.get(i);
if(e.equals(d)){
d.setCount(d.getCount()+e.getCount());
return super.add(e);
测试：T.java
import java.util.L
public class T {
* @param args
public static void main(String[] args) {
Distinct d1 = new Distinct("东莞", "长安沙头南区", 1);
Distinct d2 = new Distinct("东莞", "长安沙头南区", 1);
Distinct d3 = new Distinct("东莞", "桥头", 1);
Distinct d4 = new Distinct("东莞", "桥头", 1);
Distinct d5 = new Distinct("东莞", "桥头", 1);
Distinct d6 = new Distinct("东莞", "长安镇步步高", 1);
List&Distinct& oldList = new MyArrayList();
oldList.add(d1);
oldList.add(d2);
oldList.add(d3);
oldList.add(d4);
oldList.add(d5);
oldList.add(d6);
for (int i = 0; i & oldList.size(); i++) {
System.out.println(oldList.get(i));
1.实现一个比较Distinct的帮助类,比如Distinct_Helper.equal(Distinct d1,Distinct d2)
2. 遍历oldList
& for(int i=0;i&oldList.size-1; i++){
&&&&& int j=i+1;&&
&&&&& for(;j&oldList.j++){
&&&&&& //如果相同，i结点+1,移除重复的结点
&&&&&& //不相同，不操作&&&&
&&&&&& }
}
先说一点，这个需求本身不是一个好的设计，这样会比较麻烦，如果用map可能会更简单一些，用你的对象做key然后重写hashcode,equals方法,value来表示数量。当然，按你这样也是可以处理的：list遍历，从0开始，遇到重复的就记录位置，然后遍历一遍之后全部删除并更新数量，然后再从1开始，遍历....
1.重写Distinct里面的equals方法
public boolean equals(Object obj)
if(obj!=null)
Distinct d = (Distinct)
if (d.getAddress()==this.address&&d.getProvince()==this.province)
return super.equals(obj);
}
2.判断list里是否有重复值，如果有，remove，然后给count加1，若没有add
Distinct d1 = new Distinct("东莞", "长安沙头南区", 1);
Distinct d2 = new Distinct("东莞", "长安沙头南区", 1);
Distinct d3 = new Distinct("东莞", "桥头", 1);
Distinct d4 = new Distinct("东莞", "桥头", 1);
Distinct d5 = new Distinct("东莞", "桥头", 1);
Distinct d6 = new Distinct("东莞", "长安镇步步高", 1);
List&Distinct& oldList = new ArrayList&Distinct&();
oldList.add(d1);
for (int i = 1; i & 6; i++)
Distinct d = new Distinct();
case 1:d=d2;
case 2:d=d3;
case 3:d=d4;
case 4:d=d5;
case 5:d=d6;
if (oldList.contains(d))
Distinct dd = new Distinct();
dd.setCount(oldList.get(oldList.indexOf(d)).getCount() + 1);
oldList.remove(d);
oldList.add(dd);
oldList.add(d);
}
}
for (int i = 0; i & oldList.size(); i++)
System.out.println(oldList.get(i).getProvince() +&&&& oldList.get(i).getAddress()
+ oldList.get(i).getCount());
}
看了题目的第一个感觉是: 继承ArrayList类，重写add方法。
import java.util.ArrayL
import java.util.L
public class Distinct {
private String addressLineO
private String addressLineT
public Distinct(String addressLineOne,String addressLineTwo,int count) {
this.addressLineOne = addressLineO
this.addressLineTwo = addressLineT
this.count =
//判断是否相等
public boolean equals(Distinct distinct){
if(addressLineOne.equals(distinct.addressLineOne) && addressLineTwo.equals(distinct.addressLineTwo)){
//自动将数量加1
this.count++;
public String toString() {
return "{addressLineOne : "+addressLineOne+",addressLineTwo : "+addressLineTwo+",count : "+count+"}";
public static void main(String[] args) {
Distinct d1 = new Distinct("东莞", "长安沙头南区",1);
Distinct d2 = new Distinct("东莞", "长安沙头南区",1);
Distinct d3 = new Distinct("东莞", "桥头",1);
Distinct d4 = new Distinct("东莞", "桥头",1);
Distinct d5 = new Distinct("东莞", "桥头",1);
Distinct d6 = new Distinct("东莞", "长安镇步步高",1);
List&Distinct& oldList = new ArrayList&Distinct&();
oldList.add(d1);
oldList.add(d2);
oldList.add(d3);
oldList.add(d4);
oldList.add(d5);
oldList.add(d6);
//遍历数组
for (int i = 0; i & oldList.size(); i++) {
//逐个比对
for (int j = i+1; j & oldList.size(); j++) {
//判断是否相等（数量自动加1）
//相等移除对象
if(oldList.get(i).equals(oldList.get(j))){
oldList.remove(j);
//输出合并之后的对象
System.out.println(oldList);
这种事情为什么不用HASH呢，这是HASH的强项。。。
Distinct 的声明
public class Distinct {
public Distinct(String name, String road, int i) {
this.name =
this.road =
this.count =
public String toString() {
return name+" "+road+" "+
public boolean equals(Object obj) {
if (!(obj instanceof Distinct)) {
Distinct o = (Distinct)
if ((name == null && o.name!=null) || !name.equals(o.name)) {
} else if ((road == null && o.road!=null)|| !road.equals(o.road)){
public String getName() {
public void setName(String name) {
this.name =
public String getRoad() {
public void setRoad(String road) {
this.road =
public int getCount() {
public void setCount(int count) {
this.count =
Distinct d1 = new Distinct("东莞", "长安沙头南区",1);
Distinct d2 = new Distinct("东莞", "长安沙头南区",1);
Distinct d3 = new Distinct("东莞", "桥头",1);
Distinct d4 = new Distinct("东莞", "桥头",1);
Distinct d5 = new Distinct("东莞", "桥头",1);
Distinct d6 = new Distinct("东莞", "长安镇步步高",1);
List&Distinct& oldList = new ArrayList&Distinct&();
oldList.add(d1);
oldList.add(d2);
oldList.add(d3);
oldList.add(d4);
oldList.add(d5);
oldList.add(d6);
for (Iterator&Distinct& it = oldList.iterator(); it.hasNext();) {
Distinct distinct = it.next();
boolean duped =
Distinct last =
for(Distinct sub: oldList) {
if (sub == distinct) {
if (distinct.equals(sub)) {
if (duped) {
it.remove();
last.setCount(last.getCount()+1);
for(Distinct d : oldList) {
System.out.println(d.toString());
重写List的add方法不就行了么
学习下，还有许多不会的。
为什么不用Map
先从Map中取，没拿到就直接仍进去，拿到了将个数加一就可以了
先分组，再将分组中list.size大于1的从最后一个删除到第一个。
最好还是用set，啊
重写Distinct的hashcode方法
这样应该效率要高很多啊。。。。。。。。
比较相等重写equals时还需要重写hashCode
重写equals之后
for(Iterator&D& iter = list.iterator();iter.hasNext();)
{
&&&& D d = iter.next();
&&&& if(list.contains(d))
&&&& {
&&&&&&&&& iter.remove();
&&&& }
}
一段伪代码,请拍砖..
继承ArrayList 重写add方法！！！
如果要归纳不同小区的人数的话，可以根据地区的长度先构建一个LinkedList起来，然后提供一个根据地区名来提取那个实例的方法入口，先取到那个实例，然后将那个对象remove掉，再将原先那个实例的count属性加一，然后set进去!
部分代码如下：
private static StringBuffer str = new StringBuffer(",长安沙头南区,桥头，长安镇步步高，");
private LinkedList&Distinct& linklist = new LinkedList&Distinct&();
Distinct d1 = new Distinct("东莞", "长安沙头南区",1);&&&&&
Distinct d2 = new Distinct("东莞", "桥头",1);&&&&&
Distinct d3 = new Distinct("东莞", "长安镇步步高",1);
//上面要NEW出来的实例数就是你的地区总数，或者是("东莞","*")这种键值对的总数
linklist.add(d1);
linklist.add(d2);
linklist.add(d3);
现在比如你有一个新的Distinct,它的地区是address
if(str.contains(address))
{
&&& for(int i=0;i&linklist.size();i++)
&&& {
&&&&&&&& Distinct d = linklist.get(i);
&&&&&&&& if(d.getAddress().equals(address))
&&&&&&&& {
&&&&&&&&&&& linklist.remove(d);
&&&&&&&&&&& d.setCount(++d.getCount);
&&&&&&&&&&& linklist.add(d);
&&&&&&&& }
&&& }
}
Distinct类，重写equals和toString方法
public boolean equals(Object obj) {
if (obj instanceof Distinct) {
Distinct t = (Distinct)
if (this.name.equals(t.name) && this.address.equals(t.address)) {
public String toString() {
return this.name + "\t" + this.address + "\t" + this.
新建一个MyArrayList&E&的泛型,继承ArrayList&E&并重写add方法
public boolean add(E e) {
if(e instanceof Distinct){
Distinct d = (Distinct)e;
for(int i=0;i&super.size();i++){
Distinct t = (Distinct)super.get(i);
if(d.equals(t)){
t.num = t.num+d.
return super.add(e);
Distinct d1 = new Distinct("东莞", "长安沙头南区",1);
Distinct d2 = new Distinct("东莞", "长安沙头南区",1);
Distinct d3 = new Distinct("东莞", "桥头",1);
Distinct d4 = new Distinct("东莞", "桥头",1);
Distinct d5 = new Distinct("东莞", "桥头",1);
Distinct d6 = new Distinct("东莞", "长安镇步步高",1);
List&Distinct& oldList = new MyArrayList&Distinct&();
oldList.add(d1);
oldList.add(d2);
oldList.add(d3);
oldList.add(d4);
oldList.add(d5);
oldList.add(d6);
for (int i=0;i&oldList.size();i++) {
System.out.println(oldList.get(i));
输出结果：
东莞 长安沙头南区 2
东莞 桥头 &&&&&&&&&& 3
东莞 长安镇步步高 1
Distinct d1 = new Distinct("东莞", "长安沙头南区", 1);
Distinct d2 = new Distinct("东莞", "长安沙头南区", 1);
Distinct d3 = new Distinct("东莞", "桥头", 1);
Distinct d4 = new Distinct("东莞", "桥头", 1);
Distinct d5 = new Distinct("东莞", "桥头", 1);
Distinct d6 = new Distinct("东莞", "长安镇步步高", 1);
List&Distinct& oldList = new ArrayList&Distinct&();
oldList.add(d1);
oldList.add(d2);
oldList.add(d3);
oldList.add(d4);
oldList.add(d5);
oldList.add(d6);
Map&String, Distinct& keys = new Hashtable&String, Distinct&();
for (int i = 0; i & oldList.size(); i++) {
Distinct distinct = oldList.get(i);
String key = distinct.getRegion1() + distinct.getRegion2();
Distinct distinct2 = keys.get(key);
if (distinct2 != null) {
distinct2.setCount(distinct2.getCount() + 1);
oldList.remove(i);
keys.put(key, distinct);
for (Distinct d : oldList) {
System.out.println(d);
2层循环，查找要合并的对象
合并结束移除对象oldList.remove(distinct)
建议用set或者map，
然后自己写一个判断equal的方法，
在map里put的时候判断是不是euqal。
要么你就用重写add方法，重复的就不添加。
或者你就写distinct类的equals
重写distinct类的equals方法或者用set
换种数据类型就不ok了，不明白你到底要干什么
解法可参加apache org.apache.commons.collections下listUtil
各种对list的操作
继承ArrayList 重写add方法！！！
Distinct d1 = new Distinct("东莞", "长安沙头南区",1);&
Distinct d2 = new Distinct("东莞", "长安沙头南区",1);&
Distinct d3 = new Distinct("东莞", "桥头",1);&
Distinct d4 = new Distinct("东莞", "桥头",1);&
Distinct d5 = new Distinct("东莞", "桥头",1);&
Distinct d6 = new Distinct("东莞", "长安镇步步高",1);
List&Distinct& oldList = new ArrayList&Distinct&();&
oldList.add(d1);&
oldList.add(d2);&
oldList.add(d3);&
oldList.add(d4);&
oldList.add(d5);&
oldList.add(d6);
for(int i = 0;i & oldList.size();i++){
&& System.out.println(oldList.get(i).name+oldList.get(i).add+oldList.get(i).num);
&& System.out.println("--------------------------");
for(int i = 0;i & oldList.size();i++) {
for(int j = i+1;j & oldList.size();j++){
&& if(oldList.get(i).name.equals(oldList.get(j).name)
&& && oldList.get(i).add.equals(oldList.get(j).add)){
&& oldList.get(i).num = oldList.get(i).num + oldList.get(j).
&& oldList.remove(j);
&& for(int i = 0;i & oldList.size();i++){
&& System.out.println(oldList.get(i).name+oldList.get(i).add+oldList.get(i).num);
东莞长安沙头南区1
东莞长安沙头南区1
东莞桥头1
东莞桥头1
东莞长安镇步步高1
东莞桥头1
--------------------------
东莞长安沙头南区2
东莞桥头3
东莞长安镇步步高1
重写Distinct的equals方法，集合类用Set。
int length = oldList.size();
for (int i = 0; i & length-1; i++) {
& System.out.println("========"+i+"开始==========");
&&&&& for (int j = i+1; j & j++) {
if (oldList.get(i).equals(oldList.get(j))) {
System.out.println("移除&&&&"+oldList.get(j).getName1());
oldList.remove(j);
&&&&&&&& j--; //重置索引
length--; //list长度-1
}
&&&&& for (int k = 0; k& oldList.size(); k++) {
System.out.println(oldList.get(k).getName1());
}
&& System.out.println("----------"+i+"结束---------------");
}
将oldlist中的第i个变量取出来，设为di。然后remove掉oldlist中，所有和di“相等”的Distinct对象。最后，再把di填加到oldlist中。
另，为什么不用Set玩呢？
重写Distinct类的equals方法。
已解决问题
未解决问题其他回答(1)
方法的参数分为形参和值参两种，所谓值参就是传递参数的值，而形参就是传递参数的地址（在.NET里没有地址的概念，但作用是一样的）。
形参又分为引用参数和输出参数。
引用参数是原本就可能有内容的参数，也就是说，参数在调用的时候已经初始化了的（.NET中变量未赋值就使用是不允许的，ref引用参数定义就有这个要求）
输出参数是原本就为空的参数（可以为空，也可以不为空），如果原来参数有值也会被覆盖，在方法体内在方法结束前必须对输出参数（out）进行至少一次赋值。输出参数在调用之前定义的变量可以不赋值。
形参传递的必须是变量，而不能是常量、表达式等。
值参又分为值类型参数与引用类型参数（形参其实也是有这个区分）。对于引用类型的值参，方法体内可以对参数对象内容进行改变，如对集合的排序、增加、删除、插入成员，修改对象的属性等。而对于值类型的值参则没办法做任何改变。
理解了，你也就明白了你的问题为什么会这样了，以及该怎么去修正代码了。
收获园豆：2
园豆：5085
清除回答草稿
&&&您需要以后才能回答，未注册用户请先。泛型编程去掉字段重复数据的方法
转载 &更新时间：日 15:07:50 & 作者：
这篇文章主要介绍了泛型去掉字段重复数据的方法,大家参考使用吧
代码如下:public partial class V_MyJoinedCloudRespository
&&&&&&& public List&V_MyJoinedCloud& GetDistinctJoinedCloud(string cloudName,long ExpertId)&&&&&&& {&&&&&&&&&&& var lamd = from p in db.V_MyJoinedCloud&&&&&&&&&&&&&&&&&&&&&& where p.Status == 1 && p.CompanyName.Contains(cloudName) && p.ExpertID==ExpertId&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&& List&V_MyJoinedCloud& list = new List&V_MyJoinedCloud&();&&&&&&&&&&& if (lamd!=null&&lamd.Count()&0)&&&&&&&&&&& {&&&&&&&&&&&&&&& list = lamd.ToList();&&&&&&&&&&&&&&& list = list.Distinct(new CompanyNameComparer()).ToList();&&&&&&&&&&& }&&&&&&&&&&&&&&&&&& }
public class CompanyNameComparer : IEqualityComparer&V_MyJoinedCloud&&&& {&&&&&&& public bool Equals(V_MyJoinedCloud x, V_MyJoinedCloud y)&&&&&&& {&&&&&&&&&&& if (x == null)&&&&&&&&&&&&&&& return y ==&&&&&&&&&&& return x.CompanyID == y.CompanyID;&&&&&&& }
&&&&&&& public int GetHashCode(V_MyJoinedCloud obj)&&&&&&& {&&&&&&&&&&& if (obj == null)&&&&&&&&&&&&&&& return 0;&&&&&&&&&&& return obj.CompanyID.GetHashCode();&&&&&&& }&&& }
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具