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

迷南。 2024-02-18 23:41 81阅读 0赞

**需 求：**

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

原型图：

![70][]

**分 析：**

这里分两种情况，第一种：表里面有汽车品牌名称首字母字段，第二种就是没有这个字段。如果表里面有字段，那么查询出来后直接用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][https_blog.csdn.net_Muscleheng_article_details_81742723]

[70]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/b4be34a4087440c487d0106008f0eea4.png
[https_blog.csdn.net_Muscleheng_article_details_81742723]: https://blog.csdn.net/Muscleheng/article/details/81742723