Java编程练习之集合

1.产生10个1-100的随机数，并放到一个数组中，把数组中大于等于10的数字放到一个list集合中，并打印到控制台。

public static void main(String[] args) {
        // 生成随机数
        Random r = new Random();
        //创建数组
        int [] arr = new int[10];
        //创建一个List集合
        ArrayList<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < arr.length; i++) {
            //把随机数存进数组
            arr[i] = r.nextInt(100);
            //如果值大于10 执行到这加入集合
            if (arr[i] > 10){
                list.add(arr[i]);
            }
        }
        System.out.println(list);
    }

2.已知数组存放一批QQ号码，QQ号码最长为11位，最短为5位String[] strs = {"12345","67891","12347809933","98765432102","67891","12347809933"}。 将该数组里面的所有qq号都存放在LinkedList中，将list中重复元素删除，将list中所有元素分别用迭代器和增强for循环打印出来。

public class SecondClass {
    public static void main(String[] args) {
        String[] strs = {"12345", "67891", "12347809933", "98765432102", "67891", "12347809933"};
        // 创建数组
        LinkedList<String> list = new LinkedList<String>();
        //将String[]中的QQ号，放到list集合当中
        for(String s : strs){
            list.add(s);
        }
        // 去除LinkedList中的重复元素
        // 利用HashSet去重
        HashSet<String> set = new HashSet<>(list);
        // 清空LinkedList
        list.clear();
        // 将去重后的元素重新放入LinkedList中
        list.addAll(set);

        //遍历集合的两个方法:
        // 使用迭代器打印LinkedList中的元素
        System.out.println("使用迭代器打印LinkedList中的元素:");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        // 使用增强for循环打印LinkedList中的元素
        System.out.println("使用增强for循环打印LinkedList中的元素:");
        for (String s : list) {
            System.out.println(s);
        }
    }
}

3. 分别用Comparable和Comparator两个接口对下列四位同学的成绩做降序排序，如果成绩一样， 那在成绩排序的基础上按照年龄由小到大排序。 

姓名（String）	年龄（int）	分数（float）
刘桑	20	90.0F
李斯	22	90.0F
王武	20	99.0F
孙俪	22	100.0F

编写一个Student类用来实现Comparable<Student>接口,并在其中重写CompareTo(Student o)方法　 在主函数中使用Comparable 与 Comparetor分别对ArrayList进行排序.

public class Student implements Comparable<Student> {
    //public class Student{
    //姓名
    private String name;
    //年龄
    private int age;
    //分数
    private float score;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public float getScore() {
        return score;
    }

    public void setScore(float score) {
        this.score = score;
    }

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

    // 实现 compareTo 方法，按照成绩降序，成绩相同时按照年龄升序
    public int compareTo(Student o) {
        // 首先按照成绩降序排序
        if (this.score != o.score) {
            return Float.compare(o.score, this.score); // 降序排序
        } else {
            // 如果成绩相同，按照年龄升序排序
            return Integer.compare(this.age, o.age);
        }
    }

    // toString 方法，方便输出
    @Override
    public String toString() {
        return
                "name='" + name + '\'' +
                        ", age=" + age +
                        ", score=" + score;
    }
}

//public class Main implements Comparator<Student> {
    public class Main {
    public static void main(String[] args) {
        // 创建学生列表
        ArrayList<Student> S = new ArrayList<>();
        S.add(new Student("刘桑", 20, 90.0F));
        S.add(new Student("李斯", 22, 90.0F));
        S.add(new Student("王武", 20, 99.0F));
        S.add(new Student("孙俪", 22, 100.0F));

        //使用 Comparable 接口排序（按照成绩降序，成绩相同时按照年龄升序）
        Collections.sort(S);
        for (int i = 0; i < S.size(); i++) {
            Student student = S.get(i);
            System.out.println(student);
        }
        // 使用Comparator进行降序排序，成绩相同按年龄升序
//        Comparator<Student> scoreComparator = new Comparator<Student>() {
//            @Override
//            public int compare(Student s1, Student s2) {
//                // 比较分数，降序
//                if (Float.compare(s2.getScore(), s1.getScore()) != 0) {
//                    return Float.compare(s2.getScore(), s1.getScore());
//                }
//                // 如果分数相同，按年龄升序
//                return Integer.compare(s1.getAge(), s2.getAge());
//            }
//        };
//
//        // 使用Comparator进行排序
//        Collections.sort(S, scoreComparator);
//
//        // 打印排序后的学生信息
//        for (Student student : S) {
//            System.out.println(student);
//        }
//    }
    }
}

要注意上诉是两个方法：Comparable 和Comparetor

4. "fdgavcbsacdfs" 获取该字符串中，每一个字母出现的次数。

要求打印结果是：a(2)b(1)...;

public class FourthlyClass {
    public static void main(String[] args) {
        String str = "fdgavcbsacdfs";
        // 定义Map
        Map<Character, Integer> charCountMap = new TreeMap<Character, Integer>();

        // 遍历字符串，统计每个字母出现的次数
        for (char c : str.toCharArray()) {
            if (charCountMap.containsKey(c)) {
                charCountMap.put(c, charCountMap.get(c) + 1);
            } else {
                charCountMap.put(c, 1);
            }
        }

        // 格式化输出结果
        StringBuilder result = new StringBuilder();
        for (Map.Entry<Character, Integer> entry : charCountMap.entrySet()) {
            result.append(entry.getKey()).append("(").append(entry.getValue()).append(")");
        }
        System.out.println(result.toString());
    }
}

5. 选择某种Map集合保存学号从1到15的学员的学号（键）和姓名（值），学号用字符串表示，输入的时候要以学号乱序的方式存入Map集合，然后按照学号从大到小的顺序将Map集合中的元素输出打印。需要自定义Map集合的比较器Comparator，因字符串对象的大小比较是按字典序，而非对应的数值。 要求：必须使用Map集合的内部排序机制进行排序，不能在外部排序。

public class Students {
    public static void main(String[] args) {
        HashMap<String,String> studentsMap = new HashMap<String,String>();
        studentsMap.put("8","love");
        studentsMap.put("10","wiggins");
        studentsMap.put("1","Anthony");
        studentsMap.put("11","Book");
        studentsMap.put("2","Curry");
        studentsMap.put("12","Davis");
        studentsMap.put("3","EdWards");
        studentsMap.put("13","Francis");
        studentsMap.put("4","Giannis");
        studentsMap.put("14","Harden");
        studentsMap.put("5","James");
        studentsMap.put("15","Kobe");
        studentsMap.put("6","Malone");
        studentsMap.put("7","Nash");
        studentsMap.put("9","LeBron");
        // 创建Comparator按照学号从大到小排序
        Comparator<String> comparator = (o1, o2) -> {
            Integer s1 = Integer.parseInt(o1);
            Integer s2 = Integer.parseInt(o2);
            return s2.compareTo(s1); // 从大到小排序
        };

        // 将HashMap的entrySet转换为List进行排序
        List<Map.Entry<String, String>> entryList = new ArrayList<>(studentsMap.entrySet());

        // 使用Comparator进行排序
        entryList.sort(Map.Entry.comparingByKey(comparator));

        // 打印排序后的结果
        System.out.println("按照学号从大到小的顺序输出：");
        for (Map.Entry<String, String> entry : entryList) {
            System.out.println("学号：" + entry.getKey() + ", 姓名：" + entry.getValue());
        }
    }
}

6. 编写一个Book类，该类至少有name和price两个属性。该类要实现Comarable接口，在接口的compareTo（）方法中规定两个Book类实例的大小关系为二者的price属性的大小关系。在主函数中，选择合适的集合类型存放Book类的若干个对象，然后创建一个新的Book类的对象，并检查该对象与集合中的哪些对象相等。查询结果如下：

---

新书：《模式识别》与下列图书：

Java基础教程

数据库技术

C++基础教程

价格相同，具体价格为：29.0元。

public class Book implements Comparable<Book> {
    private String name;
    private double price;

    public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }

    //get 和 set
    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    // 实现 compareTo方法，按价格比较
    @Override
    public int compareTo(Book o) {
        if (this.price < o.price) {
            return -1;
        } else if (this.price > o.price) {
            return 1;
        } else {
            return 0;
        }
    }

    // 重写 toString 方法
    @Override
    public String toString() {
        return name + ": " + price + "元";
    }
}

public class Test {
    public static void main(String[] args) {
        // 创建一个 ArrayList 存放 Book 对象
        ArrayList<Book> books = new ArrayList<>();

        // 添加一些 Book 对象
        books.add(new Book("\t\t\tJava基础教程", 29.0));
        books.add(new Book("\t\t\t数据库技术", 29.0));
        books.add(new Book("\t\t\tC++基础教程", 29.0));
        books.add(new Book("\t\t\tPython编程",35.0));
        books.add(new Book("\t\t\tC程序设计",25.5));

        // 创建一个新的 Book 对象
        Book newBook = new Book("《模式识别》",29.0);

        // 输出新书与集合中的每本书比较的结果
        System.out.println("新书：" + newBook.getName() + " 与下列图书：");
        for (Book book : books) {
            if (newBook.compareTo(book) == 0) {
                System.out.println("\t" + book.getName());
            }
        }
        System.out.println("价格相同，具体价格为：" + newBook.getPrice() + "元。");
    }
}

7. 按照要求定义一个操作类：要求完成一个一维数组操作类，其中可以加入任意类型的数据，数组的具体操作类型由程序外部决定，并且可以实现查询的功能

public class Operations<T> {
    private T[] array;

    //get和set
    public T[] getArray() {
        return array;
    }

    public void setArray(T[] array) {
        this.array = array;
    }

    //构造方法,初始化数组
    public Operations(T[] array) {
        this.array = array;
    }
}