力扣-9.25-524

在这里插入图片描述

方法一：

class Solution {
    
    
    public boolean isSubsequence(String str,String s){
    
    
            int i=0;
            for(int j=0;i<str.length() && j<s.length();j++){
    
    
                if(str.charAt(i)==s.charAt(j)){
    
    
                    i++;
                }
            }
            return i==str.length();
        }

    public String findLongestWord(String s, List<String> d) {
    
    

        Collections.sort(d,new Comparator<String>(){
    
    
            public int compare(String s1,String s2){
    
    
                return s1.length()!=s2.length() ? s2.length()-s1.length() : s1.compareTo(s2);
            }
        });

        for(String str:d){
    
    
            if(isSubsequence(str,s)){
    
    
                return str;
            }
        }
        return "";
    }
}

补充：
Collections.sort
Collections.sort的两种使用方法：
Collections是一个工具类，sort是其中的静态方法，是用来对List类型进行排序的，它有两种参数形式：

public static <T extends Comparable<? super T>> void sort(List<T> list) {
    
    
        list.sort(null);
}

public static <T> void sort(List<T> list, Comparator<? super T> c) {
    
    
        list.sort(c);
}

首先使用基本类型（此处使用Integer）来演示第一个方法：

private static void sortBaseTypeByDefaultMode() {
    
    
        System.out.println("before sort:");
        PrintUtil.showList(intList);
        System.out.println("=========================");
        Collections.sort(intList);
        System.out.println("after sort:");
        PrintUtil.showList(intList);
    }

PrintUtil.showList是自定义的一个打印List类型的方法，此处只关心输出结果就行，如下：
在这里插入图片描述
可以看到，默认的排序是正序，那么如何实现逆序呢，这就要使用第二种方式了，即通过实现Comparator接口的compare方法来完成自定义排序，代码如下：

private static void sortBaseTypeByIDefineMode() {
    
    
        System.out.println("before sort:");
        PrintUtil.showList(intList);
        System.out.println("=========================");
        Collections.sort(intList,new Comparator<Integer>() {
    
    

            @Override
            public int compare(Integer o1, Integer o2) {
    
    
                // 返回值为int类型，大于0表示正序，小于0表示逆序
                return o2-o1;
            }
        });
        System.out.println("after sort:");
        PrintUtil.showList(intList);
    }

在这里插入图片描述
可以看到，已经实现了逆序的排序了。

接下来看看自定义类的排序：
定义一个Emp类：

public class Emp{
    
    
    private int empno;
    private String ename;
    public int getEmpno() {
    
    
        return empno;
    }
    public void setEmpno(int empno) {
    
    
        this.empno = empno;
    }
    public String getEname() {
    
    
        return ename;
    }
    public void setEname(String ename) {
    
    
        this.ename = ename;
    }
    
    public Emp(int empno, String ename) {
    
    
        super();
        this.empno = empno;
        this.ename = ename;
    }
    @Override
    public String toString()
    {
    
    
        return "empno:\t"+empno+"\tename:\t"+ename;
    }
}

首先使用同样的方式来使用Collections.sort方法：
定义泛型违Emp类型的List：

static List<Emp> empList;
static 
{
    
    
    Emp emp1 = new Emp(2,"Guan YunChang");
    Emp emp2 = new Emp(3,"Zhang Fei");
    Emp emp3 = new Emp(1,"Liu Bei");
    empList = Arrays.asList(emp1,emp2,emp3);
}

对empList进行排序：
在这里插入图片描述
此时会报错：
The method sort(List) in the type Collections is not applicable for the arguments (List)
意思是参数类型为List时，sort方法无法执行，原因是泛型没有继承Comparable接口，这种方式稍后再说，我们先使用sort方法的第二种形式：

private static void sortEmpByIDefineMode()
    {
    
    
        System.out.println("before sort:");
        PrintUtil.showList(empList);
        System.out.println("=========================");
        Collections.sort(empList,new Comparator<Emp>() {
    
    

            @Override
            public int compare(Emp o1, Emp o2) {
    
    
                /*按员工编号正序排序*/
                return o1.getEmpno()-o2.getEmpno();
                /*按员工编号逆序排序*/
                //return o2.getEmpno()-o1.getEmpno();
                /*按员工姓名正序排序*/
                //return o1.getEname().compareTo(o2.getEname());
                /*按员工姓名逆序排序*/
                //return o2.getEname().compareTo(o1.getEname());
            }
        });
        System.out.println("after sort:");
        PrintUtil.showList(empList);
    }

在这里插入图片描述
根据不同的排序方式即可呈现不同的结果。

接下来看看第一种形式的实现，首先让Emp类继承Comparable接口并重写compareTo方法（为了和上面的排序方式区别开，此次按照员工姓名逆序排列）：

public class Emp implements Comparable<Emp>{
    
    

    /*属性、getter/setter方法、toString方法及构造方法略*/
    @Override
    public int compareTo(Emp emp) {
    
    
        /*按员工编号正序排序*/
        //return this.getEmpno()-emp.getEmpno();
        /*按员工编号逆序排序*/
        //return emp.getEmpno()-this.getEmpno();
        /*按员工姓名正序排序*/
        //return this.getEname().compareTo(emp.getEname());
        /*按员工姓名逆序排序*/
        return emp.getEname().compareTo(this.getEname());
    }
}

使用Collections.sor方法的第一种形式实现：

private static void sortEmpByDefaultMode()
    {
    
    
        System.out.println("before sort:");
        PrintUtil.showList(empList);
        System.out.println("=========================");
        Collections.sort(empList);
        System.out.println("after sort:");
        PrintUtil.showList(empList);
    }

在这里插入图片描述

总结：

对于String或Integer这些已经实现Comparable接口的类来说，可以直接使用Collections.sort方法传入list参数来实现默认方式（正序）排序；
如果不想使用默认方式（正序）排序，可以通过Collections.sort传入第二个参数类型为Comparator来自定义排序规则；
对于自定义类型(如本例子中的Emp)，如果想使用Collections.sort的方式一进行排序，可以通过实现Comparable接口的compareTo方法来进行，如果不实现，则参考第2点；
jdk1.8的Comparator接口有很多新增方法，其中有个reversed()方法比较实用，是用来切换正序和逆序的，代码如下：

private static void sortEmpByIDefineMode()
    {
    
    
        System.out.println("before sort:");
        PrintUtil.showList(empList);
        System.out.println("=========================");
        Comparator<Emp> comparator = new Comparator<Emp>() {
    
    

            @Override
            public int compare(Emp o1, Emp o2) {
    
    
                /*按员工编号正序排序*/
                return o1.getEmpno()-o2.getEmpno();
                /*按员工编号逆序排序*/
                //return o2.getEmpno()-o1.getEmpno();
                /*按员工姓名正序排序*/
                //return o1.getEname().compareTo(o2.getEname());
                /*按员工姓名逆序排序*/
                //return o2.getEname().compareTo(o1.getEname());
            }
            
        };
        
        /*新的逆序实现方式*/
        Collections.sort(empList,comparator.reversed());
        System.out.println("after sort:");
        PrintUtil.showList(empList);
    }

复写的compare方法定义的是按员工编号正序排序，在使用reversed翻转后结果如下：
在这里插入图片描述
compareTo()

当两个比较的字符串相等时

String a = "abc";
String b = "abc";

返回：num = 0

当两个比较的字符串是英文且长度不等时
2.1长度短的与长度长的字符一样，则返回的结果是两个长度相减的值

a="abc";
b="ab";

返回：num=1;

a="h";
b="hello";

返回：num=4;

2.2长度不一样且前几个字符也不一样,从第一位开始找，当找到不一样的字符时，则返回的值是这两个字符比较的值

a="assdf";
b="bdd";

返回：num=-1;

当两个比较的字符串是英文且长度相等时
3.1一个字符

a="a";   //97
b="b";   //98

返回：num=-1;
3.2多个字符,第一个字符不同则直接比较第一个字符

a="abc";    //a=97
b="ebc";    //e=101

返回：num=-4
3.3多个字符,第一个字符相同则直接比较第二个字符,以此类推

a="bce";   //e=101
b="bca";   //a=97

返回：num=4;

方法儿：
不需要排序

class Solution {
    
    
    public boolean isSubsequence(String str,String s){
    
    
        int i=0;
        for(int j=0;i<str.length() && j<s.length();j++){
    
    
            if(str.charAt(i)==s.charAt(j)){
    
    
                i++;
            }
        }
        return i==str.length();
    }

    public String findLongestWord(String s, List<String> d) {
    
    
        String max_str="";
        for(String str:d){
    
    
            if(isSubsequence(str,s)){
    
    
                if(str.length()>max_str.length() || (str.length()==max_str.length() && str.compareTo(max_str)<0)){
    
    
                    max_str=str;
                }
            }
        }
        return max_str;
    }
}

猜你喜欢