Get Max Value from List in Java

I have a list like below

List{        
{Type=A, Amt=30000},{Type=A, Amt=50000},{Type=B, Amt=40000},{Type=B,Amt=60000},{Type=C,spRqstAmt=50000},{Type=C,Amt=10000}
}

I need to print the max amount for each Type.

Output:

Type: A,
Amt: 50000

Type: B,
Amt: 60000

Type: C,
Amt: 50000

How to achieve this?

Check the below code . This should work for you . There could be other approaches also , this is using HashMap.

Data Class

class Data{
	String type;
	int amt;
	
	Data(String s , int a){
		this.type = s;
		this.amt = a;
	}
}

Implementation Class:

        Data data1 = new Data("A",30000);
		Data data2 = new Data("A",50000);
		Data data3 = new Data("B",40000);
		Data data4 = new Data("B",60000);
		Data data5 = new Data("C",50000);
		Data data6 = new Data("C",10000);
		
		ArrayList<Data> al = new ArrayList<>();
		al.add(data1);
		al.add(data2);
		al.add(data3);
		al.add(data4);
		al.add(data5);
		al.add(data6);
		
		
		
		HashMap<String,Integer> hm = new HashMap<>();
		for (int i = 0; i < al.size(); i++) {
			if(hm.containsKey(al.get(i).type)) {
				int tempAmt = hm.get(al.get(i).type);
				if(al.get(i).amt > tempAmt) {
					hm.put(al.get(i).type, al.get(i).amt);
				}
			}else {
				hm.put(al.get(i).type,al.get(i).amt);
			}
		}
		
		System.out.println(hm);

Assuming a class:

class DataClass {
  public String type;
  public Integer amt;
}

You can:

HashMap<String, Integer> values = new HashMap<>();
for (DataClass data : listDatas) {
  if (values.contains(data.type)) {
     int amt = data.get(type);
     if (data.amt > amt) {
       values.put(data.type, data.amt);
     }
  } else {
    values.put(data.type, data.amt);
  }
}

Then you can print the results.

Assuming your list contains objects of type Element, aggregate them using toMap collector into map where type is a key and value conflicts are resolved in favour of greatest value:

Map<String,Integer> m = list.stream().collect(Collectors.toMap(Element::getType, Element::getAmt, Math::max))

(code from top of my head, I didn't tested it)

Similar to the answer of Tomáš Záluský, using the stream API but this way you retain the Element objects, if you need them later:

import static java.util.Comparator.comparingInt;
import static java.util.function.BinaryOperator.maxBy;
import static java.util.stream.Collectors.toMap;

Map<String, Element> groupByMax = list.stream()
				.collect(toMap(Element::getType, e -> e, maxBy(comparingInt(Element::getAmt))));
Collection<Element> elementsWithMaxAmts = groupByMax.values();

There's no real need to use streams in this case. Give the following list of maps:

List<Map<String, String>> list =
		List.of(Map.of("Type", "A", "Amt", "30000"),
				Map.of("Type", "A", "Amt", "50000"),
				Map.of("Type", "B", "Amt", "40000"),
				Map.of("Type", "B", "Amt", "60000"),
				Map.of("Type", "C", "Amt", "50000"),
				Map.of("Type", "C", "Amt", "10000"));

You can use the merge method of map to combine the results.

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

for (Map<String, String> m : list) {
	results.merge(m.get("Type"), m.get("Amt"),
			(a, b) -> Integer.valueOf(a)
					.compareTo(Integer.valueOf(b)) == 1 ? a :
							b);
	
}
results.entrySet().forEach(System.out::println);

Prints the following with the type showing the maximum amount.

A=50000
B=60000
C=50000