Java 在ArrayList中查找重复的值

我是一个编程新手

我有

List<DataProvider> dataProviders = new ArrayList<DataProvider>();

---

我想要得到一个没有重复的

日期的列表，并且所有重复的列表值应该加起来。
如果您想要返回
数据提供程序中包含不同重复项的
列表，您应该能够使用以下内容：

dataProviders.stream().filter(d -> Collections.frequency(dataProviders, d) > 1).distinct().collect(Collectors.toList());

要使用它，您还需要覆盖
DataProvider.java
中的
Object#equals
和
Object#hashCode
：

@Override
public boolean equals(Object o) {
    if (!(o instanceof DataProvider)) {
        return false;
    }

    return date.equals(((DataProvider) o).date);
}

@Override
public int hashCode() {
    return Objects.hash(date);
}

如果您想返回一个
列表
，该列表包含
数据提供程序中的不同重复项，您应该能够使用以下内容：

dataProviders.stream().filter(d -> Collections.frequency(dataProviders, d) > 1).distinct().collect(Collectors.toList());

要使用它，您还需要覆盖
DataProvider.java
中的
Object#equals
和
Object#hashCode
：

@Override
public boolean equals(Object o) {
    if (!(o instanceof DataProvider)) {
        return false;
    }

    return date.equals(((DataProvider) o).date);
}

@Override
public int hashCode() {
    return Objects.hash(date);
}

当日期相同时，可以使用Set并实现DataProvider的equals方法返回true

public class DataProvider {

private Date date;
private int pendingtickets;
private int closedtickets;
private int createdtickets;

@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    DataProvider other = (DataProvider) obj;
    if (date == null) {
        if (other.date != null)
            return false;
    } else if (!date.equals(other.date))
        return false;
    return true;
}

}
当日期相同时，可以使用Set并实现DataProvider的equals方法返回true

public class DataProvider {

private Date date;
private int pendingtickets;
private int closedtickets;
private int createdtickets;

@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    DataProvider other = (DataProvider) obj;
    if (date == null) {
        if (other.date != null)
            return false;
    } else if (!date.equals(other.date))
        return false;
    return true;
}

}
如果我了解您想要什么，您可以制作如下：

Map<Date, DataProvider> res = new HashMap<Date, DataProvider>();
for (DataProvider dp : dataProviders) {
    if (!res.containsKey(dp.getDate())) {
        res.put(dp.getDate(), dp);
    }

    else{ 
        res.get(dp.getDate()).setPendingtickets(res.get(dp.getDate()).getPendingtickets() + dp.getPendingtickets());
        res.get(dp.getDate()).setClosedtickets(res.get(dp.getDate()).getClosedtickets() + dp.getClosedtickets());
        res.get(dp.getDate()).setCreatedtickets(res.get(dp.getDate()).getCreatedtickets());
    }
}
List<DataProvider> result = new ArrayList<DataProvider>(res.values());

Map res=newhashmap（）；
对于（数据提供程序dp:dataProviders）{
如果（！res.containsKey（dp.getDate（）））{
res.put（dp.getDate（），dp）；
}
否则{
res.get（dp.getDate（））.setPendingtickets（res.get（dp.getDate（））.getPendingtickets（）+dp.getPendingtickets（））；
res.get（dp.getDate（））.setClosedtickets（res.get（dp.getDate（））.getClosedtickets（）+dp.getClosedtickets（））；
res.get（dp.getDate（））.setCreatedtickets（res.get（dp.getDate（））.getCreatedtickets（））；
}
}
列表结果=新的ArrayList（res.values（））；
如果我了解您想要什么，您可以制作如下内容：

Map<Date, DataProvider> res = new HashMap<Date, DataProvider>();
for (DataProvider dp : dataProviders) {
    if (!res.containsKey(dp.getDate())) {
        res.put(dp.getDate(), dp);
    }

    else{ 
        res.get(dp.getDate()).setPendingtickets(res.get(dp.getDate()).getPendingtickets() + dp.getPendingtickets());
        res.get(dp.getDate()).setClosedtickets(res.get(dp.getDate()).getClosedtickets() + dp.getClosedtickets());
        res.get(dp.getDate()).setCreatedtickets(res.get(dp.getDate()).getCreatedtickets());
    }
}
List<DataProvider> result = new ArrayList<DataProvider>(res.values());

Map res=newhashmap（）；
对于（数据提供程序dp:dataProviders）{
如果（！res.containsKey（dp.getDate（）））{
res.put（dp.getDate（），dp）；
}
否则{
res.get（dp.getDate（））.setPendingtickets（res.get（dp.getDate（））.getPendingtickets（）+dp.getPendingtickets（））；
res.get（dp.getDate（））.setClosedtickets（res.get（dp.getDate（））.getClosedtickets（）+dp.getClosedtickets（））；
res.get（dp.getDate（））.setCreatedtickets（res.get（dp.getDate（））.getCreatedtickets（））；
}
}
列表结果=新的ArrayList（res.values（））；
试试这个

package com.stackoverflow.responses;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class Dataprovider{
    private Date date;
    private int pendingTickets;
    public Date getDate() {
        return date;
    }
    public void setDate(Date date) {
        this.date = date;
    }
    public int getPendingTickets() {
        return pendingTickets;
    }
    public void setPendingTickets(int pendingTickets) {
        this.pendingTickets = pendingTickets;
    }
    public Dataprovider(Date date, int pendingTickets) {
        super();
        this.date = date;
        this.pendingTickets = pendingTickets;
    }
    @Override
    public String toString() {
        return "[ pendingTickets=" + pendingTickets + "]";
    }
}

public class DateSort {

    /*
     * It is to count number of duplicates prevailing in given list
     * */
    public static int getCount(List<Dataprovider> dp,Date date){
        int count = 0;
        for(int i = dp.size()-1;i > -1; i--){
            if(dp.get(i).getDate().compareTo(date) == 0){
                count++;
            }
        }
        return count;
    }
    /*
     * returning list of particular index ie: date*/
    private static List<Dataprovider> getList(Map<Date, List<Dataprovider>> map, Date date) {
        return map.get(date);
    }
    public static void main(String[] args) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        List<Dataprovider> dataproviders = new ArrayList<Dataprovider>();
        try {
            dataproviders.add(new Dataprovider(dateFormat.parse("2016-01-10"), 1));
            dataproviders.add(new Dataprovider(dateFormat.parse("2016-01-10"), 0));
            dataproviders.add(new Dataprovider(dateFormat.parse("2016-01-09"), 0));
            dataproviders.add(new Dataprovider(dateFormat.parse("2016-01-07"), 1));
            dataproviders.add(new Dataprovider(dateFormat.parse("2016-01-07"), 1));
        } catch (ParseException e) {
            System.out.println(e.getMessage());
        }
        /*
         * if you just need the count of duplicates existing 
         * you could just use this result
         * */
        List<Dataprovider> output = dataproviders.stream().filter(n->DateSort.getCount(dataproviders, n.getDate())>1).collect(Collectors.toList());
        System.out.println(output);
        Map<Date,List<Dataprovider>> map = new HashMap<Date,List<Dataprovider>>();
        for(Dataprovider dp : dataproviders){
            /*
             * if map doesn't contain particular date 
             * adding date to map*/
            if(!map.containsKey(dp.getDate())){
                List<Dataprovider> temp = new ArrayList<Dataprovider>();
                temp.add(dp);
                map.put(dp.getDate(), temp);
            }else{
                List<Dataprovider> temp = new ArrayList<Dataprovider>();
                temp.addAll(getList(map,dp.getDate()));
                temp.add(dp);
                map.put(dp.getDate(), temp);
            }
        }
        /*
         * filtering and adding result to another map
         * */
        Map<Date,Dataprovider> outputMap = new HashMap<Date,Dataprovider>();
        for(Date date : map.keySet()){
            if(map.get(date).size()>1){
                int count = 0;
                for(int i = 0; i < map.get(date).size();i++){
                    count = count+map.get(date).get(i).getPendingTickets();
                }
                Dataprovider dataprovider = new Dataprovider(date, count);
                outputMap.put(date, dataprovider);
            }else{
                outputMap.put(date,map.get(date).get(0));
            }
        }
        for(Date date : outputMap.keySet()){
            System.out.println("date :: "+date+" "+outputMap.get(date));
        }
    }
}

package com.stackoverflow.responses；
导入java.text.ParseException；
导入java.text.simpleDataFormat；
导入java.util.ArrayList；
导入java.util.Date；
导入java.util.HashMap；
导入java.util.List；
导入java.util.Map；
导入java.util.stream.collector；
类数据提供程序{
私人日期；
私人内部悬而未决的诉讼；
公共日期getDate（）{
返回日期；
}
公共作废设置日期（日期）{
this.date=日期；
}
public int getPendingTickets（）{
返回挂起标签；
}
公共无效设置挂起tickets（int挂起tickets）{
this.pendingTickets=pendingTickets；
}
公共数据提供程序（日期，int pendingTickets）{
超级（）；
this.date=日期；
this.pendingTickets=pendingTickets；
}
@凌驾
公共字符串toString（）{
返回“[pendingTickets=“+pendingTickets+”]”；
}
}
公共类日期排序{
/*
*计算给定列表中的副本数量
* */
公共静态int getCount（列表dp，日期）{
整数计数=0；
对于（int i=dp.size（）-1；i>-1；i--）{
if（dp.get（i）.getDate（）.compareTo（date）==0）{
计数++；
}
}
返回计数；
}
/*
*特定索引的返回列表，即：日期*/
私有静态列表getList（映射、日期）{
返回地图。获取（日期）；
}
公共静态void main（字符串[]args）{
SimpleDataFormat dateFormat=新SimpleDataFormat（“yyyy-MM-dd”）；
List dataproviders=new ArrayList（）；
试一试{
数据提供者。添加（新数据提供者（dateFormat.parse（“2016-01-10”），1）；
添加（新的数据提供程序（dateFormat.parse（“2016-01-10”），0））；
添加（新的数据提供程序（dateFormat.parse（“2016-01-09”），0））；
添加（新的数据提供程序（dateFormat.parse（“2016-01-07”），1））；
添加（新的数据提供程序（dateFormat.parse（“2016-01-07”），1））；
}捕获（解析异常）{
System.out.println（e.getMessage（））；
}
/*
*如果您只需要现有副本的计数
*你可以用这个结果
* */
列表输出=dataproviders.stream（）.filter（n->DateSort.getCount（dataproviders，n.getDate（））>1.collect（Collectors.toList（））；
系统输出打印项次（输出）；
Map Map=newhashmap（）；
对于（数据提供程序dp:dataproviders）{
/*
*如果地图不包含特定日期
*向地图添加日期*/
如果（！map.containsKey（dp.getDate（）））{
List temp=new ArrayList（）；
温度添加（dp）；
map.put（dp.getDate（），temp）；
}否则{
List temp=new ArrayList（）；
临时addAll（getList（map，dp.getDate（））；
温度添加（dp）；
map.put（dp.getDate（），temp）；
}
}
/*
*过滤并将结果添加到另一个映射
* */
Map outputMap=newhashmap（）；
for（日期：map.keySet（））{
if（map.get（date.size（）>1）{
整数计数=0；
for（int i=0；i