Java-将数据从一个列表传输到另一个列表_Java

Java-将数据从一个列表传输到另一个列表

java

Java-将数据从一个列表传输到另一个列表,java,Java,这是一个场景，在我的源代码列表中，它包含所有用户对象。每个用户对象都将具有id、事件和时间戳。我需要创建一个目的地列表来包含所有用户对象，这些用户对象具有每个id的最新时间戳记录。如下面的示例所示 import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Date; import java.util.List; import com.vi

这是一个场景，在我的源代码列表中，它包含所有用户对象。每个用户对象都将具有

id

、

事件

和

时间戳

。我需要创建一个目的地列表来包含所有用户对象，这些用户对象具有每个id的最新时间戳记录。如下面的示例所示

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import com.vincent.object.User;

public class Test {
  public static void main(String[] args) throws Exception {
    DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    User u1 = new User("1", "55", dateFormat.parse("2017-10-01 10:11:01.111"));
    User u2 = new User("1", "105", dateFormat.parse("2017-10-01 10:11:02.111"));
    User u3 = new User("2", "55", dateFormat.parse("2017-10-01 10:11:03.111"));
    List<User> sources = new ArrayList<>();
    sources.add(u1);
    sources.add(u2);
    sources.add(u3);

    List<User> destination = new ArrayList<>();
    // I want my destination array only contains following 2 result:
    // u2 and u3 from the source
  }
}

我假设您不需要像在源代码列表中那样保持用户的顺序。其思路如下：

迭代源列表
在映射中添加每个用户（如果不存在），如果存储的用户的时间戳低于当前用户，则更新该用户（假设两个用户具有相同的id，则两个用户相等）

返回映射的键集

public static void main(String[] args)
{
     DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
     User u1 = new User("1", "55", dateFormat.parse("2017-10-01 10:11:01.111"));
     User u2 = new User("1", "105", dateFormat.parse("2017-10-01 10:11:02.111"));
     User u3 = new User("2", "55", dateFormat.parse("2017-10-01 10:11:03.111"));
     List<User> sources = new ArrayList<>();
     sources.add(u1);
     sources.add(u2);
     sources.add(u3);

     Set<User> uniqUsers = new HashSet<>();
     for(User u : sources)
     {
         if(uniqUsers.containsKey(u))
         {
             User oldUser = uniqUsers.get(u);
             long oldTimeStamp = uniqUsers.get(u).getDate().getTime();
             long currentTimeStamp = u.getDate().getTime();
             if(currentTimeStamp > oldTimeStamp)
                 uniqUsers.remove(oldUser);
            uniqUsers.add(u);
         }
      }
      List<User> destination = new ArrayList<>(uniqUsers);

 }

为此，可以使用Java8流

public class Test {
    public static void main(String[] args) throws Exception {
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        User u1 = new User("1", "55", dateFormat.parse("2017-10-01 10:11:01.111"));
        User u2 = new User("1", "105", dateFormat.parse("2017-10-01 10:11:02.111"));
        User u3 = new User("2", "55", dateFormat.parse("2017-10-01 10:11:03.111"));
        User u4 = new User("2", "105", dateFormat.parse("2017-10-01 10:11:04.111"));
        List<User> sources = new ArrayList<>();
        sources.add(u1);
        sources.add(u2);
        sources.add(u3);
        sources.add(u4);


        List<User> destination = sources.stream()
                .collect(Collectors.groupingBy(User::getId, Collectors.maxBy(Comparator.comparing(User::getDate))))
                .values()
                    .stream()
                    .map(o -> o.get())
                    .collect(Collectors.toList());

        System.out.println(destination);
    }
}

公共类测试{
公共静态void main（字符串[]args）引发异常{
DateFormat DateFormat=新的简化格式（“yyyy-MM-dd HH:MM:ss.SSS”）；
用户u1=新用户（“1”，“55”，dateFormat.parse（“2017-10-01 10:11:01.111”）；
用户u2=新用户（“1”，“105”，dateFormat.parse（“2017-10-01 10:11:02.111”）；
用户u3=新用户（“2”，“55”，dateFormat.parse（“2017-10-01 10:11:03.111”）；
用户u4=新用户（“2”，“105”，dateFormat.parse（“2017-10-01 10:11:04.111”）；
列表源=新的ArrayList（）；
资料来源。添加（u1）；
资料来源：添加（u2）；
资料来源。添加（u3）；
资料来源：添加（u4）；
列表目的地=sources.stream（）
.collect（Collectors.groupingBy（User:：getId，Collectors.maxBy（Comparator.comparing（User:：getDate）））
.values（）
.stream（）
.map（o->o.get（））
.collect（Collectors.toList（））；
系统输出打印项次（目的地）；
}
}

在这里，我通过ID获取用户的日期

输出（显然覆盖了用户类上的toString）：

[User{id='1'，reason='105'，date=Sun Oct 01 10:11:02 BOT 2017}，
用户{id='2'，reason='105'，date=Sun Oct 01 10:11:04 BOT 2017}]

如果我阅读问题，用户“1”和用户“2”的最新日期。一些流操作？您好，您的意思是将一个列表保存在另一个列表中吗？您不能在添加后将源列表存储在目标中，并添加一个条件来检查列表的内容是否相同，方法是使用！集合。不相交（列表1、列表2）；或普通等于方法列表1.equals（列表2）；这里有一个关于使用有状态筛选器谓词的流的问题：FYI、

Date

和

SimpleDateFormat

是现在遗留的麻烦的旧日期时间类的一部分，如果您想按照某些注释中的建议使用流，您可以始终应用实现HashSet逻辑的过滤器。另一种解决方案是按日期对数组进行排序（

Collections.sort（sources，Comparator.comparingit（u->u.getDate（）.getTime（））

）；然后从右到左迭代，让每个用户只在第一次见面时使用。

public class User 
{
    private String id;
    private String reason;
    private Date date;

    public User(String id, String reason, Date date) 
    {
        super();
        this.id = id;
        this.reason = reason;
        this.date = date;
     }
     // getter setter


     @Override
     public int hashCode()
     {
        return id.hashCode();
     }

     @Override
     public boolean equals(Object obj)
     {
         return obj instanceof User && ((User) obj).id.equals(id);
     }
}

public class Test {
    public static void main(String[] args) throws Exception {
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        User u1 = new User("1", "55", dateFormat.parse("2017-10-01 10:11:01.111"));
        User u2 = new User("1", "105", dateFormat.parse("2017-10-01 10:11:02.111"));
        User u3 = new User("2", "55", dateFormat.parse("2017-10-01 10:11:03.111"));
        User u4 = new User("2", "105", dateFormat.parse("2017-10-01 10:11:04.111"));
        List<User> sources = new ArrayList<>();
        sources.add(u1);
        sources.add(u2);
        sources.add(u3);
        sources.add(u4);


        List<User> destination = sources.stream()
                .collect(Collectors.groupingBy(User::getId, Collectors.maxBy(Comparator.comparing(User::getDate))))
                .values()
                    .stream()
                    .map(o -> o.get())
                    .collect(Collectors.toList());

        System.out.println(destination);
    }
}