[java基础]将请求参数排序并拼接

在日常的开发中，我们经常需要在请求参数签名前，对请求参数的参数名进行排序并拼接，再次记录，与君分享：

先上代码：

package com.wr.park_toolkit.utils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 请求参数工具类
 * 
 * @author aran
 *
 */
public class ReqParamsHelper {

	public static String genReqStringByMap(Map<String,String> params) {
		//keySet获取键集
		List<String> keys = new ArrayList<String>(params.keySet());
		//对键集进行排序
		Collections.sort(keys);
		String reqStr = "";
		for(int i = 0;i < keys.size();i++) {
			String curKey = keys.get(i);
			String curValue = params.get(curKey);
			// 如果是最后一个参数，则不加“&”
			if(i== keys.size() - 1) {
				reqStr = preStr + curKey + "=" + curValue;
			} else {
				reqStr = preStr + curKey + "=" + curValue + "&";
			}
			
		}
		return reqStr;
	}
	

}

下面做简单解释：

1. 获取请求参数，即params，类型为Map<String,String>
2. 获取params的键集：

//keySet获取键集
List<String> keys = new ArrayList<String>(params.keySet());

看下keySet()的源码：

 /**
     * Returns a {@link Set} view of the keys contained in this map.
     * The set is backed by the map, so changes to the map are
     * reflected in the set, and vice-versa.  If the map is modified
     * while an iteration over the set is in progress (except through
     * the iterator's own <tt>remove</tt> operation), the results of
     * the iteration are undefined.  The set supports element removal,
     * which removes the corresponding mapping from the map, via the
     * <tt>Iterator.remove</tt>, <tt>Set.remove</tt>,
     * <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt>
     * operations.  It does not support the <tt>add</tt> or <tt>addAll</tt>
     * operations.
     *
     * @return a set view of the keys contained in this map
     */
    Set<K> keySet();

可以看出，keySet() 返回的是一个由Map<K,V>中的K组成的Set

再看下ArrayList的源码，其实是调用了这样一个构造函数：

    /**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is null
     */
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

3. 对键集进行排序：

//对键集进行排序
Collections.sort(keys);

当然，sort函数还支持，传入第二个Comparator对象作为参数，即通过指定的排序算法进行排序：

//对键集进行排序
		Collections.sort(keys,(a,b) -> {
			return a.length() - b.length();
		});

除了使用lambda表达，你可以直接粗暴的匿名实现Comparator接口：

//对键集进行排序
		Collections.sort(keys,new Comparator<String>() {

			@Override
			public int compare(String s1, String s2) {
				 
				return s1.length() - s2.length();
			}
		});

4. 实例演示：

package com.wr.park_toolkit.utils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 请求参数工具类
 * 
 * @author aran
 *
 */
public class ReqParamsHelper {

	public static String genReqStringByMap(Map<String,String> params) {
		//keySet获取键集
		List<String> keys = new ArrayList<String>(params.keySet());
		//对键集进行排序
		Collections.sort(keys,new Comparator<String>() {

			@Override
			public int compare(String s1, String s2) {
				 
				return s1.length() - s2.length();
			}
		});
		String preStr = "";
		for(int i = 0;i < keys.size();i++) {
			String curKey = keys.get(i);
			String curValue = params.get(curKey);
			// 如果是最后一个参数，则不加“&”
			if(i== keys.size() - 1) {
				preStr = preStr + curKey + "=" + curValue;
			} else {
				preStr = preStr + curKey + "=" + curValue + "&";
			}
			
		}
		return preStr;
	}
	
	
	public static Map<String,String> genMap(){
		Map<String,String> paramsMap = new HashMap<>();
		int myAge = 18; 
		paramsMap.put("usernanme", "Aran");
		paramsMap.put("sex", "male");
		paramsMap.put("age",String.valueOf(myAge));
		
		
		
		return paramsMap;
	}
	
	
	public static void main(String[] args) {
		System.out.println(genReqStringByMap(genMap()));
	}
}
 

输出：

sex=male&age=18&usernanme=Aran

你也许会有一个小疑问：

sex 和 age 无论put的先后顺序如何，按照上述比较方式，都是sex在前，age在后，这是为什么呢？

其实我也还没找到出处，请大神指点！

不过经过我试验，如果比较后结果为0，我猜测是会继续比较第一个字符的ASCII码，并按照从大到小排定先后顺序，如果第一个字母依然相等，则依次比较。

map中，如果后面put进来的key已经存在，则直接覆盖，好惨！

参考：

https://blog.csdn.net/wahaha13168/article/details/82903850