存在重复密钥时Java guava拆分器失败

如何在使用java guava Splitter函数时处理重复键。下面是遇到以下问题的示例代码。有没有更好的办法来处理这个问题

String fieldSplit = " ";
String valueSplit = "=";
String message = "ip=1.2.9.0 error=NA ip=1.2.9.0";
Map<String, String> parserMap = Splitter.on(fieldSplit).omitEmptyStrings().withKeyValueSeparator(valueSplit).split(message);

String fieldSplit=“”；
字符串valueSplit=“=”；
字符串消息=“ip=1.2.9.0错误=NA ip=1.2.9.0”；
Map parserMap=Splitter.on（fieldSplit）.ommitEmptyStrings（）.withKeyValueSeparator（valueSplit）.split（message）；

线程“kv-plugin-ac801a38-66f1-4ffe-86ca-f9eb6c823842-StreamThread-1”org.apache.kafka.streams.errors.StreamsException:进程中捕获异常。taskId=0_0，processor=KSTREAM-SOURCE-0000000000，topic=kv输入，partition=0，offset=22，stacktrace=java.lang.IllegalArgumentException:找到重复的密钥[ip]

---

我得到上面的错误。有人能提出一个更好的方法来处理这个问题吗。因为我是java新手。

取决于您希望如何处理重复的密钥。

Map

是一种键值存储，只能有唯一的键和一个值

public class SO66139006 {

    private static final Splitter PAIRS_SPLITTER = Splitter.on(' '); // .trimResults().omitEmptyStrings() if necessary
    private static final Splitter KEY_VALUE_SPLITTER = Splitter.on('=').limit(2);

    @Test
    public void shouldOverwriteValuesOnDuplicateKey() {
        //given
        String message = "ip=42.42.42.0 error=NA ip=1.2.9.0";
        //when
        Map<String, String> result = parseOverwritingValues(PAIRS_SPLITTER, KEY_VALUE_SPLITTER, message);
        //then
        assertThat(result) // {ip=1.2.9.0, error=NA}
                .containsExactly(entry("ip", "1.2.9.0"), entry("error", "NA"));
    }

    private Map<String, String> parseOverwritingValues(Splitter pairsSplitter, Splitter keyValueSplitter, String message) {
        return Streams.stream(pairsSplitter.split(message))
                .map(keyValueSplitter::splitToList)
                .collect(toImmutableMap(
                        list -> list.get(0),
                        list -> list.get(1),
                        (oldValue, newValue) -> newValue
                ));
    }

    @Test
    public void shouldDiscardValuesOnDuplicateKey() {
        //given
        String message = "ip=42.42.42.0 error=NA ip=1.2.9.0";
        //when
        Map<String, String> result = parseDiscardingValues(PAIRS_SPLITTER, KEY_VALUE_SPLITTER, message);
        //then
        assertThat(result) // {ip=42.42.42.0, error=NA}
                .containsExactly(entry("ip", "42.42.42.0"), entry("error", "NA"));
    }

    private Map<String, String> parseDiscardingValues(Splitter pairsSplitter, Splitter keyValueSplitter, String message) {
        return Streams.stream(pairsSplitter.split(message))
                .map(keyValueSplitter::splitToList)
                .collect(toImmutableMap(
                        list -> list.get(0),
                        list -> list.get(1),
                        (oldValue, newValue) -> oldValue
                ));
    }

    @Test
    public void shouldAppendValuesOnDuplicateKey() {
        //given
        String message = "ip=42.42.42.0 error=NA ip=1.2.9.0";
        //when
        ListMultimap<String, String> result = parseMultipleValues(PAIRS_SPLITTER, KEY_VALUE_SPLITTER, message);
        //then
        assertThat(result.asMap()) // {ip=[42.42.42.0, 1.2.9.0], error=[NA]}
                .containsExactly(entry("ip", ImmutableList.of("42.42.42.0", "1.2.9.0")), entry("error", ImmutableList.of("NA")));
    }

    private ListMultimap<String, String> parseMultipleValues(Splitter pairsSplitter, Splitter keyValueSplitter, String message) {
        return Streams.stream(pairsSplitter.split(message))
                .map(keyValueSplitter::splitToList)
                .collect(toImmutableListMultimap(
                        list -> list.get(0),
                        list -> list.get(1)
                ));
    }

    @Test
    public void shouldThrowByDefault() {
        //given
        String fieldSplit = " ";
        String valueSplit = "=";
        String message = "ip=1.2.9.0 error=NA ip=1.2.9.0";
        //when
        final Throwable throwable = catchThrowable(() -> Splitter.on(fieldSplit).omitEmptyStrings().withKeyValueSeparator(valueSplit).split(message));
        //then
        assertThat(throwable)
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessage("Duplicate key [ip] found.");
    }
}

---

如果您想存储所有这些值，您需要类似于

Map的东西，这取决于您想对重复键执行什么操作。
Map
是一种键值存储，只能有唯一的键和一个值

public class SO66139006 {

    private static final Splitter PAIRS_SPLITTER = Splitter.on(' '); // .trimResults().omitEmptyStrings() if necessary
    private static final Splitter KEY_VALUE_SPLITTER = Splitter.on('=').limit(2);

    @Test
    public void shouldOverwriteValuesOnDuplicateKey() {
        //given
        String message = "ip=42.42.42.0 error=NA ip=1.2.9.0";
        //when
        Map<String, String> result = parseOverwritingValues(PAIRS_SPLITTER, KEY_VALUE_SPLITTER, message);
        //then
        assertThat(result) // {ip=1.2.9.0, error=NA}
                .containsExactly(entry("ip", "1.2.9.0"), entry("error", "NA"));
    }

    private Map<String, String> parseOverwritingValues(Splitter pairsSplitter, Splitter keyValueSplitter, String message) {
        return Streams.stream(pairsSplitter.split(message))
                .map(keyValueSplitter::splitToList)
                .collect(toImmutableMap(
                        list -> list.get(0),
                        list -> list.get(1),
                        (oldValue, newValue) -> newValue
                ));
    }

    @Test
    public void shouldDiscardValuesOnDuplicateKey() {
        //given
        String message = "ip=42.42.42.0 error=NA ip=1.2.9.0";
        //when
        Map<String, String> result = parseDiscardingValues(PAIRS_SPLITTER, KEY_VALUE_SPLITTER, message);
        //then
        assertThat(result) // {ip=42.42.42.0, error=NA}
                .containsExactly(entry("ip", "42.42.42.0"), entry("error", "NA"));
    }

    private Map<String, String> parseDiscardingValues(Splitter pairsSplitter, Splitter keyValueSplitter, String message) {
        return Streams.stream(pairsSplitter.split(message))
                .map(keyValueSplitter::splitToList)
                .collect(toImmutableMap(
                        list -> list.get(0),
                        list -> list.get(1),
                        (oldValue, newValue) -> oldValue
                ));
    }

    @Test
    public void shouldAppendValuesOnDuplicateKey() {
        //given
        String message = "ip=42.42.42.0 error=NA ip=1.2.9.0";
        //when
        ListMultimap<String, String> result = parseMultipleValues(PAIRS_SPLITTER, KEY_VALUE_SPLITTER, message);
        //then
        assertThat(result.asMap()) // {ip=[42.42.42.0, 1.2.9.0], error=[NA]}
                .containsExactly(entry("ip", ImmutableList.of("42.42.42.0", "1.2.9.0")), entry("error", ImmutableList.of("NA")));
    }

    private ListMultimap<String, String> parseMultipleValues(Splitter pairsSplitter, Splitter keyValueSplitter, String message) {
        return Streams.stream(pairsSplitter.split(message))
                .map(keyValueSplitter::splitToList)
                .collect(toImmutableListMultimap(
                        list -> list.get(0),
                        list -> list.get(1)
                ));
    }

    @Test
    public void shouldThrowByDefault() {
        //given
        String fieldSplit = " ";
        String valueSplit = "=";
        String message = "ip=1.2.9.0 error=NA ip=1.2.9.0";
        //when
        final Throwable throwable = catchThrowable(() -> Splitter.on(fieldSplit).omitEmptyStrings().withKeyValueSeparator(valueSplit).split(message));
        //then
        assertThat(throwable)
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessage("Duplicate key [ip] found.");
    }
}

如果您想存储所有这些值，您需要类似于
Map的东西来抛出一个重复的键，因此根据需要，您必须编写自己的“键值”拆分器，该拆分器由两个拆分器组成。请看下面的示例，您可以收集结果以使用所需的行为（覆盖或放弃）进行映射，甚至可以尝试收集，但这样会使结果的值存储在列表中，即使只有一个值

public class SO66139006 {

    private static final Splitter PAIRS_SPLITTER = Splitter.on(' '); // .trimResults().omitEmptyStrings() if necessary
    private static final Splitter KEY_VALUE_SPLITTER = Splitter.on('=').limit(2);

    @Test
    public void shouldOverwriteValuesOnDuplicateKey() {
        //given
        String message = "ip=42.42.42.0 error=NA ip=1.2.9.0";
        //when
        Map<String, String> result = parseOverwritingValues(PAIRS_SPLITTER, KEY_VALUE_SPLITTER, message);
        //then
        assertThat(result) // {ip=1.2.9.0, error=NA}
                .containsExactly(entry("ip", "1.2.9.0"), entry("error", "NA"));
    }

    private Map<String, String> parseOverwritingValues(Splitter pairsSplitter, Splitter keyValueSplitter, String message) {
        return Streams.stream(pairsSplitter.split(message))
                .map(keyValueSplitter::splitToList)
                .collect(toImmutableMap(
                        list -> list.get(0),
                        list -> list.get(1),
                        (oldValue, newValue) -> newValue
                ));
    }

    @Test
    public void shouldDiscardValuesOnDuplicateKey() {
        //given
        String message = "ip=42.42.42.0 error=NA ip=1.2.9.0";
        //when
        Map<String, String> result = parseDiscardingValues(PAIRS_SPLITTER, KEY_VALUE_SPLITTER, message);
        //then
        assertThat(result) // {ip=42.42.42.0, error=NA}
                .containsExactly(entry("ip", "42.42.42.0"), entry("error", "NA"));
    }

    private Map<String, String> parseDiscardingValues(Splitter pairsSplitter, Splitter keyValueSplitter, String message) {
        return Streams.stream(pairsSplitter.split(message))
                .map(keyValueSplitter::splitToList)
                .collect(toImmutableMap(
                        list -> list.get(0),
                        list -> list.get(1),
                        (oldValue, newValue) -> oldValue
                ));
    }

    @Test
    public void shouldAppendValuesOnDuplicateKey() {
        //given
        String message = "ip=42.42.42.0 error=NA ip=1.2.9.0";
        //when
        ListMultimap<String, String> result = parseMultipleValues(PAIRS_SPLITTER, KEY_VALUE_SPLITTER, message);
        //then
        assertThat(result.asMap()) // {ip=[42.42.42.0, 1.2.9.0], error=[NA]}
                .containsExactly(entry("ip", ImmutableList.of("42.42.42.0", "1.2.9.0")), entry("error", ImmutableList.of("NA")));
    }

    private ListMultimap<String, String> parseMultipleValues(Splitter pairsSplitter, Splitter keyValueSplitter, String message) {
        return Streams.stream(pairsSplitter.split(message))
                .map(keyValueSplitter::splitToList)
                .collect(toImmutableListMultimap(
                        list -> list.get(0),
                        list -> list.get(1)
                ));
    }

    @Test
    public void shouldThrowByDefault() {
        //given
        String fieldSplit = " ";
        String valueSplit = "=";
        String message = "ip=1.2.9.0 error=NA ip=1.2.9.0";
        //when
        final Throwable throwable = catchThrowable(() -> Splitter.on(fieldSplit).omitEmptyStrings().withKeyValueSeparator(valueSplit).split(message));
        //then
        assertThat(throwable)
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessage("Duplicate key [ip] found.");
    }
}

公共类SO66139006{
私有静态最终拆分器对_Splitter=Splitter.on（“”）；//.trimResults（）。必要时省略EmptyStrings（）
私有静态最终拆分器键\u值\u Splitter=Splitter.on（'='）.limit（2）；
@试验
public void应覆盖EvaluesOnDuplicateKey（）{
//给定
字符串消息=“ip=42.42.42.0错误=NA ip=1.2.9.0”；
//什么时候
映射结果=解析覆盖值（成对拆分器、键值拆分器、消息）；
//然后
断言（结果）/{ip=1.2.9.0，错误=NA}
.containsExactly（条目（“ip”、“1.2.9.0”）、条目（“错误”、“NA”）；
}
私有映射解析覆盖值（拆分器对拆分器、拆分器键值拆分器、字符串消息）{
返回Streams.stream（pairsplitter.split（消息））
.map（keyValueSplitter:：splitToList）
.收集（toImmutableMap）(
列表->列表。获取（0），
list->list.get（1），
（旧值，新值）->新值
));
}
@试验
public void应丢弃DuplicateKey（）中的ValuesOnDuplicateKey（）{
//给定
字符串消息=“ip=42.42.42.0错误=NA ip=1.2.9.0”；
//什么时候
映射结果=parseDiscardingValues（成对拆分器、键值拆分器、消息）；
//然后
断言（结果）/{ip=42.42.42.0，错误=NA}
.containsExactly（条目（“ip”、“42.42.42.0”）、条目（“错误”、“NA”）；
}
私有映射parseDiscardingValues（拆分器对拆分器、拆分器键值拆分器、字符串消息）{
返回Streams.stream（pairsplitter.split（消息））
.map（keyValueSplitter:：splitToList）
.收集（toImmutableMap）(
列表->列表。获取（0），
list->list.get（1），
（oldValue，newValue）->oldValue
));
}
@试验
public void应在DuplicateKey（）中添加ValuesOnDuplicateKey（）{
//给定
字符串消息=“ip=42.42.42.0错误=NA ip=1.2.9.0”；
//什么时候
ListMultimap result=parseMultipleValues（PAIRS\u SPLITTER、KEY\u VALUE\u SPLITTER、message）；
//然后
assertThat（result.asMap（））/{ip=[42.42.42.0,1.2.9.0]，error=[NA]}
.containsExactly（条目（“ip”）、不可修改的列表（“42.42.42.0”、“1.2.9.0”）、条目（“错误”、不可修改的列表（“NA”））；
}
private ListMultimap ParseMultipleValue（拆分器对拆分器、拆分器keyValueSplitter、字符串消息）{
返回Streams.stream（pairsplitter.split（消息））
.map（keyValueSplitter:：splitToList）
.collect（toImmutableListMultimap(
列表->列表。获取（0），
列表->列表.获取（1）
));
}
@试验
public void shouldThrowByDefault（）{
//给定
字符串fieldSplit=“”；
字符串valueSplit=“=”；
字符串消息=“ip=1.2.9.0错误=NA ip=1.2.9.0”；
//什么时候
final-Throwable-Throwable=catchThrowable（（）->Splitter.on（fieldSplit）.ommitEmptyStrings（）.withKeyValueSeparator（valueSplit）.split（message））；
//然后
资产（可丢弃）
.isInstanceOf（IllegalArgumentException.class）
.hasMessage（“找到重复的密钥[ip]”）；
}
}
抛出重复键是一种错误，因此根据需要，您必须编写自己的“键值”拆分器，该拆分器由两个拆分器组成。请看下面的示例，您可以收集结果以使用所需的行为（覆盖或放弃）进行映射，甚至可以尝试收集，但这样会使结果的值存储在列表中，即使只有一个值

public class SO66139006 {

    private static final Splitter PAIRS_SPLITTER = Splitter.on(' '); // .trimResults().omitEmptyStrings() if necessary
    private static final Splitter KEY_VALUE_SPLITTER = Splitter.on('=').limit(2);

    @Test
    public void shouldOverwriteValuesOnDuplicateKey() {
        //given
        String message = "ip=42.42.42.0 error=NA ip=1.2.9.0";
        //when
        Map<String, String> result = parseOverwritingValues(PAIRS_SPLITTER, KEY_VALUE_SPLITTER, message);
        //then
        assertThat(result) // {ip=1.2.9.0, error=NA}
                .containsExactly(entry("ip", "1.2.9.0"), entry("error", "NA"));
    }

    private Map<String, String> parseOverwritingValues(Splitter pairsSplitter, Splitter keyValueSplitter, String message) {
        return Streams.stream(pairsSplitter.split(message))
                .map(keyValueSplitter::splitToList)
                .collect(toImmutableMap(
                        list -> list.get(0),
                        list -> list.get(1),
                        (oldValue, newValue) -> newValue
                ));
    }

    @Test
    public void shouldDiscardValuesOnDuplicateKey() {
        //given
        String message = "ip=42.42.42.0 error=NA ip=1.2.9.0";
        //when
        Map<String, String> result = parseDiscardingValues(PAIRS_SPLITTER, KEY_VALUE_SPLITTER, message);
        //then
        assertThat(result) // {ip=42.42.42.0, error=NA}
                .containsExactly(entry("ip", "42.42.42.0"), entry("error", "NA"));
    }

    private Map<String, String> parseDiscardingValues(Splitter pairsSplitter, Splitter keyValueSplitter, String message) {
        return Streams.stream(pairsSplitter.split(message))
                .map(keyValueSplitter::splitToList)
                .collect(toImmutableMap(
                        list -> list.get(0),
                        list -> list.get(1),
                        (oldValue, newValue) -> oldValue
                ));
    }

    @Test
    public void shouldAppendValuesOnDuplicateKey() {
        //given
        String message = "ip=42.42.42.0 error=NA ip=1.2.9.0";
        //when
        ListMultimap<String, String> result = parseMultipleValues(PAIRS_SPLITTER, KEY_VALUE_SPLITTER, message);
        //then
        assertThat(result.asMap()) // {ip=[42.42.42.0, 1.2.9.0], error=[NA]}
                .containsExactly(entry("ip", ImmutableList.of("42.42.42.0", "1.2.9.0")), entry("error", ImmutableList.of("NA")));
    }

    private ListMultimap<String, String> parseMultipleValues(Splitter pairsSplitter, Splitter keyValueSplitter, String message) {
        return Streams.stream(pairsSplitter.split(message))
                .map(keyValueSplitter::splitToList)
                .collect(toImmutableListMultimap(
                        list -> list.get(0),
                        list -> list.get(1)
                ));
    }

    @Test
    public void shouldThrowByDefault() {
        //given
        String fieldSplit = " ";
        String valueSplit = "=";
        String message = "ip=1.2.9.0 error=NA ip=1.2.9.0";
        //when
        final Throwable throwable = catchThrowable(() -> Splitter.on(fieldSplit).omitEmptyStrings().withKeyValueSeparator(valueSplit).split(message));
        //then
        assertThat(throwable)
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessage("Duplicate key [ip] found.");
    }
}

公共类SO66139006{
私有静态最终拆分器对_Splitter=Splitter.on（“”）；//.trimResults（）。必要时省略EmptyStrings（）
私有静态最终拆分器键\u值\u Splitter=Splitter.on（'='）.limit（2）；
@试验
public void应覆盖EvaluesOnDuplicateKey（）{
//给定
字符串消息=“ip=42.42.42.0错误=NA ip=1.2.9.0”；
//什么时候
映射结果=解析覆盖值（成对拆分器、键值拆分器、消息）；
//然后
断言（结果）/{ip=1.2.9.0，错误=NA}