根据汉字首字母排序并进行分组

需  求：

页面有一个下拉选项框（选择汽车品牌），由于品牌比较多，所以需要通过首字母就能快捷选择，也就是说：点击字母 “B”后，把汽车品牌首拼音字母为 “B” 的显示出来。汽车品牌数据从数据库表里面取。

原型图：

分  析：

这里分两种情况，第一种：表里面有汽车品牌名称首字母字段，第二种就是没有这个字段。如果表里面有字段，那么查询出来后直接用Java集合分组处理即可，如果数据库里面没有这个字段，就需要一个相对复杂的处理。

该方案也是网上查询很多大神的文章得到的。

第一种情况：表里面有汽车品牌名称首字母字段

1. 新建一个实体类

/**
 * 汽车品牌信息实体类
 */
public class CarParmCarBaseInfo {
	
    /** 品牌首字母 */
    private String carBrandFirstLetter;

    /** 品牌名称 */
    private String carBrand;

    /** 品牌ID */
    private String carBrandId;

	public String getCarBrandFirstLetter() {
		return carBrandFirstLetter;
	}

	public void setCarBrandFirstLetter(String carBrandFirstLetter) {
		this.carBrandFirstLetter = carBrandFirstLetter;
	}

	public String getCarBrand() {
		return carBrand;
	}

	public void setCarBrand(String carBrand) {
		this.carBrand = carBrand;
	}

	public String getCarBrandId() {
		return carBrandId;
	}

	public void setCarBrandId(String carBrandId) {
		this.carBrandId = carBrandId;
	}

	@Override
	public String toString() {
		return "CarParmCarBaseInfo [carBrandFirstLetter=" +          carBrandFirstLetter
				+ ", carBrand=" + carBrand + ", carBrandId=" + carBrandId + "]";
	}
    
}

2. 排序且分组的方法

/**
     * 查询所有汽车品牌
     * @param id
     * @return
     */
	public Map<String, List<CarParmCarBaseInfo>> getCarBrandList(){
		Map<String, List<CarParmCarBaseInfo>> resultMap = new HashMap<String, List<CarParmCarBaseInfo>>();
                // 从数据库获取的品牌数据集合
		List<CarParmCarBaseInfo> cList = cBaseInfoMapper.getCarBrandList();
		try {
		for (CarParmCarBaseInfo cInfo : cList) {
			// map中的key是否包含品牌首字母，存在则直接添加,否则新建key然后添加进去
			if (resultMap.containsKey(cInfo.getCarBrandFirstLetter())) {
				resultMap.get(cInfo.getCarBrandFirstLetter()).add(cInfo);
			}else {
				List<CarParmCarBaseInfo> tempList = new ArrayList<CarParmCarBaseInfo>();
				tempList.add(cInfo);
				resultMap.put(cInfo.getCarBrandFirstLetter(), tempList);
			}
		 }
		} catch (Exception e) {
				logger.info("汽车品牌按照品牌字母分组出现异常！");
				System.out.println(e);
				}
    	return resultMap;
    }

第二种情况：表里面没有汽车品牌名称首字母字段

1. 排序算法

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


/**
 * 排序算法
 * @author zhaoheng
 * @creation date 2018-09-12
 */
public class Sort {
	
	/**
	 * 字母大小写标识 capital:大写
	 */
	private static final String Letter_flag_capital = "capital";
	
	 /**
     * 排序的方法
     * @param list 需要排序的List集合
     * @return
     */
    public Map<String,List<String>> sort(List<String> list){
   	 Map<String,List<String>> map = new HashMap<String,List<String>>();
   	 List<String> arraylist = new ArrayList<String>();
   	 String[] alphatableb =
            {
   	        "A", "B", "C", "D", "E", "F", "G", "H", "I",
               "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"
   	       };
   		 for(String a:alphatableb){
   			 for(int i=0;i<list.size();i++){//为了排序都返回大写字母
	    			 if(a.equals(String2AlphaFirst(list.get(i).toString(),Letter_flag_capital))){
	    				 arraylist.add(list.get(i).toString());
	    			 }
   		     }
   			 map.put(a,arraylist);
   			 arraylist=new ArrayList<String>();
   	 }
   	 return map;
    }
	
	     //字母Z使用了两个标签，这里有２７个值
	 	 //i, u, v都不做声母, 跟随前面的字母
	    private char[] chartable =
           {
             '啊', '芭', '擦', '搭', '蛾', '发', '噶', '哈', '哈',
             '击', '喀', '垃', '妈', '拿', '哦', '啪', '期', '然',
             '撒', '塌', '塌', '塌', '挖', '昔', '压', '匝', '座'
            };
	    
	    // 大写字母匹配数组
	    private char[] alphatableb =
          {
 	         'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
             'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
 	       };
	    
	    // 小写字母匹配数组
	    private char[] alphatables =
          {
 	         'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
             'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
 	       };
	    
	    private int[] table = new int[27];  //初始化
	      {
	 	         for (int i = 0; i < 27; ++i) {
	 	             table[i] = gbValue(chartable[i]);
	 	         }
	       }
	      
	      /**
	       * 主函数,输入字符,得到他的声母,英文字母返回对应的大小写字母,英文字母返回对应的大小写字母
	       * @param ch 字符
	       * @param type 大小写类型标识
	       * @return
	       */
	     public char Char2Alpha(char ch,String type) {
	          if (ch >= 'a' && ch <= 'z')
	              return (char) (ch - 'a' + 'A');//为了按字母排序先返回大写字母

	          if (ch >= 'A' && ch <= 'Z')
	              return ch;
	             int gb = gbValue(ch);
	 	         if (gb < table[0])
	              return '0';
	  
	          int i;
	 	         for (i = 0; i < 26; ++i) {
	              if (match(i, gb))
	 	                 break;
	          }
	 	 
	 	         if (i >= 26){
	              return '0';}
	 	         else{
	 	        	 if(Letter_flag_capital.equals(type)){//大写
	                     return alphatableb[i];
	                 }else{//小写
	                	 return alphatables[i];
	                 }
	 	         }
	      }
	     
	 /**
	  * 根据一个包含汉字的字符串返回一个汉字拼音首字母的字符串
	  * @param SourceStr 目标字符串
	  * @param type      大小写类型
	  * @return
	  */
     public String String2Alpha(String SourceStr,String type) {
         String Result = "";
         int StrLength = SourceStr.length();
         int i;
      try {
          for (i = 0; i < StrLength; i++) {
                 Result += Char2Alpha(SourceStr.charAt(i),type);
             }
         } catch (Exception e) {
          Result = "";
         }
      return Result;
    }
     
	 /**
	  * 根据一个包含汉字的字符串返回第一个汉字拼音首字母的字符串
	  * @param SourceStr 目标字符串
	  * @param type      大小写类型
	  * @return
	  */
     public String String2AlphaFirst(String SourceStr,String type) {
           String Result = "";
         try {
           Result += Char2Alpha(SourceStr.charAt(0),type);
         } catch (Exception e) {
           Result = "";
         }
      return Result;
    }
     private boolean match(int i, int gb) {
            if (gb < table[i])
               return false;
 	         int j = i + 1;
  	 
 	         //字母Z使用了两个标签
  	         while (j < 26 && (table[j] == table[i]))
 	             ++j;
 	         if (j == 26)
 	             return gb <= table[j];
            else
 	             return gb < table[j];
  	      }
    	  	 
     /**
      * 取出汉字的编码
      * @param ch
      * @return
      */
     private int gbValue(char ch) {
	     String str = new String();
	     str += ch;
	     try {
	         byte[] bytes = str.getBytes("GBK");
	             if (bytes.length < 2)
	                 return 0;
	             return (bytes[0] << 8 & 0xff00) + (bytes[1] &
	                     0xff);
	         } catch (Exception e) {
	           return 0;
	         }
	     }
}
 

2. 调用测试

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

/**
 * 模拟调用测试类
 * @author zhaoheng
 * 2018-09-12
 */
public class SortService {
	
	/**
	 * 用于隔开名称和id
	 */
	private static final String KEY_SPLIT = ":";
	
	// 测试的主方法
	public static void main(String[] args) {
		List<CarParmCarBaseInfo> cList = new ArrayList<CarParmCarBaseInfo>();
		CarParmCarBaseInfo carInfo1 = new CarParmCarBaseInfo();
		carInfo1.setCarBrand("宝马");
		carInfo1.setCarBrandId("10010");
		
		CarParmCarBaseInfo carInfo2 = new CarParmCarBaseInfo();
		carInfo2.setCarBrand("宾利");
		carInfo2.setCarBrandId("10012");
		
		CarParmCarBaseInfo carInfo3 = new CarParmCarBaseInfo();
		carInfo3.setCarBrand("大众");
		carInfo3.setCarBrandId("10013");
		
		CarParmCarBaseInfo carInfo4 = new CarParmCarBaseInfo();
		carInfo4.setCarBrand("东风");
		carInfo4.setCarBrandId("10014");
		
		CarParmCarBaseInfo carInfo5 = new CarParmCarBaseInfo();
		carInfo5.setCarBrand("奥迪");
		carInfo5.setCarBrandId("10015");
		
		List<String> list = new ArrayList<String>();
		
		list.add(carInfo1.getCarBrand()+KEY_SPLIT+carInfo1.getCarBrandId());
		list.add(carInfo2.getCarBrand()+KEY_SPLIT+carInfo2.getCarBrandId());
		list.add(carInfo3.getCarBrand()+KEY_SPLIT+carInfo3.getCarBrandId());
		list.add(carInfo4.getCarBrand()+KEY_SPLIT+carInfo4.getCarBrandId());
		list.add(carInfo5.getCarBrand()+KEY_SPLIT+carInfo5.getCarBrandId());
		
		for (CarParmCarBaseInfo str : cList) {
			list.add(str.getCarBrand()+KEY_SPLIT+str.getCarBrandId());
		}
		// 调用排序的方法
		SortService sort = new SortService();
		sort.carSort(list);
	  } 
	
	/**
	 * 排序的方法
	 * @param list
	 */
	public void carSort(List<String> list) {
		Sort sort = new Sort();
		Map<String,List<String>> map = sort.sort(list);
		
		Map<String, List<CarParmCarBaseInfo>> resultMap = new HashMap<String, List<CarParmCarBaseInfo>>();
		
		// 遍历排序之后的集合
        for (Entry<String, List<String>> listEntry : map.entrySet()) {
        	for (String value : listEntry.getValue()) {
        		
        		// map中的key是否包含品牌首字母，若存在则把数据处理之后存储到对象里面，然后添加到List里面,
        		// 否则新建key然后再把数据处理之后存储到对象里面，然后添加到List里面
				if (resultMap.containsKey(listEntry.getKey())) {
					CarParmCarBaseInfo carBaseInfo = new CarParmCarBaseInfo();
					
					String [] brandArray = value.split(KEY_SPLIT); // 按:把品牌名称和id分开
					carBaseInfo.setCarBrand(brandArray[0]);    				// 品牌名称
					carBaseInfo.setCarBrandId(brandArray[1]);  				// 品牌id
					carBaseInfo.setCarBrandFirstLetter(listEntry.getKey()); // 品牌名称首字母
					
					resultMap.get(listEntry.getKey()).add(carBaseInfo);
					
				}else {
					List<CarParmCarBaseInfo> list2 = new ArrayList<CarParmCarBaseInfo>();
					CarParmCarBaseInfo carBaseInfo = new CarParmCarBaseInfo();
					
					String [] brandArray = value.split(KEY_SPLIT); // 按:把品牌名称和id分开
					carBaseInfo.setCarBrand(brandArray[0]);    				// 品牌名称
					carBaseInfo.setCarBrandId(brandArray[1]);  				// 品牌id
					carBaseInfo.setCarBrandFirstLetter(listEntry.getKey()); // 品牌名称首字母
					list2.add(carBaseInfo);
					
					resultMap.put(listEntry.getKey(), list2);
				}
			}
		}
        // 打印排序后的结果
        for (Entry<String, List<CarParmCarBaseInfo>> entry : resultMap.entrySet()) {
 			System.out.println(entry);
 		}
	}
}

测试结果：

A=[CarParmCarBaseInfo [carBrandFirstLetter=A, carBrand=奥迪, carBrandId=10015]]
B=[CarParmCarBaseInfo [carBrandFirstLetter=B, carBrand=宝马, carBrandId=10010], CarParmCarBaseInfo [carBrandFirstLetter=B, carBrand=宾利, carBrandId=10012]]
D=[CarParmCarBaseInfo [carBrandFirstLetter=D, carBrand=大众, carBrandId=10013], CarParmCarBaseInfo [carBrandFirstLetter=D, carBrand=东风, carBrandId=10014]]

通过以上处理之后，前端就可以拿到经过排序并且分组的数据。

如果需要对 Java 对象进行排序 请移步这里 https://blog.csdn.net/Muscleheng/article/details/81742723