ArrayList Table Sum

[Pvo Gri]

What would be the best way to Sum Arraylist table different values?

For example we have a table:

Name                Time(s)                 State                        
John                      54                    Florida
Mike                      48                    Texas
Kyrie                     32                    Texas
Joe                        21                    Florida
Josh                      45                    Cali
Robert                   60                    Texas

Let's say we have the table info stored in an Arraylist
What algorithm would you use to calculate the time totals of states?

The final result should look like this:

State                       Time
Florida                      75
Texas                       140
Cali                           45

[Norm Radder]

How is the data stored in the ArrayList?  Is there a class that holds the data that is shown on each row of the posted table?
Does the class have get methods for all the data items held in the class?

[Pvo Gri]

Data is stored from a json file. Yes, there is a class that holds the data and it also has getters and setters.

[Carey Brown]

Do you know how to use a Map?

[Pvo Gri]

I am familiar with it, but I wouldn't say I fully know how to

[Norm Radder]

Look at using a Map<String, TheCounter> where the key is the name of the state, and the value is an instance of TheCounter which is your class that holds the sum of the times.

[Carey Brown]

TheCounter could be as simple as Integer.

[salvin francis]

Pvo Gri wrote:What would be the best way to Sum Arraylist table different values?

The oracle tutorial mentions this: https://docs.oracle.com/javase/tutorial/collections/interfaces/map.html
You can find the example for "Map Interface Basic Operations" that calculates frequency. It perfectly fits your requirement if you know the tinkering required

[Campbell Ritchie]

Needless to say there is a way to create a Map with a Stream. But you need to read the file into a List<Player> first. I shall leave it as an exercise for the reader and might let you out of your misery in due course.

[Campbell Ritchie]

Assuming you have a List<Player> called players, you can do this:-

Map<String, Integer> totalTimes = players.stream()
                                         .collect(Collectors.groupingBy(Player::getState),
                                                  Collectors.summingInt(Player::getTime));

Has somebody given me a cow? Thank you whoever it was

[Norm Radder]

I'm still trying to learn streams so I copied the code into my test environment and compiled it, getting these errors:

      class Player {
         int time;
         String state;
         int getTime() { return time;}
         String getState() {return state;}
      }
      java.util.List<Player> players = new ArrayList<>();
      Map<String, Integer> totalTimes = players.stream()
                                         .collect(Collectors.groupingBy(Player::getState),
                                                  Collectors.summingInt(Player::getTime));
/*
Running: D:\Java\jdk-14\bin\javac.exe  -Xlint -cp . -Xdiags:verbose TestCode26.java

TestCode26.java:1171: error: no suitable method found for collect(Collector<Player,CAP#1,Map<String,List<Player>>>,Collector<Player,CAP#2,Integer>)
                                         .collect(Collectors.groupingBy(Player::getState),
                                         ^
    method Stream.<R#1>collect(Supplier<R#1>,BiConsumer<R#1,? super Player>,BiConsumer<R#1,R#1>) is not applicable
      (cannot infer type-variable(s) R#1
        (actual and formal argument lists differ in length))
    method Stream.<R#2,A>collect(Collector<? super Player,A,R#2>) is not applicable
      (cannot infer type-variable(s) R#2,A
        (actual and formal argument lists differ in length))
  where R#1,T,R#2,A are type-variables:
    R#1 extends Object declared in method <R#1>collect(Supplier<R#1>,BiConsumer<R#1,? super T>,BiConsumer<R#1,R#1>)
    T extends Object declared in interface Stream
    R#2 extends Object declared in method <R#2,A>collect(Collector<? super T,A,R#2>)
    A extends Object declared in method <R#2,A>collect(Collector<? super T,A,R#2>)
  where CAP#1,CAP#2 are fresh type-variables:
    CAP#1 extends Object from capture of ?
    CAP#2 extends Object from capture of ?
1 error

2 error(s)
*/

[Campbell Ritchie]

That is because I have “corrected” the code by moving some () and got them in the wrong places. Sorry.

Map<String, Integer> totalTimes = players.stream()
                                         .collect(Collectors.groupingBy(Player::getState,
                                                  Collectors.summingInt(Player::getTime)));

The summingInt() call creates a Collector and that is a second argument to groupingBy().

[Piet Souris]

A useful alternative is the method 'map.merge'.
For instance:

var map = new HashMap<String, Integer>();
for (var p: players) map.merge(p.getState(), p.getTime(), Integer::sum);

And using static imports is a very nice typesaver.