字符串数组java中的组和总和销售

我有一个文本文件，如下所示：

pen100
墨水50
钢笔150
文件20

我想把每一种商品加起来 输出应该如下所示：

Pen 250
Ink 50
Paper 20
Max Pen 250
Min Paper 20

我只写了下面的一些代码，我卡住了：

public  static void readData(){
File infile = new File("D:\\itemData.txt");
        String itemName = new String();
        String[] nameList = new String[100];
        String[] saleList = new String[100];
        int sale;
        int count =0;
        try {
            Scanner data = new Scanner(infile);
            while (data.hasNext()) {
                itemName = data.next();
                sale = data.nextInt();
                nameList[count] = name;
                saleList[count] = String.valueOf(sale);
                count++;
                for (int i = 0; i < nameList.length; i++) {
                    if (nameList[i] != null) {
                        System.out.println(nameList[i] + " " + saleList[i]);
                    }
                }
                data.close();
            }
        } catch (IOException e) {
        }}

publicstaticvoidreaddata（）{
文件填充=新文件（“D:\\itemData.txt”）；
String itemName=新字符串（）；
字符串[]名称列表=新字符串[100]；
字符串[]saleList=新字符串[100]；
国际销售；
整数计数=0；
试一试{
扫描仪数据=新扫描仪（填充）；
while（data.hasNext（））{
itemName=data.next（）；
sale=data.nextInt（）；
名称列表[计数]=名称；
saleList[count]=String.valueOf（销售）；
计数++；
for（int i=0；i

尝试下面的代码。 代码中有两个问题我可以看到。 a） 您没有声明变量

count

b） 您在读取数据时正在打印，这是不可取的

public  static void readData(){
File infile = new File("D:\\itemData.txt");
        String itemName = new String();
        String[] nameList = new String[100];
        String[] saleList = new String[100];
        int sale;
        int count = 0;
        try {
            Scanner data = new Scanner(infile);
            while (data.hasNext()) {
                itemName = data.next();
                sale = data.nextInt();
                nameList[count] = name;
                saleList[count] = String.valueOf(sale);
                count++;

                data.close();
            }
        } catch (SIOException e) {
        }
        for (int i = 0; i < nameList.length; i++) {
                    if (nameList[i] != null) {
                        System.out.println(nameList[i] + " " + saleList[i]);
                    }
                }
}

publicstaticvoidreaddata（）{
文件填充=新文件（“D:\\itemData.txt”）；
String itemName=新字符串（）；
字符串[]名称列表=新字符串[100]；
字符串[]saleList=新字符串[100]；
国际销售；
整数计数=0；
试一试{
扫描仪数据=新扫描仪（填充）；
while（data.hasNext（））{
itemName=data.next（）；
sale=data.nextInt（）；
名称列表[计数]=名称；
saleList[count]=String.valueOf（销售）；
计数++；
data.close（）；
}
}捕获（SIOE）{
}
for（int i=0；i
也可以考虑实现这样的事情来跟踪你的MIX和MIX：
package com.example.demo;

import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;

import org.apache.commons.collections4.map.HashedMap;

public class Inventory {
    private Map<String, AtomicInteger> totals = new HashedMap<>();
    private Map<String, AtomicInteger> maxes = new HashedMap<>();
    private Map<String, AtomicInteger> mins = new HashedMap<>();

    public void add(String name, int number) {
        getOrCreateFromMap(totals, name, 0).addAndGet(number);

        getOrCreateFromMap(maxes, name, Integer.MIN_VALUE).getAndUpdate(present -> (present < number) ? number : present);

        getOrCreateFromMap(mins, name, Integer.MAX_VALUE).getAndUpdate(present -> (number < present) ? number : present);
    }

    private AtomicInteger getOrCreateFromMap(Map<String, AtomicInteger> map, String name, int initialValue) {
        return map.computeIfAbsent(name, x -> new AtomicInteger(initialValue));
    }

    public int getTotal(String name) {
        return getFromMap(totals, name);
    }

    public int getMax(String name) {
        return getFromMap(maxes, name);
    }

    public int getMin(String name) {
        return getFromMap(mins, name);
    }

    private int getFromMap(Map<String, AtomicInteger> map, String key) {
        return map.computeIfAbsent(key, x -> new AtomicInteger())
                  .get();
    }

    public static void main(String[] args) {
        Inventory i = new Inventory();

        i.add("paper", 50);
        i.add("paper", 150);

        System.out.println(i.getTotal("paper"));
        System.out.println(i.getMax("paper"));
        System.out.println(i.getMin("paper"));

    }
}

package com.example.demo；
导入java.util.Map；
导入java.util.concurrent.AtomicInteger；
导入org.apache.commons.collections4.map.HashedMap；
公共类目录{
私有映射总计=新的HashedMap（）；
private Map maxes=new HashedMap（）；
private Map mins=new HashedMap（）；
public void add（字符串名、整数）{
getOrCreateFromMap（总计，名称，0）.addAndGet（编号）；
getOrCreateFromMap（最大、名称、整数、最小值）。getAndUpdate（当前->（当前<编号）？编号：当前）；
getOrCreateFromMap（分钟、名称、整数、最大值）。getAndUpdate（当前->（数字<当前）？数字：当前）；
}
私有AtomicInteger getOrCreateFromMap（映射映射、字符串名称、int initialValue）{
返回map.computeIfAbsent（名称，x->new AtomicInteger（初始值））；
}
public int getTotal（字符串名称）{
返回getFromMap（总计、名称）；
}
public int getMax（字符串名称）{
返回getFromMap（最大值，名称）；
}
public int getMin（字符串名称）{
返回getFromMap（分钟，名称）；
}
私有int getFromMap（映射映射，字符串键）{
返回map.computeIfAbsent（键，x->new AtomicInteger（））
.get（）；
}
公共静态void main（字符串[]args）{
存货i=新存货（）；
i、 添加（“文件”，50）；
i、 添加（“文件”，150）；
System.out.println（即getTotal（“纸张”）；
System.out.println（i.getMax（“纸张”）；
System.out.println（i.getMin（“纸张”）；
}
}
下面是一个工作示例，用于上述问题陈述-

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Map;
import java.util.stream.Collectors;

public class ReadAndSumFileData {

    public static void main(String... arguments) throws IOException {
        String filename = "C:/temp/SalesData.txt";
        readData(filename);
    }

    private static void readData(String filename) throws IOException {
        Map<String, Integer> map = Files.lines(Paths.get(filename))
                .map(s -> s.split("\\s+"))
                .collect(Collectors.groupingBy(a -> a[0], Collectors.summingInt(a -> Integer.parseInt(a[1]))));

        map.entrySet().stream().forEach(e-> System.out.println(e));
    }
}

import java.io.IOException；
导入java.nio.file.Files；
导入java.nio.file.path；
导入java.util.Map；
导入java.util.stream.collector；
公共类ReadAndSumFileData{
公共静态void main（字符串…参数）引发IOException{
字符串filename=“C:/temp/SalesData.txt”；
读取数据（文件名）；
}
私有静态void readData（字符串文件名）引发IOException{
Map Map=Files.line（path.get（文件名））
.map（s->s.split（\\s+））
.collect（Collectors.groupby（a->a[0]，Collectors.summingit（a->Integer.parseInt（a[1]））；
map.entrySet（）.stream（）.forEach（e->System.out.println（e））；
}
}
您所说的卡住是什么意思？什么不起作用？请环顾四周，通读这本书。特别是要经常引用准确的错误，而不是仅仅说你有错误。