Java collection exercise

KaneWork

已于 2024-07-31 15:22:20 修改

阅读量364

点赞数 4

分类专栏： Java 文章标签： java python 开发语言

于 2024-07-31 09:41:39 首次发布

Kane

本文链接：https://blog.csdn.net/qq_57295603/article/details/140814440

版权

Java 专栏收录该内容

9 篇文章 1 订阅

订阅专栏

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

package com.cjc.first;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class First {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            Random random = new Random();
            int num = random.nextInt(100);
            arr[i] = num;
        }
        for (int i = 0; i < arr.length; i++) {
            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循环打印出来。

package com.cjc.second;

import java.util.Iterator;
import java.util.LinkedList;

public class Second {
    public static void main(String[] args) {
        String[] strs = {"12345", "67891", "12347809933", "98765432102", "67891", "12347809933"};
        LinkedList<String> list = new LinkedList<>();
        for (String str : strs) {
            if (!list.contains(str)){
                list.add(str);
            }
        }
        for (String str : list) {
            System.out.println(str);
        }
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

分别用Comparable和Comparator两个接口对下列四位同学的成绩做降序排序，如果成绩一样，那在成绩排序的基础上按照年龄由小到大排序。
姓名（String）年龄（int）分数（float）
刘桑 20 90.0F
李斯 22 90.0F
王武 20 99.0F
孙俪 22 100.0F
编写一个Student类用来实现Comparable接口,并在其中重写CompareTo(Student o)方法　在主函数中使用Comparable 与 Comparetor分别对ArrayList进行排序.

package com.cjc.third;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class third {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<Student>();
        list.add(new Student("刘桑", 20, 90.0F));
        list.add(new Student("李斯", 22, 90.0F));
        list.add(new Student("王武", 20, 99.0F));
        list.add(new Student("孙俪", 22, 100.0F));
        System.out.println("使用Comparable接口排序");
        list.sort(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                if (o1.getFraction() == o2.getFraction())
                    return o1.getAge() - o2.getAge();
                return (int) (o2.getFraction() - o1.getFraction());
            }
        });
        Collections.sort(list);
        for (Student s : list)
            System.out.println(s.toString());
    }
}

package com.cjc.third;

public class Student implements Comparable<Student>{

    private String name;
    private int age;
    private float fraction;

    public Student() {}


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

    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 getFraction() {
        return fraction;
    }

    public void setFraction(float fraction) {
        this.fraction = fraction;
    }

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

    @Override
    public int compareTo(Student o) {
        if (this.fraction == o.fraction)
            return this.age - o.age;
        return (int) (o.fraction - this.fraction);
    }
}

“fdgavcbsacdfs” 获取该字符串中，每一个字母出现的次数。
要求打印结果是：a(2)b(1)…;
思路：
对于结果的分析发现，字母和次数之间存在着映射的关系。而且这种关系很多。
很多就需要存储，能存储映射关系的容器有数组和Map集合。
关系一方式有序编号吗？没有！
那就是使用Map集合。又发现可以保证唯一性的一方具备着顺序如 a b c …
所以可以使用TreeMap集合。
这个集合最终应该存储的是字母和次数的对应关系。
1，因为操作的是字符串中的字母，所以先将字符串变成字符数组。
2，遍历字符数组，用每一个字母作为键去查Map集合这个表。
如果该字母键不存在，就将该字母作为键 1作为值存储到map集合中。
如果该字母键存在，就将该字母键对应值取出并+1，在将该字母和+1后的值存储到map集合中，
键相同值会覆盖。这样就记录住了该字母的次数.
3，遍历结束，map集合就记录所有字母的出现的次数。

package com.cjc.four;

import java.util.Map;
import java.util.TreeMap;

public class four {
    public static void main(String[] args) {
        String str = "fdgavcbsacdfs";
        Map<Character, Integer> map = new TreeMap<>();
        char[] ch = str.toCharArray();
        for (char c : ch) {
            if (map.containsKey(c)) {
                map.put(c, map.get(c) + 1);
            } else {
                map.put(c, 1);
            }
        }
        System.out.println(map);
    }
}

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

package com.cjc.five;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Five {
    public static void main(String[] args) {
        Map<String, String> studentMap = getStringStringMap();

        // 获取entrySet并转换为List
        List<Map.Entry<String, String>> entryList = new ArrayList<>(studentMap.entrySet());

        // 按照学号从大到小排序
        entryList.sort((entry1, entry2) -> {
            Integer intId1 = Integer.parseInt(entry1.getKey());
            Integer intId2 = Integer.parseInt(entry2.getKey());
            return intId2.compareTo(intId1); // 从大到小排序
        });

        // 按顺序输出
        for (Map.Entry<String, String> entry : entryList) {
            System.out.println("学号: " + entry.getKey() + ", 姓名: " + entry.getValue());
        }
    }

    private static Map<String, String> getStringStringMap() {
        Map<String, String> studentMap = new HashMap<>();

        // 向Map中乱序插入学号和姓名
        studentMap.put("03", "王五");
        studentMap.put("04", "赵六");
        studentMap.put("12", "陈十四");
        studentMap.put("05", "钱七");
        studentMap.put("06", "孙八");
        studentMap.put("10", "王十二");
        studentMap.put("15", "蒋十七");
        studentMap.put("07", "周九");
        studentMap.put("08", "吴十");
        studentMap.put("01", "张三");
        studentMap.put("02", "李四");
        studentMap.put("09", "郑十一");
        studentMap.put("11", "冯十三");
        studentMap.put("13", "褚十五");
        studentMap.put("14", "卫十六");
        return studentMap;
    }
}

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

新书：《模式识别》与下列图书：
Java基础教程
数据库技术
C++基础教程
价格相同，具体价格为：29.0元。

package com.cjc.six;

public class Book implements Comparable<Book> {

    private String name;

    private double price;

    public Book() {

    }

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

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

    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;
    }

    @Override
    public int compareTo(Book other) {
        // 比较价格
        return Double.compare(this.price, other.price);
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Book book = (Book) obj;
        return Double.compare(book.price, price) == 0;
    }

    @Override
    public int hashCode() {
        return Double.hashCode(price);
    }
    
}

package com.cjc.six;

import java.util.ArrayList;
import java.util.List;

public class Six {
    public static void main(String[] args) {
        // 创建书籍对象集合
        List<Book> books = new ArrayList<>();
        books.add(new Book("Java基础教程", 29.0));
        books.add(new Book("数据库技术", 29.0));
        books.add(new Book("C++基础教程", 35.0));
        Book newBook = new Book("模式识别", 29.0);

        System.out.println("新书：《模式识别》与下列图书");
        for (Book book : books) {
            if (book.equals(newBook)) {
                System.out.println("               " +book.getName());
            }
        }
        System.out.println("价格相同，具体价格为" + newBook.getPrice() + "元。");
    }
}

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

package com.cjc.seven;

import java.util.ArrayList;
import java.util.List;

public class Operate<T> {

    private List<T> block;

    public Operate(){
        this.block = new ArrayList<>();
    }

    // 数组添加元素
    public void addElement(T element){
        block.add(element);
    }

    // 查看数组元素
    public void showElement(){
        for (T t : block) {
            System.out.println(t);
        }
    }

}

package com.cjc.seven;

public class Demo {
    public static void main(String[] args) {
        Operate<String> operate = new Operate<>();
        operate.addElement("hello");
        operate.addElement("world");
        operate.showElement();
        Operate<Integer> operate1 = new Operate<>();
        operate1.addElement(1);
        operate1.addElement(2);
        operate1.showElement();
    }
}