Unless Splitter is doing any magic, the getTokenizeString method is obsolete here. You can perform the entire processing as a single operation:

Map<String,String> map = Pattern.compile("\\s*-\\s*")
    .splitAsStream(responseString.trim())
    .map(s -> s.split("~", 2))
    .collect(Collectors.toMap(a -> a[0], a -> a.length>1? a[1]: ""));

By using the regular expression \s*-\s* as separator, you are considering white-space as part of the separator, hence implicitly trimming the entries. There’s only one initial trim operation before processing the entries, to ensure that there is no white-space before the first or after the last entry.

Then, simply split the entries in a map step before collecting into a Map.

You can use the following snippet for this:

Map<String, Map<String, String>> result = Arrays.stream(samp.split(","))
        .map(i -> i.split("-"))
        .collect(Collectors.groupingBy(a -> a[0], Collectors.toMap(a -> a[1], a -> a[2])));

First it creates a Stream of your items, which are mapped to a stream of arrays, containing the subitems. At the end you collect all by using group by on the first subitem and create an inner map with the second value as key and the last one as value.

The result is:

{101={1=5, 2=4}, 102={1=5, 2=5, 3=5}, 103={1=4}}

There is no need to reinvent the wheel. The Google Guava library provides the Splitter class.

Here's how you can use it along with some test code:

package com.sandbox;

import com.google.common.base.Splitter;
import org.junit.Test;

import java.util.Map;

import static org.junit.Assert.assertEquals;

public class SandboxTest {

    @Test
    public void testQuestionInput() {
        Map<String, String> map = splitToMap("A=4 H=X PO=87");
        assertEquals("4", map.get("A"));
        assertEquals("X", map.get("H"));
        assertEquals("87", map.get("PO"));
    }

    private Map<String, String> splitToMap(String in) {
        return Splitter.on(" ").withKeyValueSeparator("=").split(in);
    }

}

Split the string by , to get individual map entries. Then split them by = to get the key and the value.

Map<String, String> reconstructedUtilMap = Arrays.stream(utilMapString.split(","))
            .map(s -> s.split("="))
            .collect(Collectors.toMap(s -> s[0], s -> s[1]));

Note: As pointed out by Andreas@ in the comments, this is not a reliable way to convert between a map and a string

EDIT: Thanks to Holger for this suggestion.

Use s.split("=", 2) to ensure that the array is never larger than two elements. This will be useful to not lose the contents (when the value has =)

Example: when the input string is "a=1,b=2,c=3=44=5555" you will get {a=1, b=2, c=3=44=5555}

Earlier (just using s.split("=")) will give {a=1, b=2, c=3}

Based on tags you are looking for stream solutions. Here is one

String text = "id1:name1,id2:name1,id3:name2,id4:name2,id5:name2";
Map<String, List<String>> map = Arrays
        .stream(text.split(","))
        .map(pair -> pair.split(":"))
        .collect(Collectors.groupingBy(
                    pair -> pair[1], 
                    Collectors.mapping(e -> e[0], Collectors.toList())
                )
        );

System.out.println(map);

Output: {name2=[id3, id4, id5], name1=[id1, id2]}

You should use a Collectors::mapping to map the array to an element.

String flString = "view1:filedname11,view1:filedname12,view2:fieldname21";

Map<String, List<String>> map = Pattern.compile(",")
    .splitAsStream(flString)
    .map(a -> a.split(":"))
    .collect(
        Collectors.groupingBy(a -> a[0],
            Collectors.mapping(a -> a[1], Collectors.toList())
        )
    );

map.entrySet().forEach(System.out::println);

Output

view1=[filedname11, filedname12]
view2=[fieldname21]

You could use a loop to iterate over the key value pairs and put them into the map:

String[] cookieArr = cookies.split(";");
for(String cookieString : cookieArr){
  String[] pair = cookieString.split("=");
  if(pair.length < 2){
    continue;
  }
  map.put(pair[0], pair[1]);
}

The if is only there to prevent ArrayIndexOutOfBounds expcetions if cookie string is malformed

an alternativ would be using a stream:

Arrays.stream(cookies.split(";")).forEach(cookieStr -> map.put(cookieStr.split("=")[0], cookieStr.split("=")[1]));

As mentioned by @WJS in the comment, you could use map.putIfAbsent(key, vlaue) instead of map.put(key, value) to prevent overriding of values. But in case of cookies it could be a desired behavior to overwrite the old value with the new.

A simpler approach is to just use split with standard arrays.

String[] keyValues = currentString.split("=", 2);
String[] keys = keyValues[0].split("-");
String[] values = keyValues[1].split("-", keys.length);
Map<String, String> map = IntStream.range(0, keys.length).boxed()
        .collect(Collectors.toMap(i -> keys[i], i -> values[i]));

There's no error checking in this but hopefully it'll give you the general idea.