精华内容
下载资源
问答
  • Java字符排序中文+数字

    万次阅读 2013-09-15 16:34:49
    解决思路: 在Java中,排序需要复写的是 equals 方法 和 Comparable 接口 的public int compareTo(T o); 方法 步骤: 1. 使用正则表达式来判断数字,多个连续的数字作为一组, 2. 一次检索出数字组合, 3. 检出下...

    编写日期: 2013年9月15日

    另一中解法:点击查看

    解决思路: 在Java中,排序需要复写的是 equals 方法 和 Comparable<T> 接口 的public int compareTo(T o); 方法

    步骤:

    1. 使用正则表达式来判断数字,多个连续的数字作为一组,

    2.  一次检索出数字组合,

    3. 检出下一组数字,如果有,则进入步骤4,否则进入步骤6.

    4. 如果两组数字出现的位置相等,并且前面部分的字符串相等,则进入第5步。否则break,跳到第6步.

    5. 如果前面部分的字符串完全一致。则比较两个数字的大小,如果大小一致,则进入下一组,即步骤3.如果大小不一致,则可以比对出来大小,比较结束

    6. 调用String的compareTo方法,病返回(流程结束)。

    完整的代码如下:

    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    //包装器类
    public class OrderWrapper implements Comparable<OrderWrapper>{
    	String name = null;
    	public OrderWrapper(String name){
    		this.name = name;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    	@Override
    	public String toString() {
    		return String.valueOf(name);
    	}
    	@Override
    	public boolean equals(Object obj) {
    		if(obj == this){
    			return true;
    		} 
    		
    		if(obj instanceof OrderWrapper){
    			OrderWrapper other = (OrderWrapper)obj;
    	
    			if(null == this.name){
    				return false;
    			} else {
    				return this.name.equals(other.name);
    			}
    		}
    		return false;
    	}
    
    	// 比较方法,相当于减法。 (return this - wrapper)
    	public int compareTo(OrderWrapper wrapper) {
    		if(null == wrapper){
    			return 1;
    		}
    		// 直接相等
    		if(this == wrapper || this.equals(wrapper)){
    			return 0;
    		}
    		String name1 = this.name;
    		String name2 = wrapper.name;
    		// 特殊情形,name有一个为空的情况.
    		if(null == name1){
    			// 都为空,认为相对
    			if(null == name2){
    				return 0;
    			} else {
    				return -1;
    			}
    		} else if(null == name2){
    			return 1;
    		}
    		// 中间 1-多个数字
    		Pattern pattern = Pattern.compile("\\D*(\\d+)\\D*");
    		Matcher matcher1 = pattern.matcher(name1);
    		Matcher matcher2 = pattern.matcher(name2);
    		//System.out.println(pattern.pattern());
    		//
    		int index1_step = 0;
    		int index2_step = 0;
    		while(matcher1.find()){
    			String s1 = matcher1.group(1);
    			String s2 = null;
    			if(matcher2.find()){
    				s2 = matcher2.group(1);
    			}
    			int index1 = name1.indexOf(s1, index1_step);
    			int index2 = name2.indexOf(s2, index2_step);
    			//
    			index1_step = index1;
    			index2_step = index2;
    			// 索引相等的情况下
    			if(index1 == index2){
    				System.out.println("name1="+name1.length()+"\nname2="+name2.length());
    				System.out.println("index1="+index1+",index2="+index2);
    				String pre1 = name1.substring(0, index1);
    				String pre2 = name2.substring(0, index2);
    				if(pre1.equals(pre2)){
    					// 
    					long num1 = Long.parseLong(s1);
    					long num2 = Long.parseLong(s2);
    					//
    					if(num1 == num2){
    						// 比较下一组
    						continue;
    					} else {
    						return (int)(num1 - num2);
    					}
    				} else {
    					break;
    				}
    			} else {
    				break;
    			}
    		}
    		
    		// 最后的情形.
    		return this.name.compareTo(wrapper.name);
    	}
    	
    
    	public static void testNew(){
    		List<OrderWrapper> chinesesOrderList = new ArrayList<OrderWrapper>();  
            chinesesOrderList.add(new OrderWrapper("我们80后相亲奇遇记-1.mp3"));  
            chinesesOrderList.add(new OrderWrapper("他80后相亲奇遇记-10.mp3"));  
            chinesesOrderList.add(new OrderWrapper("我80后相亲奇遇记-11.mp3"));  
            chinesesOrderList.add(new OrderWrapper("啊80后相亲奇遇记-12.mp3"));  
            chinesesOrderList.add(new OrderWrapper("我80后相亲奇遇记-13.mp3"));  
            chinesesOrderList.add(new OrderWrapper("我80后相亲奇遇记-25.mp3"));  
            chinesesOrderList.add(new OrderWrapper("我80后相亲奇遇记-26.mp3"));  
            chinesesOrderList.add(new OrderWrapper("我80后相亲奇遇记-2.mp3"));  
            chinesesOrderList.add(new OrderWrapper("我80后相亲奇遇记-3.mp3"));  
            chinesesOrderList.add(new OrderWrapper("我80后相亲奇遇记-4.mp3"));  
            chinesesOrderList.add(new OrderWrapper("a80后相亲奇遇记-4.mp3"));  
       
            //Collator collatorChinese = Collator.getInstance(java.util.Locale.CHINA);  
            //collatorChinese = Collator.getInstance(java.util.Locale.CHINESE);  
           // Collections.sort(chinesesOrderList, collatorChinese);  
            Collections.sort(chinesesOrderList);  
    
            System.out.println("中文+数字排序: = ");  
            for (int i = 0; i < chinesesOrderList.size(); i++) {  
            	OrderWrapper chinese = chinesesOrderList.get(i);  
                System.out.println("" + chinese);  
            }  
    
    	}
    	
    	public static void main(String[] args) {
    		testNew();
    	}
    }


    展开全文
  • java字符排序

    千次阅读 2019-08-09 19:29:18
    java字符排序 今天收到一个公司的面试邀请,人还没去,直接面试题都发过来了,真仗义啊。哈哈哈,我看了一下面试题,难度还是挺高的,怪不得直接给我。 我大致看了一下关于java方面的面试题,我还是对其中一个编程...

    java字符串排序
    今天收到一个公司的面试邀请,人还没去,直接面试题都发过来了,真仗义啊。哈哈哈,我看了一下面试题,难度还是挺高的,怪不得直接给我。
    我大致看了一下关于java方面的面试题,我还是对其中一个编程题挺感兴趣的,题目如下:
    在这里插入图片描述
    就是对一个无序字符串进行排序,主要难度在怎么处理字母的排序,Arrays类和Collections类提供的排序方法都是大写字母在前的,题目要求的是小写在前。这就是个考点,废话不多说直接上代码:

    
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.LinkedList;
    import java.util.List;
    
    /**
     * 
     * @author 谢辉 2019.8.9
     *
     */
    public class StrSplit {
    	public static void main(String[] args) {
    		System.out.println(sortStr("3Ba1cA"));
    	}
    
    	/**
    	 * 思路:
    	 * 1、先对字符串拆分,进行第一次排序,目的是把数字提取出来
    	 * 2、数字提取出来后利用集合工具类得到排序后的字母(缺点是大写的字母在前,不是想要的结果) 
    	 * 3、利用冒泡排序改变大小写
    	 * 
    	 * @param str
    	 * @return
    	 */
    	public static String sortStr(String str) {
    		// 形参拆分
    		char[] charArray = str.toCharArray();
    		// 存取结果
    		StringBuilder result = new StringBuilder();
    		// 对数组排序:数字、大写字母、小写字母
    		Arrays.sort(charArray);
    
    		int index = 0;
    		// 查找最后一位数字紧挨着的大写字母下标(将会使用该下标截取字符串)
    		// 0的ASCII码是48 9的ASCII码是57
    		for (int i = 0; i < charArray.length; i++) {
    			if (Integer.valueOf(charArray[i]) > 57) {
    				index = i;
    				break;
    			}
    		}
    		// 先截取出所有数字
    		String temp = String.valueOf(charArray);
    		result.append(temp.substring(0, index));
    
    		// 剩下纯字母字符串
    		String newStr = temp.substring(index);
    		// 利用集合对字母数组排序
    		List<String> list = new LinkedList<>();
    		char[] array = newStr.toCharArray();
    		for (char c : array) {
    			list.add(String.valueOf(c));
    		}
    		Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
    		System.out.println(list.toString());// [A, a, B, b, c, d, Z, z]
    
    		// 排序后的字母都是大写的在前面
    		String[] strTemp = new String[list.size()];
    		for (int i = 0; i < strTemp.length; i++) {
    			strTemp[i] = list.get(i);
    		}
    		// 利用冒泡排序进行对比,改变大小写
    		for (int i = 0; i < strTemp.length - 1; i++) {
    			for (int j = 0; j < strTemp.length - 1 - i; j++) {
    				if (strTemp[j].equals(strTemp[j + 1])) {
    					continue;
    				} else if (strTemp[j].equalsIgnoreCase(strTemp[j + 1])) {
    					strTemp[j] = strTemp[j].toLowerCase();
    					strTemp[j + 1] = strTemp[j + 1].toUpperCase();
    				}
    			}
    		}
    
    		// 拼接字符串
    		for (int i = 0; i < strTemp.length; i++) {
    			result.append(strTemp[i]);
    		}
    
    		return result.toString();
    	}
    }
    
    

    在这里插入图片描述
    这个题就算答完了,嗯?答完了?作为程序员要举一反三啊,假如面试官要求:d8A68acD 排序此字符串为688acdAD怎么办?
    有办法继续上代码:

    import java.util.Arrays;
    
    public class A {
    	public static void main(String[] args) {
    		System.out.println(sortStr("36z1ZaBbdc8","aA0"));
    	}
    	
    	/**
    	 * 
    	 * @param str 需要排序的字符串
    	 * @param splitRule 定义的规则:默认是0Aa
    	 * @return 排序后的字符串
    	 * 规则介绍:
    	 * 对于排序规则定义了一个0、A、a三个字符组成的字符串规则,
    	 * 0aA表示数字所有排序后的数字在前面,所有排序后的小写字母在中间,所有大写字母在最后
    	 * 规则有:0Aa(默认)、A0a、0aA、a0A、aA0
    	 */
    	public static String sortStr(String str, String splitRule) {
    		/**
    		 * 思路: 
    		 * 1、把字符串拆开,用Arrays工具类进行排序,排序规则是:数字-大写字母-小写字母 
    		 * 2、根据规则按照ASCII码再次拆分字符串
    		 * 3、第一次拆分是把数字部分拆出来 
    		 * 4、第二次把所有大写字母拆分出来 
    		 * 5、第三次把所有小写字母拆分出来 
    		 * 6、按要求再次拼接
    		 */
    		// 0的ASCII码是48 9的ASCII码是57
    		// A的ASCII码是65 Z的ASCII码是90
    		// a的ASCII码是97 z的ASCII码是122
    
    		// 形参拆分
    		char[] charArray = str.toCharArray();
    		// 存取结果
    		StringBuilder result = new StringBuilder();
    		// 对数组排序:数字、大写字母、小写字母
    		Arrays.sort(charArray);
    		if (null == splitRule || "".equals(splitRule)) {
    			return String.valueOf(charArray);
    		}
    
    		
    		
    		
    		/*
    		 * 开始第一次截取
    		 */
    		int index = 0;
    		// 查找最后一位数字紧挨着的大写字母下标(将会使用该下标截取字符串)
    		for (int i = 0; i < charArray.length; i++) {
    			if (Integer.valueOf(charArray[i]) > 57) {
    				index = i;
    				break;
    			}
    		}
    		// 第一次截取:所有数字
    		String temp = String.valueOf(charArray);
    		// result.append(temp.substring(0, index));
    
    		
    		
    		
    		
    		/*
    		 * 开始第二次截取
    		 */
    		// 该字符串就是去掉数字的字符串了
    		String newStr = temp.substring(index);
    		int index2 = 0;
    		char[] newCharArr = newStr.toCharArray();
    		// 找到最后一个大写字母紧挨着的小写字母下标(使用该下标截取字符串)
    		for (int i = 0; i < newCharArr.length; i++) {
    			if (Integer.valueOf(newCharArr[i]) > 90) {
    				index2 = i;
    				break;
    			}
    		}
    		// 截取到的就是所有小写字母
    		// result.append(newStr.substring(index2));
    		
    		
    		
    		
    		/*
    		 * 开始第三次截取
    		 */
    		// 截取到的就是所有大写字母
    		// result.append(newStr.substring(0, index2));
    
    		String finalResult = "";
    		// 为了程序的扩展性,对一下排序规则做了定义,就是按照规则追加字符串
    		if ("0aA".equals(splitRule)) {
    			result.append(temp.substring(0, index));
    			result.append(newStr.substring(index2));
    			result.append(newStr.substring(0, index2));
    			finalResult = result.toString();
    		} else if ("A0a".equals(splitRule)) {
    			result.append(newStr.substring(0, index2));
    			result.append(temp.substring(0, index));
    			result.append(newStr.substring(index2));
    			finalResult = result.toString();
    		} else if ("aA0".equals(splitRule)) {
    			result.append(newStr.substring(index2));
    			result.append(newStr.substring(0, index2));
    			result.append(temp.substring(0, index));
    			finalResult = result.toString();
    		}else if ("a0A".equals(splitRule)) {
    			result.append(newStr.substring(index2));
    			result.append(temp.substring(0, index));
    			result.append(newStr.substring(0, index2));
    			finalResult = result.toString();
    		}
    		return finalResult;
    
    	}
    }
    

    总之面试官的要求千变万化,解决问题先有思路,然后问题迎刃而解…
    在这里只是分享面试题,希望技术大牛勿喷,谢谢大牛的照顾。同时希望小伙伴们指出错误和不足之处,谢谢大家!

    展开全文
  • * 类描述: 用于带数字字母的字符串混合排序 * 例子:↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓...

    * 类名称:NaturalOrderComparator   
    * 类描述:   用于带数字字母的字符串混合排序
    * 例子:↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
    * 排序前:V1FJX_6,V1FJX_12_8_3_1,V1FJX_12_8_3,V1FJX_12_8,V1FJX_12,V1FJX_12_2,V1FJX_4,V1FJX_12_4,V1FJX_2,V1FJX_12_6
    * 排序后:V1FJX_2,V1FJX_4,V1FJX_6,V1FJX_12,V1FJX_12_2,V1FJX_12_4,V1FJX_12_6,V1FJX_12_8,V1FJX_12_8_3,V1FJX_12_8_3_1
    * 例子:↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑

    import java.util.*;
    
    /**   
    *     
    * 类名称:NaturalOrderComparator   
    * 类描述:   用于带数字字母的字符串混合排序
    * 例子:↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
    * 排序前:V1FJX_6,V1FJX_12_8_3_1,V1FJX_12_8_3,V1FJX_12_8,V1FJX_12,V1FJX_12_2,V1FJX_4,V1FJX_12_4,V1FJX_2,V1FJX_12_6
    * 排序后:V1FJX_2,V1FJX_4,V1FJX_6,V1FJX_12,V1FJX_12_2,V1FJX_12_4,V1FJX_12_6,V1FJX_12_8,V1FJX_12_8_3,V1FJX_12_8_3_1
    * 例子:↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
    * 创建时间:2020年10月10日 下午5:38:38   
    * @version        
    */
     
    public class NaturalOrderComparator implements Comparator {
        int compareRight(String a, String b) {
            int bias = 0, ia = 0, ib = 0;
     
            // The longest run of digits wins. That aside, the greatest
            // value wins, but we can't know that it will until we've scanned
            // both numbers to know that they have the same magnitude, so we
            // remember it in BIAS.
            for (; ; ia++, ib++) {
                char ca = charAt(a, ia);
                char cb = charAt(b, ib);
     
                if (!isDigit(ca) && !isDigit(cb)) {
                    return bias;
                }
                if (!isDigit(ca)) {
                    return -1;
                }
                if (!isDigit(cb)) {
                    return +1;
                }
                if (ca == 0 && cb == 0) {
                    return bias;
                }
     
                if (bias == 0) {
                    if (ca < cb) {
                        bias = -1;
                    } else if (ca > cb) {
                        bias = +1;
                    }
                }
            }
        }
     
        @Override
        public int compare(Object o1, Object o2) {
            String a = o1.toString();
            String b = o2.toString();
     
            int ia = 0, ib = 0;
            int nza = 0, nzb = 0;
            char ca, cb;
     
            while (true) {
                // Only count the number of zeroes leading the last number compared
                nza = nzb = 0;
     
                ca = charAt(a, ia);
                cb = charAt(b, ib);
     
                // skip over leading spaces or zeros
                while (Character.isSpaceChar(ca) || ca == '0') {
                    if (ca == '0') {
                        nza++;
                    } else {
                        // Only count consecutive zeroes
                        nza = 0;
                    }
     
                    ca = charAt(a, ++ia);
                }
     
                while (Character.isSpaceChar(cb) || cb == '0') {
                    if (cb == '0') {
                        nzb++;
                    } else {
                        // Only count consecutive zeroes
                        nzb = 0;
                    }
     
                    cb = charAt(b, ++ib);
                }
     
                // Process run of digits
                if (Character.isDigit(ca) && Character.isDigit(cb)) {
                    int bias = compareRight(a.substring(ia), b.substring(ib));
                    if (bias != 0) {
                        return bias;
                    }
                }
     
                if (ca == 0 && cb == 0) {
                    // The strings compare the same. Perhaps the caller
                    // will want to call strcmp to break the tie.
                    return compareEqual(a, b, nza, nzb);
                }
                if (ca < cb) {
                    return -1;
                }
                if (ca > cb) {
                    return +1;
                }
     
                ++ia;
                ++ib;
            }
        }
     
        static boolean isDigit(char c) {
            return Character.isDigit(c) || c == '.' || c == ',';
        }
     
        static char charAt(String s, int i) {
            return i >= s.length() ? 0 : s.charAt(i);
        }
     
        static int compareEqual(String a, String b, int nza, int nzb) {
            if (nza - nzb != 0) {
                return nza - nzb;
            }
     
            if (a.length() == b.length()) {
                return a.compareTo(b);
            }
     
            return a.length() - b.length();
        }
     
        public static void main(String[] args) {
                
            String[] strings = new String[]{"V1FJX_6","V1FJX_12_8_3_1","V1FJX_12_8_3", "V1FJX_12_8","V1FJX_12", "V1FJX_12_2", "V1FJX_4", "V1FJX_12_4","V1FJX_2", "V1FJX_12_6"};
     
            List scrambled = Arrays.asList(strings);
            Collections.shuffle(scrambled);
            Collections.sort(scrambled, new NaturalOrderComparator());
            System.out.println("排序后: " + scrambled);
    
        }
    
    }

     

    展开全文
  • 可对百万级的数字字符串进行整数排序,可能需要增加java虚拟机内存,可能比快速排序快点,请大家测试后回复,:)
  • JAVA字符排序去重

    2019-08-26 14:23:39
    JAVA字符排序去重 场景问题:在DB中我们可能会对数据的ID进行拼接,有时会存在部分ID相同的情况。此时需要对查询出来的这个拼接数据(type:String)进行去重。 实现:此处采用JAVA8的Stream()操作进行实现,做...

    场景问题:在DB中我们可能会对数据的ID进行拼接,有时会存在部分ID相同的情况。此时需要对查询出来的这个拼接数据(type:String)进行去重。

    实现:此处采用JAVA8的Stream()操作进行实现,做个记录,方便下次使用。

    CODE

    在本业务中拼接的ID数据一般使用",“和”_"作为拼接符,所以code中的delimiter是写死的两种情况,后续待优化。

    去重数据:

    1. String value1 = “aa,bb,cc,aa,dd,ee,aa,”
    2. String value2 = “12_15_30_12_100_1_58_90_210”
      》执行结果如下:
      1) “aa,bb,cc,dd,ee”
      2) “1_12_15_30_58_90_100_210”
    
    private String removeDuplicateData(String value) {
    		//工具类判断字符串非空
    		if (CommonUtil.isEmptyString(value)) {
    			retun null;
    		}
    		String delimiter = value.contains("_") ? "_":",";
    		String lastCharacter = value.substring(value.length()-1);
    		if (lastCharacter.equals(delimiter)) {
    			value = value.substring(0,value.length()-1);
    		}
    		if (value.equals(delimiter)) {
    			return null;
    		}
    		List<String> targetList = Arrays.asList(value.split(delimiter));
    		//JAVA8的stream()操作,sorted()用来排序,distinct()用来去重
    		return targetList.stream().sorted(Comparator.comparing(String::hashCode)).distinct().collect(Collectors.joining(delimiter));		
    	}
    

    这个方法由于在业务中侧重对数字字符串进行去重排序,字符的排序建议自己测试通过后再进行使用。

    展开全文
  • Java数字字符排序

    千次阅读 2020-06-03 17:44:24
    A:案例:我有如下一个字符串:”91 27 46 38 50”,请写代码实现最终输出结果是:”27 38 46 50 91” 分析: ...注意:字符串也可排序,但是按第一位数字比较,故排序前应将String数组转换成int数组
  • Java字符排序过滤
  • PAGE / NUMPAGES Java 字符数字混合list集合排序 排序后样式 关键代码 //sort list List<KpiView> kpiViews = (List) query.execute;个人收集整理 勿做商业用途 ComparatorKpiViewName comparatorKpiViewName = ...
  • import java.util.Arrays; public class demo2 { public static void main(String[] args) { String s = "91 22 67 77 88"; String[] sarr = s.split(" "); int[] arr = new int[sarr.length]; for(int i=0;i...
  • 图片名命名规则: sku-图片数字序号.jpg 或 特殊字符-图片数字序号.jpg 或 中文.图片数字序号.jpg 等等 命名规则很乱,因为获取的是第三方的数据,但是不变的是图片数字序号前面的前缀,不同的sku中间的分隔符可能也会变...
  • java数字字符排序

    千次阅读 2008-09-19 23:44:00
    本打算把字符串转成数字,再用学过的一些排序算法实现,可一想,如此强大的java,这种小小功能应该不用这么复杂的自己折腾。仔细读过书后,发现果真有捷径可走。 我的思路是这样的 1.把字符串读入ArrayList,每个...
  • import java.util.ArrayList;import java.util.Arrays;import java.util.Collections;import java.util.List;/*** 排序算法* 使用三个:numberSort stringSort chineseSort* @author KyLinD http
  • 根据数字部分排序,遇到相同的根据第一部分字母排序。 才自学java三个星期,写了几个小时就写出来上面那一片,现在没有头绪了。 能不能请帮忙改到有正确的输出? 直接加我微信shishunfan2 也行,改完发20红包...
  • Java三种方法实现字符排序

    千次阅读 2021-01-30 21:04:28
    文章目录Java字符排序排序方法概述键索引计数法低位优先的字符串排序(LSD)高位优先的字符串排序(MSD)三向字符串快速排序 排序方法概述 对于许多应用,决定顺序的键都是字符串。本篇讲述如何利用字符串的特殊...
  • Java正则篇-26-编程练习-给定字符数字排序后输出新字符串.pdf
  • Java.lang.Character类 复习一下 这是修正前的排序效果:   这是修正后的排序效果:    完整示例: 以下是排序的部份代码(非全部代码:拼音首字母算法不在其中) import java.util.Arrays;  ...
  • 请对一组字符串进行排序字符串由大小写字母和数字组成,需要满足一下比较规则 长度不同时,长度较短在排前面。 长度相同时,按照字典顺序排列(AaBb-Zz,0-9顺序),即大写字母在小写字母前,数字排在字母后。 ...
  • List<String> location=new ArrayList(); 一行代码轻松搞定混合排序问题 Collections.sort(location, new SortUtils(true));
  • Java 字母数字字符串 混合排序

    千次阅读 2016-12-13 14:44:00
    NaturalOrderComparator.java -- Perform 'natural order' comparisons of strings in Java. Copyright (C) 2003 by Pierre-Luc Paour Based on the C version by Martin Pool, of which this is more or less ...
  • 问题描述 比如我有一字符串"10 50 5 20 36"需要对它进行排序 问题分析 我们一看间我们可能马上就...在将数组中的数字转化为int 排序 再拼接成字符串 代码 String s = "10 50 5 20 36"; Strin...
  • import java.util.*; public class NaturalOrderComparator implements Comparator { int compareRight(String a, String b) { int bias = 0, ia = 0, ib = 0; // The longest run of digits...
  • 这篇来写一个编程练习,题目是在给定的一个字符串中,里面全部是一些数字元素,需要通过代码实现,按照从小到大的数字输出成字符串。 1.题目 在给定的字符串“91 27 46 38 50”,编程实现输出“27 38 46 50 91”...
  • 开发过程中,使用java操作mongo库的时候,排序的时候遇到了排字符串类型的数字的时候会将99排到100的后边,这时候排序就出现了问题,下面呢就让我来解决这个疑惑吧
  • Java数字转换为字符串,字符串转换为字符

    万次阅读 多人点赞 2017-11-20 10:20:41
    java数字字符串相互转化
  • Java实现字符串数组和字符排序

    千次阅读 2014-10-13 14:51:07
    Java环境下,对字符串数组或者对字符排序都是一件很容易的
  • java-区分数字元素和字符串元素的数组排序-代码,希望能帮到大家
  • 要求:如何对一个数字字符串进行排序? eg:“12 45 67 54 34 7 17” 要求:“7 12 17 34 45 54 67” 思路: 第一步:把数字字符串中的数字拿出来,存到String[] 第二步:把String[] 转化成int[] 第三步:用Arrays....
  • //转换成字符串 String str2=d2.toString();//转换成字符串 char[] ch1=str1.toCharArray();//转换成数组 char[] ch2=str2.toCharArray();//转换成数组 for(int i=0;i;i++){ for(int j=0;j;j++){ ...
  • java字符串去重并排序

    千次阅读 2019-03-16 21:44:50
    import java.util.Scanner; import java.util.TreeSet;... * 字符串去重后,排序 * 例:输入aaddbcep * 输出abcdep */ public class Test04 { public static void main(String[] args) { System.out.println...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 110,175
精华内容 44,070
关键字:

java字符数字排序

java 订阅