Java 如何计算字符串出现的次数

因此，我为我的代码创建了一条错误消息。目前，我的代码每次出现时都会弹出错误消息。我的代码验证并确保excel文件格式正确。验证后，如果出现错误/警告消息，它将返回这些消息。因此，当我收到错误消息时，每一条消息都会在每次发生时出现。例如，验证excel文件时，错误消息“error，id不得包含特殊字符”出现6次。有什么方法可以简单地写下来检查消息是否已经发生，并保留一个计数器来显示多少次

我考虑过类似于

if（message=message）{//then create counter}

的东西，但这不起作用，因为message总是等于message。有人有办法吗

编辑：下面是验证代码的小片段。我希望将消息分组在一起，而不是在发布到API时让它们重复

        // if there are errors, then
        if (!errorResponse.getItems().isEmpty()) {

            // set error response
            Iterator<ErrorMessage> iter = errorResponse.getItems().iterator();

            Set<ErrorMessage> summarizedErrorMessages = new HashSet<>();

            while (iter.hasNext()) {
                ErrorMessage sem = new ErrorMessage();
                ErrorMessage em = iter.next();
                if (!summarizedErrorMessages.contains(em)) {
                    sem.setMessage(em.getMessage());
                    sem.setTotal(1);
                } else {
                    sem.setTotal(sem.getTotal() + 1);
                }
                summarizedErrorMessages.add(sem);
            }
            errorResponse.setItems(summarizedErrorMessages);
            warningResponse.setItems(new ArrayList<WarningMessage>());

//如果有错误，则
如果（！errorResponse.getItems（）.isEmpty（））{
//设置错误响应
迭代器iter=errorResponse.getItems（）.Iterator（）；
Set summarederrormessages=new HashSet（）；
while（iter.hasNext（））{
ErrorMessage sem=新的ErrorMessage（）；
ErrorMessage em=iter.next（）；
如果（！SummaredErrorMessages.contains（em））{
sem.setMessage（em.getMessage（））；
sem.setTotal（1）；
}否则{
sem.setTotal（sem.getTotal（）+1）；
}
汇总错误消息。添加（sem）；
}
errorResponse.setItems（摘要错误消息）；
setItems（新的ArrayList（））；

使用

HashMap

，其中键是错误消息，值是错误发生的次数

当收到错误消息时，检查

如果map.containsKey（message）

，然后获取计数器（

long counter=map.get（message）

），将其递增并放回映射中（

map.put（message，counter+1L）

）

如果映射不包含消息，请将其添加到映射并将计数器初始化为1（

map.put（message，1L）

）

大概是这样的：

private Map<String, Long> errors = new HashMap<String, Long>();

public void handleError(String error) {
    if(errors.containsKey(error)) {
        Long counter = errors.get(error);
        errors.put(error, counter + 1L);
    } else {
        errors.put(error, 1L);
    }
}

HashMap

将使用

String

的哈希代码作为键，因此相同的

String

将映射到映射中的相同位置

因此，当您第一次看到消息字符串时（当它不在映射中时），您可以将其按计数为1的方式推入映射中，然后在其后递增：

HashMap<String,Integer> messageCounts = new HashMap<>();
messages.forEach( message -> {
    messageCounts.putIfAbsent( message, 0 );
    messageCounts.computeIfPresent( message, (k,v) -> v+1 );
});

HashMap messageCounts=new HashMap（）；
messages.forEach（message->{
messageCounts.putIfAbsent（消息，0）；
messageCounts.computeIfPresent（消息，（k，v）->v+1）；
});

因此，对于您的具体情况，可能是这样的：

// First map messages to counts
HashMap<String,Integer> messageCounts = new HashMap<>();
errorResponse.getItems().forEach( errorMessage -> {
    messageCounts.putIfAbsent( errorMessage.getMessage(), 0 );
    messageCounts.computeIfPresent( errorMessage.getMessage(), (k,v) -> v+1 );
});

// Then create the summary objects
List<ErrorMessages> summaries = 
    messageCounts.entrySet().stream().map( e -> {
        ErrorMessage summary = new ErrorMessage();
        summary.setMessage( e.getKey() );
        summary.setTotal( e.getValue() );
        return summary;
    } ).collect( Collectors.toList() );

errorResponse.setItems( summaries );

//第一次将消息映射到计数
HashMap messageCounts=新建HashMap（）；
errorResponse.getItems（）.forEach（errorMessage->{
messageCounts.putIfAbsent（errorMessage.getMessage（），0）；
messageCounts.computeIfPresent（errorMessage.getMessage（），（k，v）->v+1）；
});
//然后创建摘要对象
列表摘要=
messageCounts.entrySet（）.stream（）.map（e->{
ErrorMessage summary=新的ErrorMessage（）；
setMessage（例如getKey（））；
setTotal（例如getValue（））；
返回摘要；
}）.collect（Collectors.toList（））；
错误响应。设置项（摘要）；

在这里创建一个单独的答案，这样我就可以发布这个问题的完整代码。下面是没有错误的代码：

            // if there are errors, then
        if (!errorResponse.getItems().isEmpty()) {

            // set error response
            Iterator<ErrorMessage> iter = errorResponse.getItems().iterator();

            HashMap<String, Integer> messageCounts = new HashMap<String, Integer>();
            errorResponse.getItems().forEach(ErrorMessage -> {
                messageCounts.putIfAbsent(ErrorMessage.getMessage(), 1);
                messageCounts.computeIfPresent(ErrorMessage.getMessage(), (k, v) -> v + 1);
            });

            Set<ErrorMessage> summaries = new HashSet<>();
            for (String s : messageCounts.keySet()) {
                ErrorMessage summary = new ErrorMessage();
                summary.setMessage(s);
                summary.setTotal(messageCounts.get(s));
                summaries.add(summary);
            }

            errorResponse.setItems(summaries);
            warningResponse.setItems(new ArrayList<WarningMessage>());

//如果有错误，则
如果（！errorResponse.getItems（）.isEmpty（））{
//设置错误响应
迭代器iter=errorResponse.getItems（）.Iterator（）；
HashMap messageCounts=新建HashMap（）；
errorResponse.getItems（）.forEach（ErrorMessage->{
messageCounts.putIfAbsent（ErrorMessage.getMessage（），1）；
messageCounts.computeIfPresent（ErrorMessage.getMessage（），（k，v）->v+1）；
});
Set summaries=新HashSet（）；
对于（字符串s:messageCounts.keySet（））{
ErrorMessage summary=新的ErrorMessage（）；
摘要：设置消息；
setTotal（messageCounts.get）；
摘要。添加（摘要）；
}
错误响应。设置项（摘要）；
setItems（新的ArrayList（））；

是否只比较两个字符串？如果是，请使用

。equals

在这里：请共享您的代码。使用

Hashmap map

，此映射消息和计数，您可以将所有可能的消息的计数设为零，然后更新（增量）错误情况发生时的计数。您的意思是

HashMap

？此方法的问题是，由于变量太多，我可以生成很多不同的消息。我正在寻找一种方法，不必在所有可能的选项中硬编码happen@ArnaudDenoyelle哦，是的，Kotlin:D太多了，我会编辑这篇文章。@nico43624我添加了一个与你发布的代码相匹配的示例。这会更清楚吗？你的代码重复的原因是你每次都在循环中创建一条新的

ErrorMessage

。将其与

add（）一起放入
if（…contains（））
块中

而且它可能会起作用。@davedupplaw您新更新的代码非常有用，但是

.map（）

抛出错误的原因我不知道。我目前正在尝试您的其他建议，并将看看是否有效。我的消息是一个名为errorResponse的自定义变量。这些错误消息必须作为一个集合进入系统，因此我无法将其作为一个映射，因为从映射到集合的转换在这里不起作用。

// First map messages to counts
HashMap<String,Integer> messageCounts = new HashMap<>();
errorResponse.getItems().forEach( errorMessage -> {
    messageCounts.putIfAbsent( errorMessage.getMessage(), 0 );
    messageCounts.computeIfPresent( errorMessage.getMessage(), (k,v) -> v+1 );
});

// Then create the summary objects
List<ErrorMessages> summaries = 
    messageCounts.entrySet().stream().map( e -> {
        ErrorMessage summary = new ErrorMessage();
        summary.setMessage( e.getKey() );
        summary.setTotal( e.getValue() );
        return summary;
    } ).collect( Collectors.toList() );

errorResponse.setItems( summaries );

            // if there are errors, then
        if (!errorResponse.getItems().isEmpty()) {

            // set error response
            Iterator<ErrorMessage> iter = errorResponse.getItems().iterator();

            HashMap<String, Integer> messageCounts = new HashMap<String, Integer>();
            errorResponse.getItems().forEach(ErrorMessage -> {
                messageCounts.putIfAbsent(ErrorMessage.getMessage(), 1);
                messageCounts.computeIfPresent(ErrorMessage.getMessage(), (k, v) -> v + 1);
            });

            Set<ErrorMessage> summaries = new HashSet<>();
            for (String s : messageCounts.keySet()) {
                ErrorMessage summary = new ErrorMessage();
                summary.setMessage(s);
                summary.setTotal(messageCounts.get(s));
                summaries.add(summary);
            }

            errorResponse.setItems(summaries);
            warningResponse.setItems(new ArrayList<WarningMessage>());