이름 값 컬렉션으로의 URI 문자열 해석

이름 값 컬렉션으로의 URI 문자열 해석

URI는 다음과 같습니다.

https://google.com.ua/oauth/authorize?client_id=SS&response_type=code&scope=N_FULL&access_type=offline&redirect_uri=http://localhost/Callback

구문 분석된 요소가 포함된 컬렉션이 필요합니다.

NAME               VALUE
------------------------
client_id          SS
response_type      code
scope              N_FULL
access_type        offline
redirect_uri       http://localhost/Callback

정확히는 C#/에 해당하는 Java가 필요합니다.NET 방식

외부 라이브러리를 사용하지 않고 이 기능을 사용할 수 있는 방법을 찾는 경우 다음 코드를 참조하십시오.

public static Map<String, String> splitQuery(URL url) throws UnsupportedEncodingException {
    Map<String, String> query_pairs = new LinkedHashMap<String, String>();
    String query = url.getQuery();
    String[] pairs = query.split("&");
    for (String pair : pairs) {
        int idx = pair.indexOf("=");
        query_pairs.put(URLDecoder.decode(pair.substring(0, idx), "UTF-8"), URLDecoder.decode(pair.substring(idx + 1), "UTF-8"));
    }
    return query_pairs;
}

는 반환된 지도에 할 수 .<map>.get("client_id")「SS」의 URL.

UPDATE URL-디코딩 추가

업데이트 이 답변이 여전히 인기가 있기 때문에 위의 방법을 개선하여 동일한 키를 가진 여러 매개 변수와 값이 없는 매개 변수를 처리했습니다.

public static Map<String, List<String>> splitQuery(URL url) throws UnsupportedEncodingException {
  final Map<String, List<String>> query_pairs = new LinkedHashMap<String, List<String>>();
  final String[] pairs = url.getQuery().split("&");
  for (String pair : pairs) {
    final int idx = pair.indexOf("=");
    final String key = idx > 0 ? URLDecoder.decode(pair.substring(0, idx), "UTF-8") : pair;
    if (!query_pairs.containsKey(key)) {
      query_pairs.put(key, new LinkedList<String>());
    }
    final String value = idx > 0 && pair.length() > idx + 1 ? URLDecoder.decode(pair.substring(idx + 1), "UTF-8") : null;
    query_pairs.get(key).add(value);
  }
  return query_pairs;
}

Java8 버전 업데이트

public Map<String, List<String>> splitQuery(URL url) {
    if (Strings.isNullOrEmpty(url.getQuery())) {
        return Collections.emptyMap();
    }
    return Arrays.stream(url.getQuery().split("&"))
            .map(this::splitQueryParameter)
            .collect(Collectors.groupingBy(SimpleImmutableEntry::getKey, LinkedHashMap::new, mapping(Map.Entry::getValue, toList())));
}

public SimpleImmutableEntry<String, String> splitQueryParameter(String it) {
    final int idx = it.indexOf("=");
    final String key = idx > 0 ? it.substring(0, idx) : it;
    final String value = idx > 0 && it.length() > idx + 1 ? it.substring(idx + 1) : null;
    return new SimpleImmutableEntry<>(
        URLDecoder.decode(key, "UTF-8"),
        URLDecoder.decode(value, "UTF-8")
    );
}

URL을 사용하여 위의 메서드를 실행합니다.

https://stackoverflow.com?param1=value1&param2=&param3=value3&param3

다음 맵을 반환합니다.

{param1=["value1"], param2=[null], param3=["value3", null]}

org.displays.client.displays 를 지정합니다.URLEncodedUtils

이 기능을 이용할 수 있는 유명한 라이브러리입니다.

import org.apache.hc.client5.http.utils.URLEncodedUtils

String url = "http://www.example.com/something.html?one=1&two=2&three=3&three=3a";

List<NameValuePair> params = URLEncodedUtils.parse(new URI(url), Charset.forName("UTF-8"));

for (NameValuePair param : params) {
  System.out.println(param.getName() + " : " + param.getValue());
}

출력

one : 1
two : 2
three : 3
three : 3a

Spring Framework를 사용하는 경우:

public static void main(String[] args) {
    String uri = "http://my.test.com/test?param1=ab&param2=cd&param2=ef";
    MultiValueMap<String, String> parameters =
            UriComponentsBuilder.fromUriString(uri).build().getQueryParams();
    List<String> param1 = parameters.get("param1");
    List<String> param2 = parameters.get("param2");
    System.out.println("param1: " + param1.get(0));
    System.out.println("param2: " + param2.get(0) + "," + param2.get(1));
}

다음과 같은 이점을 얻을 수 있습니다.

param1: ab
param2: cd,ef

Google Guava를 사용하여 다음 두 줄로 수행합니다.

import java.util.Map;
import com.google.common.base.Splitter;

public class Parser {
    public static void main(String... args) {
        String uri = "https://google.com.ua/oauth/authorize?client_id=SS&response_type=code&scope=N_FULL&access_type=offline&redirect_uri=http://localhost/Callback";
        String query = uri.split("\\?")[1];
        final Map<String, String> map = Splitter.on('&').trimResults().withKeyValueSeparator('=').split(query);
        System.out.println(map);
    }
}

그러면

{client_id=SS, response_type=code, scope=N_FULL, access_type=offline, redirect_uri=http://localhost/Callback}

내가 찾은 가장 빠른 방법은 이것이다.

MultiValueMap<String, String> queryParams =
            UriComponentsBuilder.fromUriString(url).build().getQueryParams();

★★★★★★★ UriComponentsBuilder봄에서 왔다.여기 링크가 있습니다.

Android의 경우 프로젝트에서 OkHttp를 사용하는 경우.이거 볼 수 있을 거야.간단하고 도움이 됩니다.

final HttpUrl url = HttpUrl.parse(query);
if (url != null) {
    final String target = url.queryParameter("target");
    final String id = url.queryParameter("id");
}

플레인 Java 11

분석할 URL 지정:

URL url = new URL("https://google.com.ua/oauth/authorize?client_id=SS&response_type=code&scope=N_FULL&access_type=offline&redirect_uri=http://localhost/Callback");

이 솔루션은 쌍의 목록을 수집합니다.

List<Map.Entry<String, String>> list = Pattern.compile("&")
   .splitAsStream(url.getQuery())
   .map(s -> Arrays.copyOf(s.split("=", 2), 2))
   .map(o -> Map.entry(decode(o[0]), decode(o[1])))
   .collect(Collectors.toList());

한편, 이 솔루션은 맵을 수집합니다(URL에는 같은 이름으로 다른 값을 가진 파라미터가 더 있을 수 있습니다).

Map<String, List<String>> list = Pattern.compile("&")
   .splitAsStream(url.getQuery())
   .map(s -> Arrays.copyOf(s.split("=", 2), 2))
   .collect(groupingBy(s -> decode(s[0]), mapping(s -> decode(s[1]), toList())));

두 솔루션 모두 파라미터를 올바르게 디코딩하기 위해 유틸리티 함수를 사용해야 합니다.

private static String decode(final String encoded) {
    return Optional.ofNullable(encoded)
                   .map(e -> URLDecoder.decode(e, StandardCharsets.UTF_8))
                   .orElse(null);
}

servlet doGet 을 사용하고 있는 경우는, 이것을 시험해 주세요.

request.getParameterMap()

java.util을 반환합니다.이 요청의 파라미터 맵.

반환: 불변의 java.util.파라미터 이름을 키로, 파라미터 값을 맵 값으로 포함하는 맵.파라미터 맵의 키는 String 유형입니다.파라미터 맵의 값은 String 배열 유형입니다.

(자바 문서)

Android에서는 패키지 android.net에 URI 클래스가 있습니다.URI는 android.net의 일부이지만 URI는 java.net의 일부입니다.

URI 클래스에는 쿼리에서 키와 값의 쌍을 추출하는 함수가 많이 있습니다.

다음 함수는 HashMap 형식으로 키와 값의 쌍을 반환합니다.

자바어:

Map<String, String> getQueryKeyValueMap(Uri uri){
    HashMap<String, String> keyValueMap = new HashMap();
    String key;
    String value;

    Set<String> keyNamesList = uri.getQueryParameterNames();
    Iterator iterator = keyNamesList.iterator();

    while (iterator.hasNext()){
        key = (String) iterator.next();
        value = uri.getQueryParameter(key);
        keyValueMap.put(key, value);
    }
    return keyValueMap;
}

Kotlin의 경우:

fun getQueryKeyValueMap(uri: Uri): HashMap<String, String> {
        val keyValueMap = HashMap<String, String>()
        var key: String
        var value: String

        val keyNamesList = uri.queryParameterNames
        val iterator = keyNamesList.iterator()

        while (iterator.hasNext()) {
            key = iterator.next() as String
            value = uri.getQueryParameter(key) as String
            keyValueMap.put(key, value)
        }
        return keyValueMap
    }

Java 8을 사용하고 있으며 몇 가지 재사용 가능한 메서드를 작성할 의향이 있는 경우 한 줄로 작성할 수 있습니다.

private Map<String, List<String>> parse(final String query) {
    return Arrays.asList(query.split("&")).stream().map(p -> p.split("=")).collect(Collectors.toMap(s -> decode(index(s, 0)), s -> Arrays.asList(decode(index(s, 1))), this::mergeLists));
}

private <T> List<T> mergeLists(final List<T> l1, final List<T> l2) {
    List<T> list = new ArrayList<>();
    list.addAll(l1);
    list.addAll(l2);
    return list;
}

private static <T> T index(final T[] array, final int index) {
    return index >= array.length ? null : array[index];
}

private static String decode(final String encoded) {
    try {
        return encoded == null ? null : URLDecoder.decode(encoded, "UTF-8");
    } catch(final UnsupportedEncodingException e) {
        throw new RuntimeException("Impossible: UTF-8 is a required encoding", e);
    }
}

하지만 그건 꽤 잔인한 대사야.

Netty는 또한 라고 불리는 멋진 쿼리 문자열 파서를 제공합니다.QueryStringDecoder코드의 한 줄에서 질문의 URL을 해석할 수 있습니다. 던질 필요가 때문에 .java.net.MalformedURLException.

한 줄:

Map<String, List<String>> parameters = new QueryStringDecoder(url).parameters();

다음 사이트에서 javadocs를 참조하십시오.https://netty.io/4.1/api/io/netty/handler/codec/http/QueryStringDecoder.html

다음으로 간단한 자기 억제형 올바른 예를 제시하겠습니다.

import io.netty.handler.codec.http.QueryStringDecoder;
import org.apache.commons.lang3.StringUtils;

import java.util.List;
import java.util.Map;

public class UrlParse {

  public static void main(String... args) {
    String url = "https://google.com.ua/oauth/authorize?client_id=SS&response_type=code&scope=N_FULL&access_type=offline&redirect_uri=http://localhost/Callback";
    QueryStringDecoder decoder = new QueryStringDecoder(url);
    Map<String, List<String>> parameters = decoder.parameters();
    print(parameters);
  }

  private static void print(final Map<String, List<String>> parameters) {
    System.out.println("NAME               VALUE");
    System.out.println("------------------------");
    parameters.forEach((key, values) ->
        values.forEach(val ->
            System.out.println(StringUtils.rightPad(key, 19) + val)));
  }
}

그 결과,

NAME               VALUE
------------------------
client_id          SS
response_type      code
scope              N_FULL
access_type        offline
redirect_uri       http://localhost/Callback

위의 코멘트 및 솔루션을 사용하여 Map <String, Object>를 사용하여 모든 쿼리 파라미터를 저장합니다.여기서 Objects는 string 또는 Set <String> 중 하나입니다.해결책은 다음과 같습니다.먼저 URL을 검증하고 convertQueryStringToMap 메서드를 호출하기 위해 어떤 종류의 URL 검증기를 사용하는 것이 좋습니다.

private static final String DEFAULT_ENCODING_SCHEME = "UTF-8";

public static Map<String, Object> convertQueryStringToMap(String url) throws UnsupportedEncodingException, URISyntaxException {
    List<NameValuePair> params = URLEncodedUtils.parse(new URI(url), DEFAULT_ENCODING_SCHEME);
    Map<String, Object> queryStringMap = new HashMap<>();
    for(NameValuePair param : params){
        queryStringMap.put(param.getName(), handleMultiValuedQueryParam(queryStringMap, param.getName(), param.getValue()));
    }
    return queryStringMap;
}

private static Object handleMultiValuedQueryParam(Map responseMap, String key, String value) {
    if (!responseMap.containsKey(key)) {
        return value.contains(",") ? new HashSet<String>(Arrays.asList(value.split(","))) : value;
    } else {
        Set<String> queryValueSet = responseMap.get(key) instanceof Set ? (Set<String>) responseMap.get(key) : new HashSet<String>();
        if (value.contains(",")) {
            queryValueSet.addAll(Arrays.asList(value.split(",")));
        } else {
            queryValueSet.add(value);
        }
        return queryValueSet;
    }
}

나는 이것이 구글에서 어떻게 최고의 결과를 얻는지 Kotlin 버전을 시험해 보았다.

@Throws(UnsupportedEncodingException::class)
fun splitQuery(url: URL): Map<String, List<String>> {

    val queryPairs = LinkedHashMap<String, ArrayList<String>>()

    url.query.split("&".toRegex())
            .dropLastWhile { it.isEmpty() }
            .map { it.split('=') }
            .map { it.getOrEmpty(0).decodeToUTF8() to it.getOrEmpty(1).decodeToUTF8() }
            .forEach { (key, value) ->

                if (!queryPairs.containsKey(key)) {
                    queryPairs[key] = arrayListOf(value)
                } else {

                    if(!queryPairs[key]!!.contains(value)) {
                        queryPairs[key]!!.add(value)
                    }
                }
            }

    return queryPairs
}

그리고 확장 방법은

fun List<String>.getOrEmpty(index: Int) : String {
    return getOrElse(index) {""}
}

fun String.decodeToUTF8(): String { 
    URLDecoder.decode(this, "UTF-8")
}

URI 쿼리 부분을 디코딩하기 위한 즉시 사용 가능한 솔루션(디코딩 및 다중 파라미터 값 포함)

평.

https://stackoverflow.com/a/13592567/1211082의 @Pr0gr4mm3r에서 제공하는 코드가 마음에 들지 않았습니다.스트림 기반 솔루션에서는 URLDecoding(변환 가능한 버전)은 수행되지 않습니다.

그래서 나는 그 해결책을 정교하게 설명했다.

• 을 URI로 할 수 .Map<String, List<Optional<String>>>
• 동일한 매개 변수 이름에 대해 여러 값을 처리할 수 있습니다.
• 값 없이 파라미터를 올바르게 나타낼 수 있습니다(Optional.empty()null)
• 매개 변수 이름 및 값을 올바르게 디코딩합니다.URLdecode
• Java 8 Streams 기반
• 직접 사용 가능(아래의 Import를 포함한 코드 참조)
• 처리를 하게 합니다(에서는, 마크를 온으로 ).UnsupportedEncodingException 시 " " "로 변경하다RuntimeUnsupportedEncodingException를 던지는 골칫거리입니다(일반 기능을 함수로 감싸서 체크된 예외를 던지는 것은 골칫거리입니다. 스칼라 라 and andTry자바(Java)

자바 코드

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.*;
import static java.util.stream.Collectors.*;

public class URIParameterDecode {
    /**
     * Decode parameters in query part of a URI into a map from parameter name to its parameter values.
     * For parameters that occur multiple times each value is collected.
     * Proper decoding of the parameters is performed.
     * 
     * Example
     *   <pre>a=1&b=2&c=&a=4</pre>
     * is converted into
     *   <pre>{a=[Optional[1], Optional[4]], b=[Optional[2]], c=[Optional.empty]}</pre>
     * @param query the query part of an URI 
     * @return map of parameters names into a list of their values.
     *         
     */
    public static Map<String, List<Optional<String>>> splitQuery(String query) {
        if (query == null || query.isEmpty()) {
            return Collections.emptyMap();
        }

        return Arrays.stream(query.split("&"))
                    .map(p -> splitQueryParameter(p))
                    .collect(groupingBy(e -> e.get0(), // group by parameter name
                            mapping(e -> e.get1(), toList())));// keep parameter values and assemble into list
    }

    public static Pair<String, Optional<String>> splitQueryParameter(String parameter) {
        final String enc = "UTF-8";
        List<String> keyValue = Arrays.stream(parameter.split("="))
                .map(e -> {
                    try {
                        return URLDecoder.decode(e, enc);
                    } catch (UnsupportedEncodingException ex) {
                        throw new RuntimeUnsupportedEncodingException(ex);
                    }
                }).collect(toList());

        if (keyValue.size() == 2) {
            return new Pair(keyValue.get(0), Optional.of(keyValue.get(1)));
        } else {
            return new Pair(keyValue.get(0), Optional.empty());
        }
    }

    /** Runtime exception (instead of checked exception) to denote unsupported enconding */
    public static class RuntimeUnsupportedEncodingException extends RuntimeException {
        public RuntimeUnsupportedEncodingException(Throwable cause) {
            super(cause);
        }
    }

    /**
     * A simple pair of two elements
     * @param <U> first element
     * @param <V> second element
     */
    public static class Pair<U, V> {
        U a;
        V b;

        public Pair(U u, V v) {
            this.a = u;
            this.b = v;
        }

        public U get0() {
            return a;
        }

        public V get1() {
            return b;
        }
    }
}

스칼라 코드

...완성을 위해 나는 간결함과 아름다움이 지배하는 스칼라 솔루션을 제공하지 않을 수 없다.

import java.net.URLDecoder

object Decode {
  def main(args: Array[String]): Unit = {
    val input = "a=1&b=2&c=&a=4";
    println(separate(input))
  }

  def separate(input: String) : Map[String, List[Option[String]]] = {
    case class Parameter(key: String, value: Option[String])

    def separateParameter(parameter: String) : Parameter =
      parameter.split("=")
               .map(e => URLDecoder.decode(e, "UTF-8")) match {
      case Array(key, value) =>  Parameter(key, Some(value))
      case Array(key) => Parameter(key, None)
    }

    input.split("&").toList
      .map(p => separateParameter(p))
      .groupBy(p => p.key)
      .mapValues(vs => vs.map(p => p.value))
  }
}

Kotlin's Answer는 https://stackoverflow.com/a/51024552/3286489,에서 처음 참조했지만 코드를 정리하여 버전을 개선하고 2가지 버전을 제공하며 불변의 수집 작업을 사용합니다.

사용하다java.net.URI쿼리를 추출합니다.그런 다음 아래에 제공된 확장 함수를 사용합니다.

1. 쿼리의 마지막 값만 원하는 것으로 가정합니다. page2&page3얻을 수 있다{page=3}, 다음의 확장 기능을 사용합니다.

    fun URI.getQueryMap(): Map<String, String> {
        if (query == null) return emptyMap()

        return query.split("&")
                .mapNotNull { element -> element.split("=")
                        .takeIf { it.size == 2 && it.none { it.isBlank() } } }
                .associateBy({ it[0].decodeUTF8() }, { it[1].decodeUTF8() })
    }

    private fun String.decodeUTF8() = URLDecoder.decode(this, "UTF-8") // decode page=%22ABC%22 to page="ABC"

2. 쿼리의 모든 값 목록이 필요한 경우. page2&page3얻을 수 있다{page=[2, 3]}

    fun URI.getQueryMapList(): Map<String, List<String>> {
        if (query == null) return emptyMap()

        return query.split("&")
                .distinct()
                .mapNotNull { element -> element.split("=")
                        .takeIf { it.size == 2 && it.none { it.isBlank() } } }
                .groupBy({ it[0].decodeUTF8() }, { it[1].decodeUTF8() })
    }

    private fun String.decodeUTF8() = URLDecoder.decode(this, "UTF-8") // decode page=%22ABC%22 to page="ABC"

아래와 같이 사용하는 방법

    val uri = URI("schema://host/path/?page=&page=2&page=2&page=3")
    println(uri.getQueryMapList()) // Result is {page=[2, 3]}
    println(uri.getQueryMap()) // Result is {page=3}

쿼리에 단일 매개 변수 정의가 있을 때 지정한 것처럼 쿼리에 적합한 답변이 많이 있습니다.일부 응용 프로그램에서는 다음과 같은 몇 가지 추가 쿼리 파라미터 에지 케이스를 처리하는 것이 유용할 수 있습니다.

• 다음과 같은 매개 변수 값 목록param1&param1=value&param1=의미.param1로 설정되어 있다.List.of("", "value", "")
• 다음과 같은 잘못된 치환querypath?&=&&=noparamname&.
• 맵에서 null이 아닌 빈 문자열을 사용합니다.a='a'는List.of("")웹 서블릿 처리를 일치시키다

필터 및 groupingBy가 포함된 스트림을 사용하여 수집합니다.Map<String, List<String>>:

public static Map<String, List<String>> getParameterValues(URL url) {
    return Arrays.stream(url.getQuery().split("&"))
            .map(s -> s.split("="))
            // filter out empty parameter names (as in Tomcat) "?&=&&=value&":
            .filter(arr -> arr.length > 0 && arr[0].length() > 0)
            .collect(Collectors.groupingBy(arr -> URLDecoder.decode(arr[0], StandardCharsets.UTF_8),
                     // drop this line for not-name definition order Map:
                     LinkedHashMap::new, 
                     Collectors.mapping(arr -> arr.length < 2 ? "" : URLDecoder.decode(arr[1], StandardCharsets.UTF_8), Collectors.toList())));
}

스프링을 사용하는 경우 유형의 인수를 추가합니다.@RequestParam Map<String,String>Spring이 지도를 만들어 줄 것입니다!

Java 8 버전에 대한 업데이트입니다.

public Map<String, List<String>> splitQuery(URL url) {
    if (Strings.isNullOrEmpty(url.getQuery())) {
        return Collections.emptyMap();
    }
    return Arrays.stream(url.getQuery().split("&"))
            .map(this::splitQueryParameter)
            .collect(Collectors.groupingBy(SimpleImmutableEntry::getKey, LinkedHashMap::new, **Collectors**.mapping(Map.Entry::getValue, **Collectors**.toList())));
}

mapping 및 toList() 메서드는 상위 답변에서 언급되지 않은 Collector와 함께 사용해야 합니다.그렇지 않으면 IDE에서 컴파일 오류가 발생합니다.

인기 있는 스레드이기 때문에 여기에 대답합니다.이것은 Kotlin에서 권장하는 클린솔루션입니다.UrlQuerySanitizerapi. 공식 문서를 참조하십시오.저는 파라미터를 연결하여 표시하기 위해 문자열 작성기를 추가했습니다.

    var myURL: String? = null

    if (intent.hasExtra("my_value")) {
        myURL = intent.extras.getString("my_value")
    } else {
        myURL = intent.dataString
    }

    val sanitizer = UrlQuerySanitizer(myURL)
    // We don't want to manually define every expected query *key*, so we set this to true
    sanitizer.allowUnregisteredParamaters = true
    val parameterNamesToValues: List<UrlQuerySanitizer.ParameterValuePair> = sanitizer.parameterList
    val parameterIterator: Iterator<UrlQuerySanitizer.ParameterValuePair> = parameterNamesToValues.iterator()

    // Helper simply so we can display all values on screen
    val stringBuilder = StringBuilder()

    while (parameterIterator.hasNext()) {
        val parameterValuePair: UrlQuerySanitizer.ParameterValuePair = parameterIterator.next()
        val parameterName: String = parameterValuePair.mParameter
        val parameterValue: String = parameterValuePair.mValue

        // Append string to display all key value pairs
        stringBuilder.append("Key: $parameterName\nValue: $parameterValue\n\n")
    }

    // Set a textView's text to display the string
    val paramListString = stringBuilder.toString()
    val textView: TextView = findViewById(R.id.activity_title) as TextView
    textView.text = "Paramlist is \n\n$paramListString"

    // to check if the url has specific keys
    if (sanitizer.hasParameter("type")) {
        val type = sanitizer.getValue("type")
        println("sanitizer has type param $type")
    }

절감 및 옵션 기능을 갖춘 솔루션을 다음에 나타냅니다.

private Optional<SimpleImmutableEntry<String, String>> splitKeyValue(String text) {
    String[] v = text.split("=");
    if (v.length == 1 || v.length == 2) {
        String key = URLDecoder.decode(v[0], StandardCharsets.UTF_8);
        String value = v.length == 2 ? URLDecoder.decode(v[1], StandardCharsets.UTF_8) : null;
        return Optional.of(new SimpleImmutableEntry<String, String>(key, value));
    } else
        return Optional.empty();
}

private HashMap<String, String> parseQuery(URI uri) {
    HashMap<String, String> params = Arrays.stream(uri.getQuery()
            .split("&"))
            .map(this::splitKeyValue)
            .filter(Optional::isPresent)
            .map(Optional::get)
            .reduce(
                // initial value
                new HashMap<String, String>(), 
                // accumulator
                (map, kv) -> {
                     map.put(kv.getKey(), kv.getValue()); 
                     return map;
                }, 
                // combiner
                (a, b) -> {
                     a.putAll(b); 
                     return a;
                });
    return params;
}

• 중복된 파라미터는 무시합니다(마지막 파라미터는 무시합니다).
• 사용하고 있다Optional<SimpleImmutableEntry<String, String>>나중에 쓰레기를 무시하다
• 축소는 빈 맵에서 시작하여 각 SimpleImmmutableEntry에 입력합니다.

reduce를 요청하면 마지막 파라미터에 이 이상한 결합기가 필요하며 이는 병렬스트림에서만 사용됩니다.그 목적은 두 개의 중간 결과(여기서는 HashMap)를 병합하는 것입니다.

클래스 패스에 cxf-core가 있고 반복 쿼리 파라미터가 없는 경우 UrlUtils.parseQueryString을 사용할 수 있습니다.

Eclipse Jersey REST 프레임워크는 를 통해 이를 지원합니다. 예:

import org.glassfish.jersey.uri.UriComponent;

String uri = "https://google.com.ua/oauth/authorize?client_id=SS&response_type=code&scope=N_FULL&access_type=offline&redirect_uri=http://localhost/Callback";
MultivaluedMap<String, String> params = UriComponent.decodeQuery(URI.create(uri), true);
for (String key : params.keySet()) {
  System.out.println(key + ": " + params.getFirst(key));
}

String에서 URL 뒤에 있는 파라미터만 원하는 경우.그러면 다음 코드가 작동합니다.단순한 URL을 상정하고 있습니다.하드하고 빠르게 확인하고 해독할 수 없다는 뜻이죠.테스트 케이스 중 하나에서 URL을 얻었을 때 파라미터의 값만 있으면 된다는 것을 알고 있습니다.URL은 단순했습니다.인코딩 디코딩은 필요 없습니다.

String location = "https://google.com.ua/oauth/authorize?client_id=SS&response_type=code&scope=N_FULL&access_type=offline&redirect_uri=http://localhost/Callback";
String location1 = "https://stackoverflow.com?param1=value1&param2=value2&param3=value3";
String location2 = "https://stackoverflow.com?param1=value1&param2=&param3=value3&param3";
    
    Map<String, String> paramsMap = Stream.of(location)
        .filter(l -> l.indexOf("?") != -1)
        .map(l -> l.substring(l.indexOf("?") + 1, l.length()))
        .flatMap(q -> Pattern.compile("&").splitAsStream(q))
        .map(s -> s.split("="))
        .filter(a -> a.length == 2)
        .collect(Collectors.toMap(
            a -> a[0], 
            a -> a[1],
            (existing, replacement) -> existing + ", " + replacement,
            LinkedHashMap::new
        ));
    
    System.out.println(paramsMap);

감사합니다.

클라이언트의 인 Apache HTTP가 .org.apache.httpcomponents.client5서 - 디 - -URLEncodedUtils을 사용하다 URIBuilder대신 을 사용해야 합니다.

import org.apache.hc.core5.http.NameValuePair;
import org.apache.hc.core5.net.URIBuilder;

private static Map<String, String> getQueryParameters(final String url) throws URISyntaxException {
    return new URIBuilder(new URI(url), StandardCharsets.UTF_8).getQueryParams()
                                                               .stream()
                                                               .collect(Collectors.toMap(NameValuePair::getName,
                                                                                         nameValuePair -> URLDecoder.decode(nameValuePair.getValue(), StandardCharsets.UTF_8)));
}

언급URL : https://stackoverflow.com/questions/13592236/parse-a-uri-string-into-name-value-collection