精华内容
下载资源
问答
  • 在尝试根据元素字符串长度对数组进行排序时,我遇到了编译错误.我有一套开始,Set arraycat = new HashSet();//add contents to arraycatString[] array = arraycat.toArray(new String[0]);//array looks like this ...

    在尝试根据元素字符串长度对数组进行排序时,我遇到了编译错误.我有一套开始,

    Set arraycat = new HashSet();

    //add contents to arraycat

    String[] array = arraycat.toArray(new String[0]);

    //array looks like this now:

    //array=[cat,cataaaa,cataa,cata,cataaa]

    我理想的想要排序

    array=[cat,cata,cataa,cataaa,cataaaa]

    所以我有一个类型的比较器

    class comp implements Comparator {

    public int compare(String o1, String o2) {

    if (o1.length() > o2.length()) {

    return 1;

    } else if (o1.length() < o2.length()) {

    return -1;

    } else {

    return 0;

    }

    }

    }

    然后我打电话给上课

    Collections.sort(array, new comp());

    但是,它抛出了两个编译错误:

    comp is not abstract and does not override abstract method compare(java.lang.Object,java.lang.Object) in java.util.Comparator

    class comp implements Comparator {

    ^

    testa.java:59: cannot find symbol

    symbol : method sort(java.lang.String[],comp)

    location: class java.util.Collections

    Collections.sort(array, new comp());

    ^2 errors

    我很感激任何解决问题的线索.

    展开全文
  • 字符串+连续数字 组合排序 ComparatorUtil .java package com.xx.common.util; import cn.hutool.core.collection.CollUtil; import cn.hutool.core.collection.CollectionUtil; import ...

    字符串+连续数字  组合排序 

    目前只有数字排序需求  有其他需求需要自己再完善

    ComparatorUtil .java

    package com.xx.common.util;
    
    import cn.hutool.core.collection.CollUtil;
    import cn.hutool.core.collection.CollectionUtil;
    import cn.hutool.core.util.StrUtil;
    
    import java.math.BigDecimal;
    import java.text.Collator;
    import java.util.ArrayList;
    import java.util.Comparator;
    import java.util.List;
    import java.util.Locale;
    
    /**
     * 功能描述: 排序比较工具类
     *
     * @author Administrator
     * @date 2021/8/14
     */
    public class ComparatorUtil {
    
        
        public static void main(String[] args) {
            List<String> collect = CollectionUtil.newArrayList("产品-2","产品-11-后缀","产品-001","产品002","产品13后缀","产品14后缀","产品15后缀","产品16后缀","产品17后缀","产品18后缀","产品19后缀","产品2","产品20后缀","产品-3","产品4","产品5","产品6后缀","产品7后缀","产品8后缀","产品9后缀");
            collect.sort((o1,o2)->{ //分段比较
                return compare(o1,o2);
            });
            collect.forEach(System.out::println);
        }
    
        static Comparator<Object> compare = Collator.getInstance(Locale.CHINA);
        /**
         * 字符串比较 不同类型分段比较   正序
         * 顺序 比较结果
         * @param o1
         * @param o2
         * @return
         */
        public static int compare(String o1,String o2){
            // ---------  把字符串 按不同类型 分割成字符串数组
            String[] split1 = joinSp(o1).split("-");
            String[] split2 = joinSp(o2).split("-");
            for (int i = 0; i < split1.length; i++) {
                if(StrUtil.isBlank(split2[i])){ //短的字符 往前放
                    return -1;
                }
                int result = 0;
                // ------------------------- 排序逻辑
                if(split1[i].matches("\\d*")&&split2[i].matches("\\d*")){ //数字比较
                    result= (StrUtil.isBlank(split1[i])?new BigDecimal(0):new BigDecimal(split1[i])).compareTo(new BigDecimal(split2[i]));
                }else{ //字符比较
                    result=compare.compare(split1[i],split2[i]);
                }
                if(result!=0){ //如果不是0  返回结果
                    return result;
                }
            }
            return compare.compare(o1,o2);
        }
    
        /**
         * 分割不同字符类型加上-
          TODO 待优化 是否能用正则实现
         * @param str
         * @return
         */
        public static String joinSp(String str){
            ArrayList<String> strArr = CollUtil.newArrayList(str.split(""));
            int strType = 0;
            StringBuilder sb = new StringBuilder("");
            for (int i = 0; i<strArr.size();i++) {
                String next = strArr.get(i);
                int tempType = 0;
                if(next.matches("\\d")){ //数字
                    tempType=1;
                }else if(next.matches("\\w")){ //字符
                    tempType=2;
                }
                if(tempType!=strType&&i!=0&&!strArr.get(i-1).equals("-")){ //如果类型发生改变 并且 上一个字符不是- 就加上-
                    sb.append("-");
                }
                sb.append(next);
                strType=tempType;
            }
            return sb.toString();
        }
    }
    

    maven hutool

     <dependency>
      <groupId>cn.hutool</groupId>
      <artifactId>hutool-core</artifactId>
      <version>5.7.2</version>
      <scope>compile</scope>
    </dependency>


     

    展开全文
  • 展开全部排序么?importjava.text.Format;importjava.text.SimpleDateFormat;importjava.util.ArrayList;importjava.util.Collections;importjava.util.Comparator;importjava.util.Date;importjava.util.List;public...

    展开全部

    排序么?import java.text.Format;

    import java.text.SimpleDateFormat;

    import java.util.ArrayList;

    import java.util.Collections;

    import java.util.Comparator;

    import java.util.Date;

    import java.util.List;

    public class Test {

    public static void main(String args[]) {

    System.out.println("字符串比32313133353236313431303231363533e4b893e5b19e31333332626631较");

    test1();

    System.out.println("Date比较");

    test2();

    }

    private static void test1() {

    List data = init();

    System.out.println("排序前" + data);

    Collections.sort(data, new Comparator() {

    public int compare(String o1, String o2) {

    String[] arr1 = o1.split("_");

    String[] arr2 = o2.split("_");

    int comparator = toInt(arr1[0], -1) - toInt(arr2[0], -2);

    if (comparator == 0) {

    comparator = toInt(arr1[1], -1) - toInt(arr2[1], -2);

    if (comparator == 0) {

    return toInt(arr1[2], -1) - toInt(arr2[2], -2);

    }

    }

    return comparator;

    }

    });

    System.out.println("排序后" + data);

    }

    private static void test2() {

    List data = init();

    System.out.println("排序前" + data);

    final Format f = new SimpleDateFormat("yyyy-MM-dd");

    Collections.sort(data, new Comparator() {

    public int compare(String o1, String o2) {

    Date d1;

    Date d2;

    try {

    d1 = (Date) f.parseObject(o1);

    d2 = (Date) f.parseObject(o2);

    return d1.compareTo(d2);

    } catch (Exception e) {

    e.printStackTrace();

    }

    return 0;

    }

    });

    System.out.println("排序后" + data);

    }

    private static List init() {

    List data = new ArrayList();

    data.add("2013-3-3");

    data.add("2012-4-4");

    return data;

    }

    private static int toInt(String str, int delVal) {

    try {

    return Integer.parseInt(str);

    } catch (Exception e) {

    return delVal;

    }

    }

    }

    字符串比较

    排序前[2013-3-3, 2012-4-4]

    排序后[2012-4-4, 2013-3-3]

    Date比较

    排序前[2013-3-3, 2012-4-4]

    排序后[2012-4-4, 2013-3-3]

    展开全文
  • Java三种方法实现字符串排序

    千次阅读 2021-01-30 21:04:28
    文章目录Java字符串排序排序方法概述键索引计数法低位优先的字符串排序(LSD)高位优先的字符串排序(MSD)三向字符串快速排序 排序方法概述 对于许多应用,决定顺序的键都是字符串。本篇讲述如何利用字符串的特殊...

    Java字符串排序


    排序方法概述

    对于许多应用,决定顺序的键都是字符串。本篇讲述如何利用字符串的特殊性质来对其进行高效的排序。

    第一类方法会从右到左检查键中的字符。这种方法一般被称为低位优先Least-Significant-DigitFirstLSD)的字符串排序。如果将一个字符串看做一个256进制的数字,那么从右向左检查字符串就等价于先检查数字的最低位。这种方法最适合用于键的长度都相同的字符串排序应用。

    第二类方法会从左到右检查键中的字符,首先查看的是最高位的字符。这种方法通常称为高位优先MSD)的字符串排序。高位优先的字符串排序和快速排序类似,因为它们都会将需要排序的数组切分为独立的部分并递归地用相同的方法处理子数组来完成排序。它们的区别之处在于高位优先的字符串排序算法在切分时仅使用键的第一个字符,而快速排序的比较则会涉及键的全部。

    第三种方法是高位优先的字符串排序算法的改进快速排序,根据键的首字母进行三向切分,仅在中间子数组中的下一个字符(因为键的首字母都与切分字符相等)继续递归排序。

    键索引计数法

    作为热身,我们先学习一种适用于小整数键的简单排序方法。这种叫做键索引计数的方法本身就很实用,同时也是要学习的三种排序算法中前两种的基础。它其实就桶计数

    现在来情景引入,老师在统计学生的分数时可能会遇到以下数据处理问题。学生被分为若干组,标号为1、2、3、4等。在某些情况下,我们希望将全班同学按组分类。因为组的编号是较小的整数,使用键索引计数法来排序时很合适的。假设数组a[]中的每个元素都保存了一个名字和一个组号,其中组号在0到R-1之间,代码a[i].key()会返回指定学生的组号。四个步骤见代码

    int N = a.length;
    int R = 256;    //R为字符基数
    
    String[] aux = new String[N];
    int[] count = new int[R + 1];
    
    //计算出现频率
    for (int i = 0; i < N; i++) 
        count[a[i].key() + 1]++;
    
    //将频率转换为索引
    for (int r = 0; r < R; r++) 
        count[r + 1] += count[r];
    
    //将元素分类
    for (int i = 0; i < N; i++) 
        aux[count[a[i].key()]++] = a[i];
    
    //回写
    for (int i = 0; i < N; i++)
        a[i] = aux[i];
    

    命题A:键索引计数法排序N个键为0R-1之间的整数的元素需要访问数组11N+4R+1

    低位优先的字符串排序(LSD)

    如果字符串的长度均为W,那就从右向左以每个位置的字符作为键,用键索引计数法将字符串排序W遍。

    命题B:低位优先的字符串排序算法能够稳定地将定长字符串排序

    class LSD{
    	// Least-Significant-Digit First
    	//低位优先的字符串排序(基数排序)
    	public static void sort(String[] a, int W) {
    		//通过前W个字符将a[]排序
    		int N = a.length;
    		int R = 256;    //基数
    		String[] aux = new String[N];  //辅助数组\
    
    		for(int d = W - 1; d >= 0; d--) {
    			//根据第d个字符用键索引计数法排序
    			int[] count = new int[R + 1];   
    			//计算出现频率
    			for (int i = 0; i < N; i++)
    				count[a[i].charAt(d) + 1]++;
    			//将频率转换为索引
    			for (int r = 0; r < R; r++)
    				count[r + 1] += count[r];
    			//将元素分类
    			for (int i = 0; i < N; i++) 
    				aux[count[a[i].charAt(d)]++] = a[i];
    			//回写
    			for (int i = 0; i < N; i++) 
    				a[i] = aux[i];
    		}
    	}
    }
    

    在许多字符串排序的应用中,键的长度可能互不相同。改进后的低位优先的字符串排序是可以适应这些情况的。下来讲解两种处理变长键排序的算法

    高位优先的字符串排序(MSD)

    首先用键索引计数法将所有字符串按照首字母排序,然后(递归地)再将每个首字母所对应的子数组排序(忽略首字母,因为每一类中的所有首字母都是相同的)。和快速排序一样,高位优先的字符串排序会将数组切分为能够独立排序的子数组来完成排序任务,但它的切分会为每个首字母得到一个子数组,而不是像快速排序中那样产生固定的两个或者三个切分。

    在高位优先的字符串排序算法中,要特别注意到达字符串末尾的情况。在排序中,合理的做法是将所有字符都已被检查过的字符串所在的子数组排在所有子数组的前面,这样就不需要递归地将该子数组排序。为了简化这两步计算,我们使用了一个接受两个参数的私有方法charAt()来将字符串中字符索引转化为数组索引,当指定的位置超过了字符串末尾时该方法返回-1,。然后将所有返回值加1,得到一个非负的int值并用它作为count[]的索引。这种转换意味着字符串中的每个字符都可能产生R+1种不同的值:0表示字符串的结尾,1表示字符串的第一个字符,2表示字符串的第二个字符,等等。因为建索引计数法本来就需要一个额外的位置,所以使用代码int count[] = new int[R + 2]

    class MSD{
    	//高位优先的字符串排序
    	private static int R = 256;      //基数
    	private static final int M = 15; //小数组的切换阈值
    	private static String[] aux;     //数组分类的辅助数组
    	private static int charAt(String s, int d) {
    		if(d < s.length()) {
    			return s.charAt(d);
    		}else {
    			return -1;
    		}
    	}
    	public static void sort(String[] a) {
    		int N = a.length;
    		aux = new String[N];
    		sort(a, 0, N - 1, 0);
    	}
    	private static void sortInsert(String[] a, int lo, int hi) {
    		//小型数组进行插入排序
    		for (int i = lo + 1; i <= hi; i++) {
    			for(int j = i; j > lo && a[j].compareTo(a[j - 1]) < 0; j--) {
    				String tmp = a[j];
    				a[j] = a[j - 1];
    				a[j - 1] = tmp;
    			}
    		}
    	}
    	private static void sort(String[] a, int lo, int hi, int d) {
    		//以第d个字符为键将a[lo]至a[hi]排序
    		if(hi <= lo + M) {
    			sortInsert(a, lo, hi);
    			return; 
    		}
    		int [] count = new int[R + 2];    //计算频率
    		for(int i = lo; i <= hi; i++) {
    			count[charAt(a[i], d) + 2]++;
    		}
    		for(int r = 0; r < R + 1; r++) {  //将频率转换为索引
    			count[r + 1] += count[r];
    		}
    		for(int i = lo; i <= hi; i++) {   //数据分类
    			aux[count[charAt(a[i], d) + 1]++] = a[i];
    		}
    		for(int i = lo; i <= hi; i++) {   //回写
    			a[i] = aux[i - lo]; 
    		}
    		//递归的以每个字符为键进行排序
    		for(int r = 0; r <R; r++) {
    			sort(a, lo + count[r], lo + count[r + 1] - 1, d + 1);
    		}
    	}
    }
    

    三向字符串快速排序

    我们也可以根据高位优先的字符串排序算法改进快速排序,根据键的首字母进行三向切分,仅在中间子数组的下一个字符(因为键得出首字母都与切分字母相同)继续递归排序。这个算法的实现并不困难,参考往期排序算法中的三向切分快排即可。

    尽管排序的方式有所不同,但三向字符串快速排序根据的仍然是键的首字母并使用递归的方法将其余部分排序。对于字符串的排序,这个方法比普通的快速排序和高位优先的字符串排序更友好。实际上,它就是两种算法的结合。

    三向字符串快速排序只将数组切分为三部分,因此当相应的高位优先的字符串排序产生的非空切分较多时,它需要移动的数据量就会变大,因此它需要进行一系列的三向切分才能够取得多向切分的效果。但是,高位优先的字符串排序可能会创建大量(空)子数组,而三向字符串快速排序的切分总是只有三个。因此三向字符串快速排序能够很好地处理等值键、有较长公共前缀的键、取值范围较小的键和小数组-----所有高位优先的字符串排序算法不擅长的各种情况。

    class Quick3string{
    	//三向字符串快速排序
    	private static int charAt(String s, int d) {
    		if(d < s.length()) {
    			return s.charAt(d);
    		}
    		return -1;
    	}
        
    	public static void sort(String[] a) {
    		sort(a, 0, a.length - 1, 0);
    	}
        
    	private static void sort(String[] a, int lo, int hi, int d) {
    		if(hi <= lo) {
    			return;
    		}
    		int lt = lo, gt = hi, i = lo + 1;
    		int v = charAt(a[lo], d);
    		while(i <= gt) {
    			int t = charAt(a[i], d);
    			if(t < v) {
    				exch(a, lt++, i++);
    			}else if(t > v) {
    				exch(a, i, gt--);
    			}else {
    				i++;
    			}
    		}
    		//a[lo..lt-1] < v = a[lt..gt] < a[gt+1..hi]
    		sort(a, lo, lt - 1, d);
    		if(v >= 0) {
    			sort(a, lt, gt, d + 1);
    		}
    		sort(a, gt + 1, hi, d);
    	}
        
    	private static void exch(String[] a, int i, int j) {
    		String t = new String(a[i]);
    		a[i] = a[j];
    		a[j] = t;
    	}
    }
    

    在将字符串数组a[]排序时,根据它们的首字母进行三向切分,然后(递归地)将得到的三个子数组排序:一个含有所以首字母小于切分字符的字符串子数组,一个含有所以首字母等于切分字符串的子数组(排序时忽略它们的首字母),一个含有所有首字母大于切分字符的字符串的子数组。


    参考资料:《算法》第四版

    展开全文
  • 我有一个字符串值的数组列表ArrayList datestring=new ArrayList();datestring.add("01/21/2013 @03:13 PM");datestring.add("01/21/2013 @04:37 PM");datestring.add("01/21/2013 @10:41 AM");datestring.add("01/...
  • 实体import java.text.Collator;import java.util.Locale;public class Language implements Comparable{private String language;private String abbreviation;public Language(String language,String ...
  • 介绍字符串Java中的特殊。我们在Java程序中定期使用String,因此比较两个字符串Java中的一种常见做法。在本文中,我试图回答有关字符串的最常见问题,例如:“如何比较Java中的字符串?”在身份验证,排序,...
  • JAVA---字符串按照字典排序

    千次阅读 2021-02-12 19:28:13
    //字符串按照字典排序 import java.util.Arrays; import java.util.Collections;public class Demo7 {public static void main(String[] args) {String demos[]={"hello","chenhj","test","中国"}; //方法一 Ar...
  • Java 8 字符串日期排序

    2021-03-09 22:58:51
    ​​​​​​​public static void main(String[] args){List list = new ArrayList()<>;ObjectDto on1 = new ObjectDto();on1.setDate("2018-05-17");ObjectDto on2 = new ObjectDto();on2.seDate("2018-05-...
  • } } 在我实现上面基于规则的collat​​or后,我只是编写了以下排序方法: static void sort(List words) { Collections.sort(words,new Comparator() { @Override public int compare(String lhs,String rhs) { ...
  • 题目描述请对一组字符串进行排序字符串由大小写字母和数字组成,需要满足一下比较规则长度不同时,长度较短在排前面。长度相同时,按照字典顺序排列(AaBb-Zz,0-9顺序),即大写字母在小写字母前,数字排在字母后。...
  • importjava.util.Arrays;public classtest_排序 {public static voidmain(String[] args) {String[] a={"Now","is","the","time","for","all","good","men","to","come","to","the","aid","of","t...
  • 注意,本文不是字符串排序,是字符串数组的排序。方法分别是:1、低位优先键索引排序2、高位优先建索引排序3、java自带排序(经过调优的归并排序)4、冒泡排序5、快速排序6、三向快速排序时间复杂度:最慢的肯定是冒泡...
  • 一、Java比较汉字// Collator 是用来执行区分语言环境的 String 比较的,这里选择使用CHINAComparator cmp = Collator.getInstance(java.util.Locale.CHINA);TreeMap tree=new TreeMap(cmp);String[] arr = {"张三...
  • 我有一个带有两个字段的学生列表(名称和数字),我想按名称(波斯名称)对列表进行排序,但是当我使用Collections.sort对列表进行排序时,某些波斯字母(例如“?”和; “?”和“?”& …???结果是:“?”,“?”,“?”???...
  • java字符串怎么排序

    2021-02-28 09:05:56
    编写应用程序,该中有一个方法sort()(其原型为:void sort(String str[])),从命令行传入多个字符串,调用方法sort()对该字符串数组按字典顺序从小到大排序。代码如下: (推荐学习:java课程)import java.util.*;...
  • Java 随机字符串排序

    2021-03-03 12:08:22
    Java 随机字符串排序package com.xk;import java.util.ArrayList;import java.util.Collections;import java.util.List;import java.util.Random;public class StringSort {public void sort(){List str=new ...
  • java.util.Arrays.sort(charArray); return new String(charArray); } public static void main(String[] args) { String string1 = "Cosmo and Laine:"; String string2 = "Maid, clean soon!"; System.out....
  • 他们可以将字符串添加到数组中,从数组中删除字符串,在数组中搜索字符串,最终他们将能够对数组进行排序排序使我很困惑。我尝试了几种不同的方法。第一种方法是将数组转换为ArrayList并使用Collections对...
  • 试试这个比较,从而消除所有非数字字符然后将其余字符作为数字进行比较:Collections.sort(strings, new Comparator() {public int compare(String o1, String o2) {return extractInt(o1) - extractInt(o2);...
  • 2.32字符串排序2.32.1题目:将字符串按照首字母排序,如果首字母相同则按照第二个字母排序……依次推。2.32.2 源程序public class StringSort {public static void main(String[] args) {String temp = null;...
  • Java中数字字符串排序

    2021-02-12 20:26:44
    本打算把字符串转成数字,再用学过的一些排序算法实现,可一想,如此强大的java,这种小小功能应该不用这么复杂的自己折腾。仔细读过书后,发现果真有捷径可走。我的思路是这样的1.把字符串读入ArrayList,每个字符...
  • /**练习:按照字符串长度排序字符本身具备比较性,但是现在以字符的长度作为比较项*/classTreeSetTest{publicstaticvoidmain(String[]args){TreeSetts=newTreeSet(newMyComparator());ts.add("abc");ts.add("c");ts....
  • 您可以将字符串放在TreeSet中,也可以使用Collections或Arrays进行排序。但是,在您的情况下,您不希望“自然排序”,您真的需要一个自定义比较器,然后您可以在Collections.sort方法或带有比较器的Arrays.sort...
  • 我有一个Person和一些Person,并且有详细信息,因为有名字,年龄段.年龄段间隔为{“0-5”,“6-10”,“11-30”,“31-45”,“46-50”,“50-100”,“100-110”};我有一个Person,其中包含name,ageBand String interval...
  • 你这样做的方式有点复杂(对不起,我甚至没有看过漏洞代码).从你想要的输出,我就是这样做的:我会使用一个Map作为关键字,而不是在下划线后面的部分,而是一个值列表的值.即:当您从行中读取以名称提取名称开头的行时,...
  • 利用冒泡排序字符串二维数组进行排序 package lan; public class array { public static void main(String[] args) { String arr[][]= {{"青年节","5.4"}, {"教师节","9.10"}, {"女生节","3.9"}, {"妇女...
  • Java字符串排序中文和数字的方法在Java中,排序需要复写的是 equals 方法 和 Comparable 接口 的public int compareTo(T o);。下面是小编为大家带来的Java字符串排序中文和数字的方法,欢迎阅读。方法步骤:1. 使用...
  • java字符串混合排序

    2021-08-03 14:28:27
    字符串混合排序对于字符串中存在字母,数字,汉字需要按照自定义规则排序时,如果通过截取字符串的方式可能不够好看,本文通过反射+正则表达式的方式实现 对于字符串中存在字母,数字,汉字需要按照自定义规则排序时,如果...
  • 我试图通过声明我自己的匿名比较器使用Collections.sort对我的自定义数组列表进行排序.但这种方式并没有按预期运作.我的代码是Collections.sort(arrlstContacts, new Comparator() {public int compare(Contacts ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 247,258
精华内容 98,903
关键字:

java类排序比较字符串

java 订阅