JAVA集合 ==＞ JAVA基础练习题 - 集合练习十道题

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

public class Test {
    public static void main(String[] args){
        Random random = new Random();   // 随机数
        int[] arr = new int[10]; // 十个数的数组
        for (int i = 0; i < 10; i++) {  // 数组中放入随机数
            arr[i] = random.nextInt(100) + 1; // 要求1-100的随机数,所以要 +1
        }
        List list = new ArrayList(); // 创建一个集合
        for (int i = 0; i < arr.length; i++) { // 循环数组,判断数组元素是否大于10
            if (arr[i] >= 10){  //如果大于十,放入集合中
                list.add(arr[i]);
            }
        }
        System.out.println(Arrays.toString(arr)); // 打印数组
        System.out.println(list); // 打印集合
        /* 结果 :
            [8, 53, 10, 20, 72, 95, 70, 80, 2, 29]
            [53, 10, 20, 72, 95, 70, 80, 29]
         */
    }
}

 

---

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

public class Test {
    public static void main(String[] args){
        String[] strs = {"12345","67891","12347809933","98765432102","67891","12347809933"}; // 已知qq号
        List list = new LinkedList(); // 创建集合
        for (int i = 0; i < strs.length; i++) {// 循环strs数组的元素
            list.add(strs[i]); // 把数组的元素遍历到集合中
        }
        // 判断元素是否重复,双循环,外循环控制元素和后面的元素依次对比,内循环取出元素,如果元素相同,则删除
        int a = list.size(); // 设置a为list集合的长度
        for (int i = 0; i < a; i++) {
            String str = (String) list.get(i); // 设置一个数,跟后面的数进行对比
            for (int j = i + 1; j < a; j++) {
                String str2 = (String) list.get(j);
                if (str.equals(str2)){  // 如果两个数相同,则删除后面的数
                    list.remove(j);
                    a--;    // 同时,数组长度-1
                }
            }
        }
        System.out.println(list);
    }
}

 

 

---

3.

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

姓名（String）年龄（int）分数（float）
liusan       20          90.0F
lisi            22          90.0F
wangwu       20          99.0F
sunliu       22          100.0F

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

public class Test {
    public static void main(String[] args){
        TreeSet<Student> set = new TreeSet<>();
        set.add(new Student("liusan", 20, 90.0f));
        set.add(new Student("lisi", 22, 90.0f));
        set.add(new Student("wangwu", 20, 99.0f));
        set.add(new Student("sunliu",22, 100.f));
        System.out.println("姓名\t年龄\t分数");
        for(Student s : set){
            System.out.println(s.getName() +" \t" + s.getAge() + "\t\t" + s.getScore());
        }
    }
}

public class Student implements Comparable<Student> {

    private String name;
    private int age;
    private float score;


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

    public Student(String name, int age, float score) {
        this.name = name;
        this.age = age;
        this.score = 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;
    }

    @Override
    public String toString() {
        return name + "\t" + age + "\t" + score + "\n";
    }
}

 

---

4.

现在有一个map集合如下：
    Map<Integer,String> map = new HashMap<Integer, String>();
    map.put(1, "张三丰");
    map.put(2, "周芷若");
    map.put(3, "汪峰");
    map.put(4, "灭绝师太");
    要求：
        1.遍历集合，并将序号与对应人名打印。
        2.向该map集合中插入一个编码为5姓名为郭靖的信息
        3.移除该map中的编号为1的信息
        4.将map集合中编号为2的姓名信息修改为"周林"

public class Test {
    public static void main(String[] args){
        Map<Integer,String> map = new HashMap<Integer, String>();
        map.put(1, "张三丰");
        map.put(2, "周芷若");
        map.put(3, "汪峰");
        map.put(4, "灭绝师太");

        // 遍历集合
        // 1. 转换成set格式
        Set<Object> set = Collections.singleton(map.keySet());
        Set<Object> set1 = Collections.singleton(map.values());
        for (Object o : set){
            System.out.println(o);
        }
        for (Object o : set1){
            System.out.println(o);
        }
        // 2.forEach
        map.forEach((key,vaule) ->{ System.out.println(key + " : " + vaule); });

        // 向该map集合中插入一个编码为5姓名为郭靖的信息
        map.put(5, "郭靖");
        System.out.println("添加 : " + map);

        // 移除该map中的编号为1的信息
        System.out.println("删除 : " + map.remove(1));

        // 将map集合中编号为2 的姓名修改为"周林"
        System.out.println(map.replace(2, "周林"));
        System.out.println(map);
    }
}

 

---

5.有2个数组，第一个数组内容为：[黑龙江省,浙江省,江西省,广东省,福建省]， 第二个数组为：[哈尔滨,杭州,南昌,广州,福州]， 将第一个数组元素作为key，第二个数组元素作为value存储到Map集合中。 如{黑龙江省=哈尔滨, 浙江省=杭州, …}

public class demo5 {
    public static void main(String[] args){
        String[] str1 ={"黑龙江省","浙江省","江西省","广东省","福建省",};
        String[] str2 ={"哈尔滨","杭州","南昌","广州","福州",};
        Map<String ,String> map = new HashMap<>();
        for (int i = 0; i < str1.length; i++) {
            map.put(str1[i],str2[i] );
    }
        map.forEach((key,vaule) -> {
            System.out.println(key + " : " + vaule);
        });
    }
}

 

---

6.定义一个泛型为String类型的List集合，统计该集合中每个字符 （注意，不是字符串）出现的次数。例如：集合中有”abc”、”bcd”两个元素， 程序最终输出结果为：“a = 1,b = 2,c = 2,d = 1”。

public class Test {
    public static void main(String[] args){
       List<String> list = new ArrayList<>();
        list.add("aaabc");
        list.add("bcddd");
        // 建立一个泛型为char的数组
        List<Character> charList = new ArrayList<>();
        // 需要先遍历集合,取出所有的元素
        for (String s : list){
            for (int i = 0; i < s.length(); i++) {  // 遍历字符串并取出
                charList.add(s.charAt(i));  // 向集合里放入取出的字符
            }
        }
        // 查看charList集合中的元素,有多少重复的
        int a = charList.size();    // 遍历的长度为charList集合的长度
        for (int i = 0; i < a - 1; i++) {
            int num = 1;    // 设置一个数接收每个元素有几个,默认有一个
            for (int j = i + 1; j < a; j++) {   // 循环判断元素后面是否有和当前元素相同的元素
                if (charList.get(i).equals(charList.get(j))){   // 判断是否相同,如果相同
                    charList.remove(j); // 删除该元素
                    num++;  // 记录这个元素共出现几次
                    a--;    // 总长度减一
                    j--;    // 因为删除了一个元素,所以 j+1 位置的元素到j位置上了,要把 j-1
                }
            }
//            System.out.println(charList); // 打印集合
            System.out.println(charList.get(i) + " : " + num); // 打印集合元素出现了几次
        }
    }
}

---

7.

设计Account 类如下：
    private long id;
    private double balance;
    private String password; 要求完善设计，使得该Account 对象能够自动分配自增id。给定一个List 如下：
    List list = new ArrayList();
    list.add(new Account(10.00, “1234”));
    list.add(new Account(15.00, “5678”));
    list.add(new Account(0, “1010”)); 要求把List 中的内容放到一个Map 中，该Map 的键为id，值为相应的Account 对象。 最后遍历这个Map，打印所有Account 对象的id 和余额

public class Test {
    public static void main(String[] args){
        List<Account> list = new ArrayList();
        list.add(new Account(10.00,"1234")); // new ==> Account
        list.add(new Account(15.00,"5678"));
        list.add(new Account(0,"1010"));
        Map<Integer,Account> map = new HashMap<>(); // 创建Map集合
        for(Account o : list){
//            System.out.println(o.getId()); // 取出遍历数组的id
            map.put(o.getId(), o); // 将map集合的Key为id,Value为Account对象
        }
//        System.out.println(map); // 输出map集合

        Set<Integer> set = map.keySet();
        for (Integer a : set){
            System.out.println("id : "+ a + "余额 : " + map.get(a).getPasswork());  // id 和 余额
        }
    }
}

public class Account {
    private static  int num = 1;
    private int id;
    private double balance;
    private String passwork;


    public Account(double balance, String passwork) {
        this.id = num++;  // id自增
        this.balance = balance;
        this.passwork = passwork;
//        id++;
    }

    public static int getNum() {
        return num;
    }

    public static void setNum(int num) {
        Account.num = num;
    }

    public Account() {
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public String getPasswork() {
        return passwork;
    }

    public void setPasswork(String passwork) {
        this.passwork = passwork;
    }

    @Override
    public String toString() {
        return "Account{" +
                "balance=" + balance +
                ", passwork='" + passwork + '\'' +
                '}';
    }
}

---

8. 创建好员工基类和程序员、项目经理子类的基础上，创建一个测试类。 创建一个ArrayList集合对象，要求保存两个程序员和两个项目经理的对象， 并循环调用show的方法显示详细信息

public class Test {
    public static void main(String[] args){
        List<Staff> collation = new ArrayList<>();    // 泛型 ==> 基类
        collation.add(new Programmer());
        collation.add(new PM());
        collation.add(new Programmer());
        collation.add(new PM());
        System.out.println(collation.size());   // 输出collation集合存储元素的个数
        for (Staff s : collation) { // 遍历collection
            s.post();
        }
    }
}

/*
    员工基类,定义为抽象类,抽象方法
 */
public abstract class Staff {
    public abstract void post();
}

/*
    程序员类
 */
public class Programmer extends Staff {
    @Override
    public void post() {
        System.out.println("我是程序员~");
    }
}

/*
    项目经理类
 */
public class PM extends Staff {
    @Override
    public void post() {
        System.out.println("我是项目经理~");
    }
}

---

9.创建Student类，属性包括id[1-40],scroe[0-100], 所有属性随机生成。创建Set集合，保存20个对象，找到分数最高与最低的学生

public class Test {
    public static void main(String[] args){
        TreeSet<Student> treeSet = new TreeSet<>();
        Random random = new Random();
        for (int i = 0; i < 20; i++) {
            int a = random.nextInt(40) + 1;
            int b = random.nextInt(101);
            treeSet.add(new Student(a, b));
        }
        System.out.println("学号\t成绩");
        for(Student s : treeSet){
            System.out.println(s.getId() + "\t\t" +
                    s.getScore());
        }
        System.out.println("最高分 : " + treeSet.first().getScore());
        System.out.println("最低分 : " + treeSet.last().getScore());
    }
}

public class Student implements Comparable<Student> {
    private int id;
    private int score;

    public Student(int id, int score) {
        this.id = id;
        this.score = score;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    @Override
    public int compareTo(Student o) {
        if (this.getScore() == o.getScore()){
            return this.getId() - o.getId();
        }else{
            return o.getScore() - this.getScore();
        }
    }
    @Override
    public String toString() {
        return id + "\t" + score + "\n";
    }
}

---

9.(第二种方法)  创建Student类，属性包括id[1-40],scroe[0-100], 所有属性随机生成。创建Set集合，保存20个对象，找到分数最高与最低的学生

public class Test {
    public static void main(String[] args) {

//        mapTest();

//        work();
        
        // TODO 最高分最低分排名未完成
    }

    public static void work(){
        LinkedHashSet<Student> set = new LinkedHashSet<>();
        for (int i = 0; i < 20; i++) {
            set.add(new Student(Student.getId(),Student.getScroe()));
        }
        int max = 0;
        int min = 100;
        System.out.println("学号 成绩");
        for(Student s : set){
            System.out.println(s);
        }
    }
    
    public static void mapTest(){
        HashSet<Student> set = new HashSet<>(); // 创建一个set集合,同时set集合的泛型是Student
        Map<Integer,Integer> map = new HashMap<>();
        while(map.size() < 20){
            map.put(Student.getId(), Student.getScroe());
        }
        set.toArray();
        System.out.println("学号 成绩");
        Set<Map.Entry<Integer,Integer>> set2 = map.entrySet();
        for (Map.Entry<Integer,Integer> s : set2){
            System.out.println(s.getKey() + "\t" + s.getValue());
        }
    }
}

public class Student{
    private int id;
    private int scroe;
    Random random = new Random();

    public Student(int i, int id) {
        this.id = (random.nextInt(39) + 1);
        this.scroe = random.nextInt(101);
    }

    public static int getId() {
        Random random = new Random();
        return (random.nextInt(39) + 1);
    }

    public void setId(int id) {
        this.id = id;
    }

    public static int getScroe() {
        Random random = new Random();
        return random.nextInt(101);
    }

    public void setScroe(int scroe) {
        this.scroe = scroe;
    }

    @Override
    public String toString() {
        return  id + "\t " + scroe;
    }
}

 

---

10.已知有十六支男子足球队参加2008 北京奥运会。写一个程序，把这16 支球队随机分为4 个组。采用List集合和随机数 2008 北京奥运会男足参赛国家： 科特迪瓦,阿根廷,澳大利亚,塞尔维亚,荷兰,尼日利亚,日本,美国,中国,新西 兰,巴西,比利时,韩国,喀麦隆,洪都拉斯,意大利

public class Test {
    public static void main(String[] args){

        // 两种方式

        no1();

        no2();
    }

    public static void no2(){
        Random random = new Random();
        List list = new ArrayList();

        // 把每一个国家的长度都保持一致,避免打印的时候出现错位的情况
        list.add("科特迪瓦");list.add("阿根廷  ");list.add("澳大利亚");list.add("塞尔维亚");list.add("荷兰    ");list.add("尼日利亚");list.add("日本    ");list.add("美国    ");
        list.add("中国    ");list.add("新西兰  ");list.add("巴西    ");list.add("比利时  ");list.add("韩国    ");list.add("喀麦隆  ");list.add("洪都拉斯");list.add("意大利  ");

        int a  = list.size();   // 设置循环次数是集合的长度
        for (int i = 0; i < 4; i++) {   // 设置双循环,外循环是第几组
            System.out.print("第" + i + "组 : ");
            for (int j = 0; j < 4; j++) {   // 内循环是对应的四个组
                System.out.print(list.get(random.nextInt(a)) + "\t");   //
                a--;    // 随机一次之后随机数删除1,不能重复出现两个组
            }
            System.out.println();
        }
    }

    public static void no1(){
        Random random = new Random();
        List list = new ArrayList();

        // 把每一个国家的长度都保持一致,避免打印的时候出现错位的情况
        list.add("科特迪瓦");list.add("阿根廷  ");list.add("澳大利亚");list.add("塞尔维亚");list.add("荷兰    ");list.add("尼日利亚");list.add("日本    ");list.add("美国    ");
        list.add("中国    ");list.add("新西兰  ");list.add("巴西    ");list.add("比利时  ");list.add("韩国    ");list.add("喀麦隆  ");list.add("洪都拉斯");list.add("意大利  ");

        List arr = new ArrayList(); // 设置一个新数组,接收随机数
        for (int i = 0; i < 16; i++) {
            boolean flag = true;
            while(flag) {   // 循环,如果随机数已经存在了就继续随机
                int a = random.nextInt(16);
                if (arr.indexOf(a) == -1){ // 判断随机数a是否存在于arr集合中,存在返回索引,不存在返回-1
                    arr.add(a);
                    flag = false;
                }
            }
        }
        System.out.println("第一组\t\t第二组\t\t第三组\t\t第四组");
        for (int i = 1; i <= arr.size(); i++) { // 设置循环十六次,因为每四次换行,i%4==0  当i=0时直接换行,所以i从1开始
            int a = (int) arr.get(i-1); // 取出随机出来的数 i从1开始,所以要减一
            System.out.print(list.get(a) + "\t");
            if (i % 4 == 0 ){   // 每四个国家循环完就换行
                System.out.println();
            }
        }

    }
}