将字符串存储到带有出现的哈希图中

Question

我有一个返回某种字符串的方法。我想将单个单词及其出现次数存储在 HashMap 中？

public static void main(String[] args) {
        String s = "{link:hagdjh, matrics:[{name:apple, value:1},{name:jeeva, value:2},{name:abc, value:0}]}";

        String[] strs = s.split("matrics");
        System.out.println("Substrings length:" + strs.length);
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }

    }

例如，我有一个字符串- "{link:https://www.google.co.in/, matrics:[{name:apple, value:1},{name:graph, value:2},{name:abc, value:0 }]}";

Now my hashmap should look like

apple = 1
graph = 2
abc = 0

我应该如何进行？

我知道如何使用 HashMap。在这种情况下，我的问题是我不知道如何解析给定的字符串并存储单词及其出现次数。

Answer 1

String regex = "\\{name:(.*), value:(\\d+)\\}";
            HashMap<String, Integer> link = new HashMap<>();

            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(s);

            while (matcher.find()){
                String found = matcher.group(1);
                String number = matcher.group(2);
                link.put(found, Integer.parseInt(number));
            }

Answer 2

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new LinkedHashMap<String, Integer>();
        Pattern pattern = Pattern.compile("matrics:\\[\\{(.*?)\\]\\}");
        Matcher matcher = pattern
                .matcher("{link:hagdjh, matrics:[{name:apple, value:1},{name:jeeva, value:2},{name:abc, value:0}]}");
        String data = "";
        if (matcher.find()) {
            data = matcher.group();
        }
        List<String> records = new ArrayList<String>();
        pattern = Pattern.compile("(?<=\\{).+?(?=\\})");
        matcher = pattern.matcher(data);
        while (matcher.find()) {
            records.add(matcher.group());
        }
        for (String s : records) {
            String[] parts = s.split(", ");
            map.put(parts[0].substring(parts[0].indexOf(":") + 1),
                    Integer.parseInt(parts[1].substring(parts[1].indexOf(":") + 1)));
        }
        map.entrySet().forEach(entry -> {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        });
    }
}

输出：

apple = 1
jeeva = 2
abc = 0

Answer 3

您的数据似乎是 JSON 格式。

如果保证是 JSON 格式，你可以使用 JSON 解析库来解析它，然后以方便的方式分析矩阵数据（代码如下）。

如果数据不能保证是 JSON 格式，你可以使用 REGEX 来帮助你解析它，就像 Reza soumi 的回答一样。

import org.json.JSONObject;
import org.json.JSONArray;
import java.util.HashMap;

String s = "{link:hagdjh, matrics:[{name:apple, value:1},{name:jeeva, value:2},{name:abc, value:0}]}";

JSONObject obj = new JSONObject(s);
JSONArray matrics = obj.getJSONArray("matrics");
System.out.println(matrics);

HashMap<String, Integer> matricsHashMap = new HashMap<String, Integer>();
for (int i=0;i < matrics.length();i++){
    JSONObject matric = matrics.getJSONObject(i);
    System.out.println("Adding matric: " + matric + " to hash map");
    String matricName = matric.getString("name");
    Integer matricValue = Integer.valueOf(matric.getInt("value"));
    matricsHashMap.put(matricName, matricValue);
}

System.out.println(matricsHashMap);

Answer 4

试试这个：

import static java.lang.System.err;
import static java.lang.System.out;
import static java.util.Arrays.stream;
import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.toMap;

/**
 *  Counting the words in a String.
 */
public class CountWordsInString
{
        /*-----------*\
    ====** Constants **========================================================
        \*-----------*/
    /**
     *  An empty array of {@code ${type_name}} objects.
     */
    public static final String INPUT = "{link:https://www.google.co.in/, matrics:[{name:apple, value:1},{name:graph, value:2},{name:abc, value:0}]}";

        /*---------*\
    ====** Methods **==========================================================
        \*---------*/
    /**
     *  The program entry point.
     *
     *  @param  args    The command line arguments.
     */
    public static void main( final String... args )
    {
        try
        {
            final var result = stream( INPUT.split( "\\W+" ) )
                .filter( s -> !s.isBlank() )
                .filter( s -> !s.matches( "\\d*" ) )
                .collect( groupingBy( s -> s ) )
                .entrySet()
                .stream()
                .collect( toMap( k -> k.getKey(), v -> Long.valueOf( v.getValue().size() ) ) );
            out.println( result.getClass() );
            for( final var entry : result.entrySet() )
            {
                out.printf( "'%s' occurred %d times%n", entry.getKey(), entry.getValue() );
            }
        }
        catch( final Throwable t )
        {
            //---* Handle any previously unhandled exceptions *----------------
            t.printStackTrace( err );
        }
    }   //  main()
}
//  class CountWordsInString

承认，不是最明显的解决方案，但我也想从中获得一些乐趣。

INPUT.split( "\\W+" ) 为您提供字符串中的单词，还包括数字和开头的“空”单词。

第一个 filter() 语句消除了“空”字，第二个语句删除了数字。

第一个collect( groupingBy() ) 为您提供HashMap<String,List<String>>，因此我必须在以下步骤中将其转换为HashMap<String,Long>（基本上使用第二个collect( groupingBy() )）。

可能有更高效的解决方案，或者更优雅的解决方案，甚至是两者兼具的解决方案，更高效和更优雅......但它按预期工作，我从中获得了一些乐趣。

输出是：

class java.util.HashMap
'apple' occurred 1 times
'matrics' occurred 1 times
'abc' occurred 1 times
'in' occurred 1 times
'www' occurred 1 times
'name' occurred 3 times
'link' occurred 1 times
'google' occurred 1 times
'https' occurred 1 times
'co' occurred 1 times
'value' occurred 3 times
'graph' occurred 1 times