Java中集合相关案例（泛型通配符、Collections工具类、TreeSet、TreeMap、HashMap、HashSet和集合嵌套案例）

一、集合相关案例

1.泛型通配符案例

案例：动物类Animal有一个方法，返回动物的腿的个数。子类有狗狗和企鹅，分别重写该方 法，返回各自腿的个数。

编写一个测试类，定义一个方法，该方法可以计算出一个动物集合List共有多少条腿，并输 出。

再定义一个测试方法，分别计算一批动物（2只狗狗和3只企鹅）和一批狗狗（3只），一批 企鹅（3只）的腿的数量。
Animal类

package fx1;

public abstract class Animal {
    
    
    //父类中的方法,因为不确定返回腿的个数,因此设计为抽象方法
    public abstract int tui();
}

Dog类

package fx1;

public class Dog extends Animal{
    
    
    @Override
    public int tui() {
    
    
        return 4;
    }
}

Penguin类

package fx1;

public class Penguin extends Animal{
    
    
    @Override
    public int tui() {
    
    
        return 2;
    }
}

Test类

package fx1;

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

public class Test {
    
    
    public static void test(List<? extends Animal> animals){
    
    
        int sum=0;
        for (Animal a : animals) {
    
    
            sum+=a.tui();
        }
        System.out.println("这批动物的腿的个数："+sum);
    }

    public static void main(String[] args) {
    
    
        //2只狗狗和3只企鹅
        ArrayList<Animal> arr = new ArrayList();
        arr.add(new Dog());
        arr.add(new Dog());
        arr.add(new Penguin());
        arr.add(new Penguin());
        arr.add(new Penguin());
        test(arr);
        //3只狗狗
        ArrayList<Dog> dog = new ArrayList();
        dog.add(new Dog());
        dog.add(new Dog());
        dog.add(new Dog());
        test(dog);
        //3只企鹅
        ArrayList<Penguin> p = new ArrayList();
        p.add(new Penguin());
        p.add(new Penguin());
        p.add(new Penguin());
        test(p);
    }
}

2.集合工具类（Collections工具类）

案例：1.现有5只猴子（姓名，年龄），将他们存入List集合中，先随机打乱，然后使用工具类，对 这一群猴子按照年龄进行排序。

2.交换集合中的第一个和第三个猴子

3.查找名称叫肉肉的猴子

package collection;

import java.util.*;
//Collections工具类：
public class Hello1 {
    
    
    public static void main(String[] args) {
    
    
        Integer[] arr={
    
    1,5,4,6,7,9,3};
        List list = Arrays.asList(arr);
        //shuffle随机打乱
        Collections.shuffle(list);
        System.out.println(list);
        //排序sort
        Collections.sort(list);
        System.out.println(list);
        //查找 binarySearch:前提是集合中的元素必须按某种规则升序排序
        System.out.println(Collections.binarySearch(list, 5));
        //交换 swap
        Collections.swap(list,1,3);
        System.out.println(list);

    }
}

package collection;

public class Monkey implements Comparable<Monkey>{
    
    
    private String name;
    private int age;

    @Override
    public int compareTo(Monkey monkey) {
    
    
        return this.getAge()-monkey.getAge();
    }

    public Monkey(String name, int age) {
    
    
        this.name = name;
        this.age = age;
    }

    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 Monkey() {
    
    
    }

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


}

package collection;


import java.util.Collections;
import java.util.LinkedList;

public class TestMonkey {
    
    
    public static void main(String[] args) {
    
    
        LinkedList list=new LinkedList();
        list.add(new Monkey("狒狒",22));
        list.add(new Monkey("旺财",18));
        list.add(new Monkey("肉肉",14));
        list.add(new Monkey("团子",15));
        list.add(new Monkey("菲菲",19));
        //年龄排序
        Collections.sort(list);
        System.out.println(list);
        //交换第一只和第三只
        Collections.swap(list,0,2);
        System.out.println(list);
        //查找叫肉肉的猴子
        Collections.sort(list);
        System.out.println(Collections.binarySearch(list,new Monkey("狒狒",22)));
    }
}

3.TreeSet和TreeMap案例

案例：1.将5个大象（姓名，年龄，体重）存入TreeSet中，并输出

2.给每一个大象安排一个主人，存入TreeMap中，并输出

package anli;

public class Elephant implements Comparable<Elephant>{
    
    
    private String name;
    private int age;
    private double weight;
    @Override
    public int compareTo(Elephant o) {
    
    
        return this.age-o.age;
    }
    public Elephant(String name, int age, double weight) {
    
    
        this.name = name;
        this.age = age;
        this.weight = weight;
    }

    public Elephant() {
    
    
    }

    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 double getWeight() {
    
    
        return weight;
    }

    public void setWeight(double weight) {
    
    
        this.weight = weight;
    }

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


}

package anli;

import java.util.TreeMap;
import java.util.TreeSet;
/*1.将5个大象（姓名，年龄，体重）存入TreeSet中，并输出
2.给每一个大象安排一个主人，存入TreeMap中，并输出*/
public class TestElephant {
    
    
    public static void main(String[] args) {
    
    
        TreeSet<Elephant> map = new TreeSet<Elephant>((o1,o2)->Double.compare(o1.getWeight(),o2.getWeight()));
        map.add(new Elephant("菲菲",10,200.0));
        map.add(new Elephant("狒狒",5,100.0));
        map.add(new Elephant("飞飞",15,150.0));
        map.add(new Elephant("肥肥",9,180.0));
        map.add(new Elephant("妃妃",20,300.0));
        System.out.println(map);
        TreeMap map1 = new TreeMap();
        map1.put("主人1",new Elephant("菲菲",10,200.0));
        map1.put("主人2",new Elephant("狒狒",5,100.0));
        map1.put("主人3",new Elephant("飞飞",15,150.0));
        map1.put("主人4",new Elephant("肥肥",9,180.0));
        map1.put("主人5",new Elephant("妃妃",20,300.0));
        System.out.println(map1);
    }
}

4.HashMap案例

案例：三国时期，刘备派关羽守樊城，张飞守新野，赵子龙守徐州，他自己坐镇荆州。
使用HashMap和City类实现，并打印输出，张飞守的是那座城？所有人员守城信息。

package map;

public class City {
    
    
    private String name;

    public String getName() {
    
    
        return name;
    }

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

    public City(String name) {
    
    
        this.name = name;
    }

    public City() {
    
    
    }

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

package map;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Hello1 {
    
    
    public static void main(String[] args) {
    
    
        HashMap map = new HashMap();
        map.put("关羽",new City("樊城"));
        map.put("张飞",new City("新野"));
        map.put("赵子龙",new City("徐州"));
        map.put("刘备",new City("荆州"));
        //遍历方式1--所有的key
        Set keys = map.keySet();
        for (Object key : keys) {
    
    
            System.out.println(key+"--"+map.get(key));
        }
        //遍历方式2--所有的value
        Collection values = map.values();
        for (Object v : values) {
    
    
            System.out.println(v);
        }
        //遍历方式3--所有的entry:k-v
        Set entrySet = map.entrySet();
        for (Object o : entrySet) {
    
    
            Map.Entry entry=(Map.Entry) o;
            System.out.println(entry.getKey()+"--"+entry.getValue());
        }
        //常用方法
        map.put("诸葛亮",new City("湘潭"));
        map.remove("刘备");
        map.get("诸葛亮");
        map.containsKey("赵子龙");
        map.containsValue("荆州");
        map.isEmpty();
        map.clear();
        map.size();
        map.keySet();
        map.values();
    }
}

5.HashSet案例

案例：定义一个字符串“我爱北京天安门，天安门上太阳升”，要求使用HashSet元素不重复的特点，过滤掉字符串中重复出现的文字。可以结合StringBuilder实现。

package work2;


import java.util.HashSet;
import java.util.LinkedHashSet;

public class Work2 {
    
    
    public static void main(String[] args) {
    
    
        String s="我爱北京天安门，天安门上太阳升";
        char[] chars=s.toCharArray();
        //方法一
        LinkedHashSet set = new LinkedHashSet();//有序不重复
        for (int i = 0; i < chars.length; i++) {
    
    
            set.add(chars[i]);
        }
        for (Object o : set) {
    
    
            System.out.print(o);
        }
        System.out.println();
        //方法二
        HashSet hs = new HashSet();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < chars.length; i++) {
    
    
            if (hs.add(chars[i])){
    
    
                sb.append(chars[i]);
            }
        }
        System.out.println(sb);
    }
}

6.TreeSet案例

案例：将一系列字符串“hello”,“helloworld”,“how”,“do”,“you”,"what"存入TreeSet集合，要求按照字符串长度进行排序。

package work2;

import java.util.Comparator;
import java.util.TreeSet;
/*2.将一系列字符串“hello”,"helloworld","how","do","you","what"存入TreeSet集合，要求按照 字符串长度进行排序。
 */
public class Work2 {
    
    
    public static void main(String[] args) {
    
    
        TreeSet<String> set = new TreeSet<String>((s1,s2)->{
    
    
            if (s1.length()!=s2.length())
                return s1.length()-s2.length();
            else
            //长度如果相等，本来会返回0，TreeSet自带去重，	认为相同的元素，只保留一个
                //因此，此处，就把这种情况的0改为1
                return 1;
        });
        set.add("hello");
        set.add("helloworld");
        set.add("how");
        set.add("do");
        set.add("you");
        set.add("what");
        System.out.println(set);
    }
}

7.记事本案例

案例：3.有一个记事本，可以记录做了哪些事情和每件事对应得次数。请输入10件事，可以重复，例如：

学java,

打球，

溜冰，

打球，

溜冰，

打球，

打球，

学java，

溜冰，

吃烧烤。

输入结束后，输出每件事和对应得次数，例如：

学java–2次

打球–4次

溜冰–3次

吃烧烤–1次

要求：所选的集合都要用泛型进行约束。

package work3;

import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;

/*有一个记事本，可以记录做了哪些事情和每件事对应得次数。请输入10件事，可以重复， */
public class Work3 {
    
    
    public static void main(String[] args) {
    
    
        TreeMap<String,Integer> map = new TreeMap();
        Scanner sc = new Scanner(System.in);
        for (int i = 1; i < 11 ; i++) {
    
    
            System.out.println("请输入做的第"+i+"件事情");
            String thing = sc.next();
            int a=map.containsKey(thing)?map.get(thing)+1:1;
            map.put(thing,a);
        }
        Set<String> keys = map.keySet();
        for (String key:keys) {
    
    
            System.out.println(key+"--"+map.get(key)+"次");
        }
    }
}

8.嵌套集合案例

案例：有一个记事本，能记录周一到周天，每天做的所有事情和事情的次数，周而复始。小明在这个记事本上记录了3周，

package work4;

import java.util.*;

public class Work4 {
    
    
    public static void main(String[] args) {
    
    
        Scanner sc = new Scanner(System.in);
        //week 共有7个元素
        TreeMap<String, Map<String,Integer>> week = new TreeMap<String, Map<String,Integer>>();
        //数据录入
        for (int i = 1; i <=3 ; i++) {
    
    
            System.out.println("第"+i+"周");
            Map<String,Integer> map;
            for (int j = 1; j <=7 ; j++) {
    
    
                map=new HashMap<String, Integer>();//每天都会清空昨天的事情和次数
                System.out.println("周"+j+":");
                String things = sc.next();//旅游，逛街，旅游，打台球，吃烧烤，跑步
                String[] thing_arr=things.split(",");
                for (String s:thing_arr) {
    
    
                    //map存入的是：事情和次数
                    map.put(s,map.containsKey(s)?map.get(s)+1:1);
                }
                //第二周,第三周
                if (week.containsKey("周"+j)){
    
    
                    Map<String,Integer> map1=week.get("周"+j);
                    mapAddMap(map1,map);
                    //week.put("周"+j,map);
                }else {
    
    //第一周
                    week.put("周"+j,map);
                }

            }
        }
        //数据输出  week
        Set<Map.Entry<String,Map<String,Integer>>> weeks=week.entrySet();
        for (Map.Entry<String,Map<String,Integer>> week1:weeks){
    
    
            System.out.println(week1.getKey()+":");
            Map<String,Integer> map=week1.getValue();
            Set<Map.Entry<String,Integer>> things=map.entrySet();
            for (Map.Entry<String,Integer> thing:things) {
    
    
                String key=thing.getKey();
                Integer count=thing.getValue();
                System.out.println(key+"--"+count+"次 \t");
            }
            System.out.println();//换行
        }
    }
    public static void mapAddMap(Map<String,Integer> map1,Map<String,Integer> map2){
    
    
        Set<String> map2Key=map2.keySet();
        for (String m2Key:map2Key) {
    
    
            map1.put(m2Key,map1.containsKey(m2Key)?map1.get(m2Key)+map2.get(m2Key):map2.get(m2Key));
        }
    }
}

总结

以上就是集合相关的所有案例内容，主要是利用了集合相关的知识来解决相关的问题。