编写一个程序，从命令行接收一组整数，将它们存储在一个ArrayList中，并将其排序后打印出来。 编写一个程序，从一个文件中读取一组字符串，将它们存储在一个HashSet中，并打印出所有不同的字符串。 编写一个程序，从一个文件中读取一组字符串，将它们存储在一个HashMap中，其中键为字符串，值为出现的次数。然后打印出每个字符串和它出现的次数。 编写一个程序，从一个文件中读取一组字符串，将它们存储在一个TreeMap中，其中键为字符串，值为出现的次数。然后按照出现次数从高到低打印出所有字符串。 编写一个程序，将一个字符串中的单词存储在一个LinkedList中，并打印出它们的反转顺序。写出java代码

好的，以下是这些题目的Java代码实现：

1. 从命令行接收一组整数，将它们存储在一个ArrayList中，并将其排序后打印出来：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class SortArrayList {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        ArrayList<Integer> list = new ArrayList<>();
        System.out.print("请输入一组整数，以空格分隔：");
        String[] input = scanner.nextLine().split(" ");
        for (String str : input) {
            list.add(Integer.parseInt(str));
        }
        Collections.sort(list);
        System.out.println("排序后的结果为：" + list);
    }
}

2. 从一个文件中读取一组字符串，将它们存储在一个HashSet中，并打印出所有不同的字符串：

import java.io.File;
import java.io.FileNotFoundException;
import java.util.HashSet;
import java.util.Scanner;

public class UniqueStrings {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        try {
            Scanner scanner = new Scanner(new File("input.txt"));
            while (scanner.hasNext()) {
                set.add(scanner.next());
            }
            System.out.println("不同的字符串有：" + set);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

3. 从一个文件中读取一组字符串，将它们存储在一个HashMap中，其中键为字符串，值为出现的次数。然后打印出每个字符串和它出现的次数：

import java.io.File;
import java.io.FileNotFoundException;
import java.util.HashMap;
import java.util.Scanner;

public class StringCount {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        try {
            Scanner scanner = new Scanner(new File("input.txt"));
            while (scanner.hasNext()) {
                String str = scanner.next();
                if (map.containsKey(str)) {
                    map.put(str, map.get(str) + 1);
                } else {
                    map.put(str, 1);
                }
            }
            for (String str : map.keySet()) {
                System.out.println(str + " 出现了 " + map.get(str) + " 次");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

4. 从一个文件中读取一组字符串，将它们存储在一个TreeMap中，其中键为字符串，值为出现的次数。然后按照出现次数从高到低打印出所有字符串：

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

public class StringCountSort {
    public static void main(String[] args) {
        TreeMap<String, Integer> map = new TreeMap<>();
        try {
            Scanner scanner = new Scanner(new File("input.txt"));
            while (scanner.hasNext()) {
                String str = scanner.next();
                if (map.containsKey(str)) {
                    map.put(str, map.get(str) + 1);
                } else {
                    map.put(str, 1);
                }
            }
            Map<Integer, String> reverseMap = new TreeMap<>(Collections.reverseOrder());
            for (String str : map.keySet()) {
                reverseMap.put(map.get(str), str);
            }
            for (Integer count : reverseMap.keySet()) {
                System.out.println(reverseMap.get(count) + " 出现了 " + count + " 次");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

5. 将一个字符串中的单词存储在一个LinkedList中，并打印出它们的反转顺序：

import java.util.LinkedList;
import java.util.Scanner;

public class ReverseWords {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个字符串：");
        String str = scanner.nextLine();
        LinkedList<String> list = new LinkedList<>();
        for (String word : str.split(" ")) {
            list.addFirst(word);
        }
        System.out.println("反转后的单词顺序为：" + list);
    }
}

希望这些代码能够帮助您练习Java集合的使用。