Remove duplicates from list based on duplicate index in another list

I have 2 Lists: Names & IDs.

There are cases where the same name will appear multiple times. For example:

Names = {'ben','david','jerry','tom','ben'}
IDs   = {'123','23456','34567','123','123'}

I know I can use

Set<String> set = new LinkedHashSet<>( Names );
Names .clear();
Names .addAll( set );

In order to remove duplicates, however, it not what I want.

What I would like to do is to check where Names has a duplicate value which in this case will be the last value and then remove from IDs the value at that position so the final result will be:

Names = {'ben','david','jerry','tom'}
IDs   = {'123','23456','34567','123'}

How can I get the index of the duplicated value in order to remove it from the second list? or is there some easy and fast way to do it?

I'm sure I can solve it by using a loop but I try to avoid it.

SOLUTION:

I changed the code to use:

Map<String, String> map = new HashMap<>();

When using:

map.put(name,id);

It might not do the job since there are cases where the same name has different it and it won't allow duplicate in the name so just changed to map.put(id,name) and it did the job.

Thank you

You could collect the data from both input arrays/lists into a set of pairs and then recollect the pairs back to two new lists (or clear and reuse existing names/IDs lists):

List<String> names = Arrays.asList("ben","david","jerry","tom","ben");
List<String> IDs   = Arrays.asList("123","23456","34567","123","123");

// assuming that both lists have the same size
// using list to store a pair
Set<List<String>> deduped = IntStream.range(0, names.size())
                 .mapToObj(i -> Arrays.asList(names.get(i), IDs.get(i)))
                 .collect(Collectors.toCollection(LinkedHashSet::new));

System.out.println(deduped);
System.out.println("-------");

List<String> dedupedNames = new ArrayList<>();
List<String> dedupedIDs = new ArrayList<>();
deduped.forEach(pair -> {dedupedNames.add(pair.get(0)); dedupedIDs.add(pair.get(1)); });

System.out.println(dedupedNames);
System.out.println(dedupedIDs);

Output:

[[ben, 123], [david, 23456], [jerry, 34567], [tom, 123]]
-------
[ben, david, jerry, tom]
[123, 23456, 34567, 123]

You can collect as a map using Collectors.toMap then get the keySet and values from map for names and ids list.

List<String> names = Arrays.asList("ben","david","jerry","tom","ben");
List<String> ids   = Arrays.asList("123","23456","34567","123","123");
Map<String, String> map = 
          IntStream.range(0, ids.size())
                   .boxed()
                   .collect(Collectors.toMap(i -> names.get(i), i -> ids.get(i),
                                             (a,b) -> a, LinkedHashMap::new));
List<String> newNames = new ArrayList<>(map.keySet());
List<String> newIds = new ArrayList<>(map.values());

You can do map creation part using loop also

Map<String, String> map = new LinkedHashMap<>();
for (int i = 0; i < names.size(); i++) {
  if(!map.containsKey(names.get(i))) {
    map.put(names.get(i), ids.get(i));
  }
}

You could add your names one by one to a set as long as Set.add returns true and if it returns false store the index of that element in a list (indices to remove). Then sort the indices list in reverse order and use List.remove(int n) on both your names list and id list:

List<String> names = ...
List<String> ids = ...
Set<String> set = new HashSet<>();
List<Integer> toRemove = new ArrayList<>();

for(int i = 0; i< names.size(); i ++){
    if(!set.add(names.get(i))){
        toRemove.add(i);
    }
}

Collections.sort(toRemove, Collections.reverseOrder());
for (int i : toRemove){
    names.remove(i);  
    ids.remove(i);
}

System.out.println(toRemove);

System.out.println(names);
System.out.println(ids);