Фильтрация списка на основе значения атрибута объекта - Java / Javascript? (Предпочтительные потоки / функциональный тип подхода предпочтительнее)

Question

У меня есть список объектов.Объект имеет тип Class - UserType.

public class UserType {

    private int userId = 0;
    private int userTypeId = 0;
    private String userType;

//Getters and Setters;

}

Для упомянутого выше списка я хочу отфильтровать список на основе userType.UserType не является уникальным (может иметь одинаковые имена и не повторяться), но комбинация userId, userTypeId и userType уникальна.

Таким образом, требование, если у меня есть userType, как, скажем, - «ASSEMBLE», затем мне нужно сформировать список с одним уникальным userType, а также добавить userId и userTypeId в качестве списка в bean-компоненте.

EX: ФОРМАТ ВХОДА:

[{userId: 1, userTypeId: 101, userType: "ASSEMBLE" },
{userId: 1, userTypeId: 102, userType: "ASSEMBLE" },
{userId: 2, userTypeId: 103, userType: "ARCHS" },
{userId: 3, userTypeId: 103, userType: "ARCHS" },
{userId: 4, userTypeId: 104, userType: "BAYLEAF" },
{userId: 4, userTypeId: 105, userType: "BAYLEAF" },
{userId: 5, userTypeId: 106, userType: "CHARSET" }]

ОЖИДАЕМЫЕ: Результаты отфильтровываются на основе userType:

 [{userIds: [1] userTypeIds: [101,102], userType: "ASSEMBLE" },
    {userId: [2,3], userTypeId: [103], userType: "ARCHS" },
    {userId: [4], userTypeId: [104,105] userType: "BAYLEAF" },
    {userId: [5], userTypeId: [106], userType: "CHARSET" }]

Так, как правило, это должно быть похоже на bean-компонент -

public class UserType {

    private String userType;
    private List userIds = 0;
    private List userTypeIds = 0;


//Getters and Setters;

}

Как фильтровать этот объект на основена требование?Может также предоставить решения в Javascript, так что рассмотрим одно, что является значительно оптимизированными решениями.Заранее спасибо.

Answer 1

Вы можете сделать это, используя цикл for и Map, например:

import java.util.*;

public class GroupBy {

  public static void main(String[] args) {
    List<UserType> userTypes = new ArrayList<>();
    userTypes.add(new UserType(1, 101, "ASSEMBLE"));
    userTypes.add(new UserType(1, 102, "ASSEMBLE"));
    userTypes.add(new UserType(2, 103, "ARCHS"));
    userTypes.add(new UserType(3, 103, "ARCHS"));
    userTypes.add(new UserType(4, 104, "BAYLEAF"));
    userTypes.add(new UserType(4, 105, "BAYLEAF"));
    userTypes.add(new UserType(5, 106, "CHARSET"));

    Map<String, UserTypeGroup> map = new HashMap<>();
    for (UserType u : userTypes) {
      if (!map.containsKey(u.getUserType())) {
        map.put(u.getUserType(), new UserTypeGroup(u.getUserType()));
      }
      map.get(u.getUserType()).getUserIds().add(u.getUserId());
      map.get(u.getUserType()).getUserTypeIds().add(u.getUserTypeId());
    }

    System.out.println("INPUT:");
    System.out.println(userTypes);

    System.out.println("\nOUTPUT:");
    System.out.println(map.values());
  }
}

class UserType {

  private int userId;
  private int userTypeId;
  private String userType;

  UserType(int userId, int userTypeId, String userType) {
    this.userId = userId;
    this.userTypeId = userTypeId;
    this.userType = userType;
  }

  int getUserId() {
    return userId;
  }

  int getUserTypeId() {
    return userTypeId;
  }

  String getUserType() {
    return userType;
  }

  @Override
  public String toString()
  {
    return "{userId: " + userId + ", userTypeId: " + userTypeId +", userType: " + userType + "}\n";
  }
}

class UserTypeGroup {

  private String userType;
  private Set<Integer> userIds = new HashSet<>();
  private Set<Integer> userTypeIds = new HashSet<>();

  UserTypeGroup(String userType) {
    this.userType = userType;
  }

  Set<Integer> getUserIds() {
    return userIds;
  }

  Set<Integer> getUserTypeIds() {
    return userTypeIds;
  }

  @Override
  public String toString()
  {
    return "{userIds: " + userIds + ", userTypeIds: " + userTypeIds + ", userType: " + userType + "}\n";
  }
}

Вывод будет следующим:

INPUT:
[{userId: 1, userTypeId: 101, userType: ASSEMBLE}
, {userId: 1, userTypeId: 102, userType: ASSEMBLE}
, {userId: 2, userTypeId: 103, userType: ARCHS}
, {userId: 3, userTypeId: 103, userType: ARCHS}
, {userId: 4, userTypeId: 104, userType: BAYLEAF}
, {userId: 4, userTypeId: 105, userType: BAYLEAF}
, {userId: 5, userTypeId: 106, userType: CHARSET}
]

OUTPUT:
[{userIds: [5], userTypeIds: [106], userType: CHARSET}
, {userIds: [1], userTypeIds: [101, 102], userType: ASSEMBLE}
, {userIds: [2, 3], userTypeIds: [103], userType: ARCHS}
, {userIds: [4], userTypeIds: [104, 105], userType: BAYLEAF}
]

Answer 2

Вот решение с использованием потоков Java 8:

import java.util.*;
import java.util.stream.Collector;

import static java.util.stream.Collectors.collectingAndThen;
import static java.util.stream.Collectors.groupingBy;

class UserType {

    private final int userId;
    private final int userTypeId;
    private final String userType;

    public UserType(int userId, int userTypeId, String userType) {
        this.userId = userId;
        this.userTypeId = userTypeId;
        this.userType = userType;
    }

    public int getUserId()      { return userId; }
    public int getUserTypeId()  { return userTypeId; }
    public String getUserType() { return userType; }

    @Override
    public String toString() {
        return "{userId: " + userId + ", userTypeId: " + userTypeId + ", userType: \"" + userType + "\"}";
    }
}

class UserTypeGroup {

    private final Set<Integer> userIds = new HashSet<>();
    private final Set<Integer> userTypeIds = new HashSet<>();
    private String userType;

    public UserTypeGroup add(UserType ut) {
        userIds.add(ut.getUserId());
        userTypeIds.add(ut.getUserTypeId());
        if (userType == null)
                userType = ut.getUserType();
        else if (!userType.equals(ut.getUserType()))
            throw new IllegalArgumentException("usertypes do not match");
        return this;
    }

    public UserTypeGroup combine(UserTypeGroup other) {
        userIds.addAll(other.userIds);
        userTypeIds.addAll(other.userTypeIds);
        if (userType == null)
            userType = other.userType;
        else if (!userType.equals(other.userType))
            throw new IllegalArgumentException("usertypes do not match");
        return this;
    }

    public Set<Integer> getUserIds()     { return Collections.unmodifiableSet(userIds); }
    public Set<Integer> getUserTypeIds() { return Collections.unmodifiableSet(userTypeIds); }
    public String getUserType()          { return userType; }

    @Override
    public String toString() {
        return "{userIds: " + userIds+ ", userTypeIds: " + userTypeIds + ", userType: \"" + userType + "\"}";
    }
}

class Main {
    public static void main(String[] args) {
        List<UserType> userTypes = Arrays.asList(
                new UserType(1, 101, "ASSEMBLE"),
                new UserType(1, 102, "ASSEMBLE"),
                new UserType(2, 103, "ARCHS"),
                new UserType(3, 103, "ARCHS"),
                new UserType(4, 104, "BAYLEAF"),
                new UserType(4, 105, "BAYLEAF"),
                new UserType(5, 106, "CHARSET"));
        Collection<UserTypeGroup> result = userTypes.stream()
                .collect(collectingAndThen(
                        groupingBy(
                                UserType::getUserType,
                                Collector.of(UserTypeGroup::new, UserTypeGroup::add, UserTypeGroup::combine)), 
                        Map::values));
        System.out.println(result);
    }
}

Вывод (с некоторыми символами новой строки, вставленными вручную для ясности):

[
    {userIds: [5], userTypeIds: [106], userType: "CHARSET"},
    {userIds: [1], userTypeIds: [101, 102], userType: "ASSEMBLE"},
    {userIds: [2, 3], userTypeIds: [103], userType: "ARCHS"},
    {userIds: [4], userTypeIds: [104, 105], userType: "BAYLEAF"}
]

Answer 3

Вы можете использовать расширенный цикл для цикла , чтобы перебирать объекты в вашем Списке объектов.Вызовите метод get для userType и проверьте, соответствует ли оно слову, которое вы хотите отфильтровать.Если это так, добавьте его userId и userTypeId в соответствующие списки с помощью методов получения.

EDIT: Поэтому после прочтения комментария я внес изменения, и использовал Set, чтобы получить всеуникальные типы , а затем составили список объектов UserList.

Примерно так:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Users{

    private List<UserType> objectList = new ArrayList<>();  //arraylist containing your objects
    private List<UserList> uniqueUserList = new ArrayList<>();

    private void filter() {   
        List<String> userTypeList = new ArrayList<>();
        for(UserType obj: objectList){
            userTypeList.add(obj.getType());    //get only Types
        }
        Set<String> uniqueUserTypes = new HashSet(userTypeList);    //set only contians unique strings
        for(String s: uniqueUserTypes)
        {
            addToUniqueList(s);
        }
    }

    private void addToUniqueList(String userTypeName){
        String filterBy = userTypeName;

        UserList listsForUniqueType = new UserList();
        listsForUniqueType.setType(filterBy);

        for(UserType obj: objectList) {
           if(obj.getType().equals(filterBy)){
               listsForUniqueType.addToUserId(obj.getId());
               listsForUniqueType.addToUserId(obj.getTypeId());
           }
        }
        uniqueUserList.add(listsForUniqueType);
    }

    public class UserList {
        private String userType;
        private List<Integer> userIds = new ArrayList<>();
        private List<Integer> userTypeIds = new ArrayList<>();

        public void setType(String typeName){
            userType = typeName;
        }
        public void addToUserId(int id){
            userIds.add(id);
        }
        public void addToTypeId(int id){
            userTypeIds.add(id);
        }
    }

    public class UserType {
        private int userId = 0;
        private int userTypeId = 0;
        private String userType;
        //Getters and Setters;
    }
}