Filtering a List based on the object's attribute value - Java/Javascript ?(Preferable streams/functional type of approach is preferred)

You can use an enhanced for loop to iterate over the objects in your List of objects. Call the getter method for the userType and check if it's equal to the word you want to filter. If so, add it's userId and userTypeId to the relevant Lists using getter methods.

EDIT : So after reading the comment, I have made changes and used a Set to get all the unique types and then made a list of UserList objects.

Like so:

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;
    }
}

Here's the solution using Java 8 streams:

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);
    }
}

Output (with some newlines inserted manually for clarity):

[
    {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"}
]