937. 重新排列日志文件

1. 题目描述

给你一个日志数组 logs。每条日志都是以空格分隔的字串，其第一个字为字母与数字混合的 标识符 。

有两种不同类型的日志：

• 字母日志：除标识符之外，所有字均由小写字母组成
• 数字日志：除标识符之外，所有字均由数字组成

请按下述规则将日志重新排序：

• 所有 字母日志 都排在 数字日志 之前。
• 字母日志 在内容不同时，忽略标识符后，按内容字母顺序排序；在内容相同时，按标识符排序。
• 数字日志 应该保留原来的相对顺序。
  返回日志的最终顺序。

示例 1：

输入：logs = ["dig1 8 1 5 1","let1 art can","dig2 3 6","let2 own kit dig","let3 art zero"]
输出：["let1 art can","let3 art zero","let2 own kit dig","dig1 8 1 5 1","dig2 3 6"]
解释：
字母日志的内容都不同，所以顺序为 "art can", "art zero", "own kit dig" 。
数字日志保留原来的相对顺序 "dig1 8 1 5 1", "dig2 3 6" 。

示例 2：

输入：logs = ["a1 9 2 3 1","g1 act car","zo4 4 7","ab1 off key dog","a8 act zoo"]
输出：["g1 act car","a8 act zoo","ab1 off key dog","a1 9 2 3 1","zo4 4 7"]

提示：

• 1 <= logs.length <= 100
• 3 <= logs[i].length <= 100
• logs[i] 中，字与字之间都用 单个 空格分隔
• 题目数据保证 logs[i] 都有一个标识符，并且在标识符之后至少存在一个字

2. 题目代码

public class Solution {
    public String[] reorderLogFiles(String[] logs) {
        //存储数字日志
        ArrayList<String> nums = new ArrayList<>();
        //存储字母日志
        ArrayList<String> strs = new ArrayList<>();
        //分隔字母和数字日志
        for (int i = 0; i < logs.length; i++) {
            char c = logs[i].charAt(logs[i].length() - 1);
            if (Character.isDigit(c)) nums.add(logs[i]);
            else strs.add(logs[i]);
        }
        //按照规则排序排序
        Collections.sort(strs, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //将字符串按照空格分隔
                String[] s1 = o1.split(" ",2);
                String[] s2 = o2.split(" ",2);
                if (s1[1].compareTo(s2[1]) > 0)
                    return 1;
                else if(s1[1].compareTo(s2[1]) == 0){
                    if (s1[0].compareTo(s2[0]) > 0)
                        return 1;
                    else
                        return -1;
                }else return -1;
            }
        });
        //填入数据
        int index = 0;
        for (int i = 0; i < logs.length; i++) {
            if (i < strs.size()) logs[i] = strs.get(i);
            else logs[i] = nums.get(index++);
        }
        return logs;
    }
}

3. 知识点

1. compareTo() 方法

public static void main(String args[]) {
    String str1 = "Strings";
    String str2 = "Strings";
    String str3 = "Strings123";

    int result = str1.compareTo( str2 );
    System.out.println(result);
  
    result = str2.compareTo( str3 );
    System.out.println(result);
 
    result = str3.compareTo( str1 );
    System.out.println(result);
    }

运行结果

0
-3
3

返回值是整型。

• 如果参数字符串等于此字符串，则返回值 0；
• 如果此字符串小于字符串参数，则返回一个小于 0 的值；
• 如果此字符串大于字符串参数，则返回一个大于 0 的值。

2. Collections的使用

//对于Collections常见方法进行测试
public static void main(String[] args) {
    //创建ArrayList集合进行测试
    List<String> list = new ArrayList<>();
    list.add("tom");
    list.add("mike");
    list.add("lucy");
    list.add("jack");
    list.add("smith");

    //1. reverse(list)：反转 List 中的元素顺序
    Collections.reverse(list);
    System.out.println(list); //[smith, jack, lucy, mike, tom]
    //2. shuffle(list)：对于 List 集合中的元素进行随机排序
    for (int i = 0; i < 5; i++) {
        Collections.shuffle(list);
        System.out.println(list);
    }
    /*
    [lucy, tom, mike, smith, jack]
    [jack, lucy, mike, smith, tom]
    [smith, tom, lucy, mike, jack]
    [tom, lucy, smith, jack, mike]
    [smith, lucy, jack, tom, mike]
     */
    //3. sort(list)：根据元素的自然顺序对List集合进行升序排序
    Collections.sort(list);
    System.out.println(list); //[jack, lucy, mike, smith, tom]
}

3. 自定义排序

class Student {
    private int age;
    private String name;

    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

public class TestSort {
    public static void main(String[] args) {
        //创建测试用例
        List list = new ArrayList<Student>();
        list.add(new Student(21,"tom"));
        list.add(new Student(21,"jack"));
        list.add(new Student(20,"smith"));
        list.add(new Student(22,"mike"));
        list.add(new Student(19,"lucy"));

        //4. sort(List<T> list, Comparator<? super T> c)：定制排序
        //先按照年龄排序，若年龄相同，则按照姓名排序
        Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                if (o1.getAge() > o2.getAge())
                    return 1;
                else if(o1.getAge() == o2.getAge()){
                    if(o1.getName().compareTo(o2.getName()) > 0)
                        return 1;
                    else return -1;
                }else return -1;

            }
        });
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        /*
        Student{age=19, name='lucy'}
        Student{age=20, name='smith'}
        Student{age=21, name='jack'}
        Student{age=21, name='tom'}
        Student{age=22, name='mike'}
        * */
    }
}

4. split函数的用法

public String[] split(String regex, int limit)

参数

• regex – 正则表达式分隔符。
• limit – 分割的份数。

4. 参考

https://leetcode-cn.com/problems/reorder-data-in-log-files/

https://www.runoob.com/java/java-string-compareto.html

https://www.runoob.com/java/java-string-split.html