（1）控制台随便输入数字，按 N 输入结束，将输入的数字都存入 LinkedList （2）使用 Collections 对集合排序，并输出（从小到大） （3）使用 Collections 输出集合的最大，最小值 （4）使用 Collections 从排序好的集合里二分查找指定数据，找不到输出“没有这个数 字”,找到则将该数字从集合中移除 （5）将集合序列化到 objs.txt 中 （6）反序列化 objs.txt 得到集合 （6） 使用 Collections 对反序列化得到的集合进行反序，并输出

好的，我会逐个回答你的问题。

首先，关于你的第一个问题，我可以提供以下 Java 代码实现：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        LinkedList<Integer> list = new LinkedList<>();
        while (true) {
            String input = scanner.nextLine();
            if (input.equals("N")) {
                break;
            }
            int num = Integer.parseInt(input);
            list.add(num);
        }
        System.out.println("LinkedList: " + list);
    }
}

这段代码会不断读入用户输入的数字，直到用户输入 N 为止，然后将这些数字存入 LinkedList 中并输出。注意，这里我们使用了 Java 的标准库 `java.util.LinkedList` 实现链表的存储。

接下来，关于你的第二个问题，我们可以使用 Collections.sort() 方法来排序集合，具体的实现代码如下：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        LinkedList<Integer> list = new LinkedList<>();
        while (true) {
            String input = scanner.nextLine();
            if (input.equals("N")) {
                break;
            }
            int num = Integer.parseInt(input);
            list.add(num);
        }
        System.out.println("LinkedList: " + list);
        Collections.sort(list);
        System.out.println("Sorted LinkedList: " + list);
    }
}

这段代码会在读入用户输入并存入 LinkedList 后，使用 Collections.sort() 方法对集合进行排序并输出排序后的结果。

接下来，关于你的第三个问题，我们可以使用 Collections.min() 和 Collections.max() 方法来找到集合中的最小值和最大值，具体的实现代码如下：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        LinkedList<Integer> list = new LinkedList<>();
        while (true) {
            String input = scanner.nextLine();
            if (input.equals("N")) {
                break;
            }
            int num = Integer.parseInt(input);
            list.add(num);
        }
        System.out.println("LinkedList: " + list);
        Collections.sort(list);
        System.out.println("Sorted LinkedList: " + list);
        int minValue = Collections.min(list);
        int maxValue = Collections.max(list);
        System.out.println("Min: " + minValue);
        System.out.println("Max: " + maxValue);
    }
}

这段代码会在读入用户输入并存入 LinkedList 后，使用 Collections.sort() 方法对集合进行排序，并使用 Collections.min() 和 Collections.max() 方法找到集合中的最小值和最大值并输出。

接下来，关于你的第四个问题，我们可以使用 Collections.binarySearch() 方法来在排序好的集合中进行二分查找，具体的实现代码如下：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        LinkedList<Integer> list = new LinkedList<>();
        while (true) {
            String input = scanner.nextLine();
            if (input.equals("N")) {
                break;
            }
            int num = Integer.parseInt(input);
            list.add(num);
        }
        System.out.println("LinkedList: " + list);
        Collections.sort(list);
        System.out.println("Sorted LinkedList: " + list);
        int target = 10; // 假设要查找的数字是 10
        int index = Collections.binarySearch(list, target);
        if (index < 0) {
            System.out.println("没有这个数字");
        } else {
            System.out.println("找到数字 " + target + "，并将其从集合中移除");
            list.remove(index);
            System.out.println("LinkedList: " + list);
        }
    }
}

这段代码会在读入用户输入并存入 LinkedList 后，使用 Collections.sort() 方法对集合进行排序，并使用 Collections.binarySearch() 方法在排序好的集合中查找指定数字（这里假设要查找的数字是 10）。如果找到了该数字，则将其从集合中移除并输出。

接下来，关于你的第五个问题，我们可以使用 Java 的序列化机制将集合序列化到文件中，具体的实现代码如下：

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        Scanner scanner = new Scanner(System.in);
        LinkedList<Integer> list = new LinkedList<>();
        while (true) {
            String input = scanner.nextLine();
            if (input.equals("N")) {
                break;
            }
            int num = Integer.parseInt(input);
            list.add(num);
        }
        System.out.println("LinkedList: " + list);
        Collections.sort(list);
        System.out.println("Sorted LinkedList: " + list);
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("objs.txt"));
        out.writeObject(list);
        out.close();
        System.out.println("Serialized LinkedList to objs.txt");
    }
}

这段代码会在读入用户输入并存入 LinkedList 后，使用 Collections.sort() 方法对集合进行排序，并使用 ObjectOutputStream 将集合序列化到文件 objs.txt 中。

接下来，关于你的第六个问题，我们可以使用 Java 的反序列化机制将文件中的序列化数据恢复成集合，具体的实现代码如下：

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("objs.txt"));
        LinkedList<Integer> list = (LinkedList<Integer>) in.readObject();
        in.close();
        System.out.println("Deserialized LinkedList from objs.txt: " + list);
        Collections.reverse(list);
        System.out.println("Reversed LinkedList: " + list);
    }
}

这段代码会使用 ObjectInputStream 从文件 objs.txt 中读取序列化数据，并将其恢复成 LinkedList 对象。然后，我们使用 Collections.reverse() 方法对集合进行反序，并输出反序后的结果。

以上就是我对你提出的问题的解答，希望能够帮助到你。