java如何獲取String里面的鍵值對(duì)："key=value&key=value"

一般的處理方式都是split,封裝成一個(gè)方法即可;
希望可以幫助到你.

兩次split都嫌煩嗎？包裝到一個(gè)方法里不就完了嗎

使用request.getParameterMap()方法

使用正則肯定最方便 —— 不過我倒是推崇直接使用 String 的 indexOf 和 substring 來做，這樣的效率比正則高一些：

import java.util.HashMap;
import java.util.Map;

public class Main {

    public static Map<String, String> getMap(String params) {
        HashMap<String, String> map = new HashMap<>();

        int start = 0, len = params.length();

        while (start < len) {
            int i = params.indexOf('&', start);

            if (i == -1) {
                i = params.length(); // 此時(shí)處理最后的鍵值對(duì)
            }

            String keyValue = params.substring(start, i);

            int j = keyValue.indexOf('=');
            String key = keyValue.substring(0, j);
            String value = keyValue.substring(j + 1, keyValue.length());

            map.put(key, value);

            if (i == params.length()) {
                break;
            }

            start = i + 1; // index+1 為下一個(gè)鍵值對(duì)的起始位置
        }

        return map;
    }

    public static void main(String[] args) throws Exception {
        String str = "k1=v1&k2=v2&k3=v3&k4=";

        Map<String, String> map = getMap(str);
        map.forEach((k, v) -> System.out.println(k + " -> " + v));
    }

}

使用正則表達(dá)式里面的組

如果可以的話string里的值，用json格式

字符串分割啊

我一個(gè)朋友幫我寫了一個(gè)，分享給大家：

package com.qtay.gls.common;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

public class FormDecoder {
    private Map<String, String> parameters;

    public FormDecoder(String str) {
        this.parameters = new HashMap<>();
        parse(this.parameters, str);
    }

    public String get(String key) {
        return this.get(key, null);
    }

    public String get(String key, String defaultValue) {
        String value = this.parameters.get(key);
        return Objects.isNull(value) ? defaultValue : value;
    }

    private int getInt32(String key) {
        return this.getInt32(key, 0);
    }

    private int getInt32(String key, int defaultValue) {
        String value = this.parameters.get(key);
        return Objects.isNull(value) || value.isEmpty() ? defaultValue : Integer.parseInt(value);
    }

    public long getInt64(String key) {
        return this.getInt64(key, 0L);
    }

    private long getInt64(String key, long defaultValue) {
        String value = this.parameters.get(key);
        return Objects.isNull(value) || value.isEmpty() ? defaultValue : Long.parseLong(value);
    }

    private float getFloat32(String key) {
        return this.getFloat32(key, 0F);
    }

    private float getFloat32(String key, float defaultValue) {
        String value = this.parameters.get(key);
        return Objects.isNull(value) || value.isEmpty() ? defaultValue : Float.parseFloat(value);
    }

    public double getFloat64(String key) {
        return this.getFloat64(key, 0D);
    }

    private double getFloat64(String key, double defaultValue) {
        String value = this.parameters.get(key);
        return Objects.isNull(value) || value.isEmpty() ? defaultValue : Double.parseDouble(value);
    }

    private boolean getBool(String key) {
        return this.getBool(key, false);
    }

    private boolean getBool(String key, boolean defaultValue) {
        String value = this.parameters.get(key);
        return Objects.isNull(value) || value.isEmpty() ? defaultValue : Boolean.parseBoolean(value);
    }

    private boolean contains(String key) {
        return this.parameters.containsKey(key);
    }

    private static void parse(Map<String, String> map, String str) {
        if(Objects.isNull(str) || str.isEmpty()) return ;
        Arrays.stream(str.split("&"))
                .filter(kv -> kv.contains("="))
                .map(kv -> kv.split("="))
                .forEach(array -> map.put(array[0], array[1]));
    }

//    public static void main(String[] args) {
//        String str = "a=1&b=3.5&c=true";
//        FormDecoder decoder = new FormDecoder(str);
//        System.out.println(decoder.contains("c"));
//        System.out.println(decoder.get("a"));
//        System.out.println(decoder.getInt32("a"));
//        System.out.println(decoder.getFloat32("b"));
//        System.out.println(decoder.getBool("c"));
//    }

}

自己寫個(gè)util 將這個(gè)String 轉(zhuǎn)成Map,或者固定object.用起來應(yīng)該還是比較方便的把? 比split('&')更簡(jiǎn)單的,或許就不應(yīng)該用這種方式的string 傳遞吧,用json吧.

String str = "a=c&b=d";
String key1 = str.split("&")[0].split("=")[0];
String key2 = str.split("&")[1].split("=")[0];
System.out.println(key1 + "--" + key2);
// a--b