Count and remove similar elements in a list while iterating through it

Question

I used many references in the site to build up my program but I'm kind of stuck right now. I think using iterator will do the job. Sadly even though I went through questions which had iterator, I couldn't get the way of using it properly to implement it on my code.

I want to, 1. remove the similar elements found in the list fname 2. count & add the that count of each element found in fname to counter.

Please help me do the above using iterator or with any other method. Following is my code,

List<String> fname = new ArrayList<>(Arrays.asList(fullname.split(""))); //Assigning the string to a list//

    int count = 1;
    ArrayList<Integer> counter = new ArrayList<>();
    List<String> holder = new ArrayList<>();

    for(int element=0; element<=fname.size; element++)
    {
        for(int run=(element+1); run<=fname.size; run++)
        {
            if((fname.get(element)).equals(fname.get(run)))
            {
                count++;
                holder.add(fname.get(run));
            }

            counter.add(count);                    
        }

        holder.add(fname.get(element));
        fname.removeAll(holder);
    }

    System.out.println(fname);
    System.out.println(counter);

Thanks.

Answer 1

From your questions, you basically want to:

1. Eliminate duplicates from given String List

You can simply convert your List to HashSet (it doesn't allow duplicates) and then convert it back to list (if you want the end result to be a List so you can do something else with it...)

2. Count all occurences of unique words in your list The fastest coding is to use Java 8 Streams (code borrowed frome here: How to count the number of occurrences of an element in a List)

Complete code

public static void main(String[] args) {
    String fullname = "a b c d a b c"; //something
    List<String> fname = new ArrayList<>(Arrays.asList(fullname.split(" ")));

    // Convert input to Set, and then back to List (your program output)
    Set<String> uniqueNames = new HashSet<>(fname);
    List<String> uniqueNamesInList = new ArrayList<>(uniqueNames);
    System.out.println(uniqueNamesInList);

    // Collects (reduces) your list
    Map<String, Long> counts = fname.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
    System.out.println(counts);
}

Answer 2

You can try something like this:

Set<String> mySet = new HashSet<>();
mySet.addAll( fname ); // Now you have unique values

for(String s : mySet) {
    count = 0;
    for(String x : fname) {
        if( s.equals(x) ) { count++; }
    }
    counter.add( count );
}

This way we don't have a specific order. But I hope it helps.

In Java 8, there's a one-liner:

List<Integer> result = fname
    .stream()
    .collect(Collectors.groupingBy(s -> s))
    .entrySet()
    .stream()
    .map(e -> e.getValue().size())
    .collect(Collectors.toList());

Answer 3

I do not think that you need iterators here. However, there are many other possible solutions you could use, like recursion. Nevertheless, I have just modified your code as the following:

    final List<String> fname = new ArrayList<String>(Arrays.asList(fullname.split("")));
    // defining a list that will hold the unique elements.
    final List<String> resultList = new ArrayList<>();
    // defining a list that will hold the number of replication for every item in the fname list; the order here is same to the order in resultList
    final ArrayList<Integer> counter = new ArrayList<>();

    for (int element = 0; element < fname.size(); element++) {
        int count = 1;
        for (int run = (element + 1); run < fname.size(); run++) {
            if ((fname.get(element)).equals(fname.get(run))) {
                count++;
                // we remove the element that has been already counted and return the index one step back to start counting over.
                fname.remove(run--);
            }
        }
        // we add the element to the resulted list and counter of that element
        counter.add(count);
        resultList.add(fname.get(element));
    }
    // here we print out both lists.
    System.out.println(resultList);
    System.out.println(counter);

Assuming String fullname = "StringOfSomeStaff"; the output will be as the following:

[S, t, r, i, n, g, O, f, o, m, e, a]
[3, 2, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1]

Answer 4

I was using LinkedHashMap to preserve order of elements. Also for loop, which I am using, implicitly uses Iterator. Code example is using Map.merge method, which is available since Java 8.

    List<String> fname = new ArrayList<>(Arrays.asList(fullname.split("")));
    /*
        Create Map which will contain pairs kay=values
        (in this case key is a name and value is the counter).
        Here we are using LinkedHashMap (instead of common HashMap)
        to preserve order in which name occurs first time in the list.
    */
    Map<String, Integer> countByName = new LinkedHashMap<>();
    for (String name : fname) {
        /*
             'merge' method put the key into the map (first parameter 'name').
             Second parameter is a value which we that to associate with the key
             Last (3rd) parameter is a function which will merge two values
             (new and ald) if map already contains this key
         */
        countByName.merge(name, 1, Integer::sum);
    }
    System.out.println(fname);                  // original list [a, d, e, a, a, f, t, d]
    System.out.println(countByName.values());   // counts [3, 2, 1, 1, 1]
    System.out.println(countByName.keySet());   // unique names [a, d, e, f, t]

Also same might be done using Stream API but it would be probably hard for understanding if you are not familiar with Streams.

    Map<String, Long> countByName = fname.stream()
            .collect(Collectors.groupingBy(Function.identity(), LinkedHashMap::new, Collectors.counting()));