Java sum of repetitive items inside for loop

I have two arrays :

String[] matnr = new String[] { "16400", "56000", "56000", "50000", "16400" };
String[] lfimg = new String[] { "4.000", "5.000", "6.000", "9.000", "10.560" };

I want to find sum of lfimg items having same matnr value i.e. for matnr 16400 sum output will be 14.560, for 56000 output will be 11.000 and matnr 50000 sum output will be 9.000

below block is written by me :

	public static void main(String[] args) {
String[] matnr = new String[] { "16400", "56000", "56000", "50000", "16400" };
String[] lfimg = new String[] { "4.000", "5.000", "6.000", "9.000", "10.56" };
int n = matnr.length;
int i, j, x;
int count = 0;
int count1 = 0;
double value = 0.0;
// calculate unique material count
for (i = 0; i < n; ++i)
System.out.println(i + 1 + "compartment material : " + matnr[i]);
for (i = 0; i < n; i++) {
for (j = 0; j < i; j++)
if (matnr[i] == matnr[j])
break;
if (i == j) {
count = count + 1;
}
}
System.out.println("final count >>" + count);
String materialArray[] = new String[count];
for (i = 0; i < n; i++) {
for (j = 0; j < i; j++)
if (matnr[i] == matnr[j])
break;
if (i == j) {
materialArray[count1] = matnr[i];
System.out.println("Material array xxxx >>" + materialArray[count1]);
System.out.println("count1 before >>" + count1);
count1 = count1 + 1;
System.out.println("count1 after >>" + count1);
}
}
System.out.println("matnr.length >>" + matnr.length);
System.out.println("materialArray.length >>" + materialArray.length);
for (i = 0; i < matnr.length; i++) {
System.out.println("111Value   >>> " + matnr[i]);
}
for (j = 0; j < materialArray.length; j++) {
System.out.println("222Value >>> " + materialArray[j]);
}
System.out.println("---- ******* ------------ *********** -------- ********** ------");
for (i = 0; i < materialArray.length; i++) {
for (j = 0; j < matnr.length; j++) {
if (materialArray[i].contains(matnr[j])) {
value = value + Double.parseDouble(lfimg[j]);
System.out.println("Value1   >>>  " + value);
}
}
}
}

But I'm not getting desired output. It is coming as :

Value1   >>>  4.0
Value1   >>>  14.56
Value1   >>>  19.560000000000002
Value1   >>>  25.560000000000002
Value1   >>>  34.56

Where as I want output as :

Value1   >>>  14.560
Value1   >>>  11.000
Value1   >>>  9.000

Can anybody please assist in this regard.

1. You do not reset the value variable in your final forloop, hence why you're getting ever increasing numbers in your print, ending in 34.56. You want one value for each materialArray entry, so immediately after for (i = 0; i < materialArray.length; i++) {, you'd want value = 0.
2. You're using materialArray[i].contains(matnr[j]) - that's asking if matnr[j] is a substring of materialArray[i]. It seems rather clear you wanted equals instead. Minor nit and doesn't break here, but a bug nonetheless.
3. Your printer tool will print every time an individual entry matches, and prints nothing after you're gone through the whole list, resulting in this weird output. Your intent, presumably, is to let the inner loop (for (int j = 0; j < matnr.length; j++)) complete, and THEN you want to print. Thus, your sysout statement needs to be shifted two lines down, after the closing bracket of the inner for loop. Combine that with resetting your value and...

Value1   >>>  14.56
Value1   >>>  11.0
Value1   >>>  9.0

NB: A second issue is rounding errors. You basically should never toString() or otherwise directly print a float or double value. If you do, you get wonky weirdness like 19.560000000000002.

If I ask you, using decimal notation, to write down the result of 'one third', you must round. You can't write an infinite processing of .3333333, right? Computers (specifically, doubles and floats) are no different, but computers count in binary, not decimal. So, the computer has to round a bit, and then 'render' the value it has in decimal, and this is where the weirdness comes from. The inaccuracies introduced by this rounding cannot be avoided (at least, not with doubles and floats), but usually the inaccuracies do not creep into the relevant significance of your numbers. The solution is therefore to ALWAYS guide the libraries when printing your numbers, by telling it how many digits you are expecting. So, make it:

System.out.printf("Value1   >>>   %.4f\n", value);

The %.4f tells the printer to print with no more than 4 digits after the dot, and printf does not automatically newline, so the \n tells it to print that newline explicitly.

Finally, there's the matter of this code style. This can be done far simpler (and more efficiently) using java's built in tools, such as HashMap:

	public static void main(String[] args) {
String[] matnr = new String[] { "16400", "56000", "56000", "50000", "16400" };
String[] lfimg = new String[] { "4.000", "5.000", "6.000", "9.000", "10.56" };
var values = new HashMap<String, Double>();
// load values into the map.
for (int i = 0; i < matnr.length; i++) {
double z = Double.parseDouble(lfimg[i]);
values.compute(matnr[i], (m, v) -> v == null ? z : v + z); // [1]
}
// print them to show it works
for (var e : values.entrySet()) {
System.out.printf("%s: %.4f\n", e.getKey(), e.getValue());
}
}

The key line is the line marked [1]: It says: To compute the value for the value at the current matnr entry, if there is no existing value yet (v would be null), it's just the corresponding entry from lfimg, and if there is an existing value, it is the sum of what we had, plus the corresponding entry from lfimg.