容器集合案例

男娘i 2024-04-08 08:42 12阅读 0赞

#### 一、集合的案例-Collection集合存储学生对象并遍历 ####

public class CollectionDemo {
        public static void main(String[] args) {
            //创建Collection集合对象
            Collection<Student> c = new ArrayList<Student>();
    
            //创建学生对象
            Student s1 = new Student("林青霞", 30);
            Student s2 = new Student("张曼玉", 35);
            Student s3 = new Student("王祖贤", 33);
    
            //把学生添加到集合
            c.add(s1);
            c.add(s2);
            c.add(s3);
    
            //遍历集合(迭代器方式)
            Iterator<Student> it = c.iterator();
            while (it.hasNext()) {
                Student s = it.next();
                System.out.println(s.getName() + "," + s.getAge());
            }
        }
    }

#### 二、集合的案例-List集合存储学生对象并遍历 ####

public class ListDemo {
        public static void main(String[] args) {
            //创建List集合对象
            List<Student> list = new ArrayList<Student>();
    
            //创建学生对象
            Student s1 = new Student("林青霞", 30);
            Student s2 = new Student("张曼玉", 35);
            Student s3 = new Student("王祖贤", 33);
    
            //把学生添加到集合
            list.add(s1);
            list.add(s2);
            list.add(s3);
    
            //迭代器方式
            Iterator<Student> it = list.iterator();
            while (it.hasNext()) {
                Student s = it.next();
                System.out.println(s.getName() + "," + s.getAge());
            }
            
            System.out.println("--------");
    
            //for循环方式
            for(int i=0; i<list.size(); i++) {
                Student s = list.get(i);
                System.out.println(s.getName() + "," + s.getAge());
            }
    
        }
    }

#### 三、集合的案例-List集合存储学生对象三种方式遍历 ####

public class ListDemo {
        public static void main(String[] args) {
            //创建List集合对象
            List<Student> list = new ArrayList<Student>();
    
            //创建学生对象
            Student s1 = new Student("林青霞", 30);
            Student s2 = new Student("张曼玉", 35);
            Student s3 = new Student("王祖贤", 33);
    
            //把学生添加到集合
            list.add(s1);
            list.add(s2);
            list.add(s3);
    
            //迭代器：集合特有的遍历方式
            Iterator<Student> it = list.iterator();
            while (it.hasNext()) {
                Student s = it.next();
                System.out.println(s.getName()+","+s.getAge());
            }
            System.out.println("--------");
    
            //普通for：带有索引的遍历方式
            for(int i=0; i<list.size(); i++) {
                Student s = list.get(i);
                System.out.println(s.getName()+","+s.getAge());
            }
            System.out.println("--------");
    
            //增强for：最方便的遍历方式
            for(Student s : list) {
                System.out.println(s.getName()+","+s.getAge());
            }
        }
    }

#### 四、集合的案例-ArrayList集合存储学生对象三种方式遍历 ####

public class ArrayListDemo {
        public static void main(String[] args) {
            //创建ArrayList集合对象
            ArrayList<Student> array = new ArrayList<Student>();
    
            //创建学生对象
            Student s1 = new Student("林青霞", 30);
            Student s2 = new Student("张曼玉", 35);
            Student s3 = new Student("王祖贤", 33);
    
            //把学生添加到集合
            array.add(s1);
            array.add(s2);
            array.add(s3);
    
            //迭代器：集合特有的遍历方式
            Iterator<Student> it = array.iterator();
            while (it.hasNext()) {
                Student s = it.next();
                System.out.println(s.getName() + "," + s.getAge());
            }
            System.out.println("--------");
    
            //普通for：带有索引的遍历方式
            for(int i=0; i<array.size(); i++) {
                Student s = array.get(i);
                System.out.println(s.getName() + "," + s.getAge());
            }
            System.out.println("--------");
    
            //增强for：最方便的遍历方式
            for(Student s : array) {
                System.out.println(s.getName() + "," + s.getAge());
            }
        }
    }

#### 五、**HashSet集合存储学生对象并遍历** ####

public class Student {
        private String name;
        private int age;
    
        public Student() {
        }
    
        public Student(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;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
    
            Student student = (Student) o;
    
            if (age != student.age) return false;
            return name != null ? name.equals(student.name) : student.name == null;
        }
    
        @Override
        public int hashCode() {
            int result = name != null ? name.hashCode() : 0;
            result = 31 * result + age;
            return result;
        }
    }

public class HashSetDemo02 {
        public static void main(String[] args) {
            //创建HashSet集合对象
            HashSet<Student> hs = new HashSet<Student>();
    
            //创建学生对象
            Student s1 = new Student("林青霞", 30);
            Student s2 = new Student("张曼玉", 35);
            Student s3 = new Student("王祖贤", 33);
    
            Student s4 = new Student("王祖贤", 33);
    
            //把学生添加到集合
            hs.add(s1);
            hs.add(s2);
            hs.add(s3);
            hs.add(s4);
    
            //遍历集合(增强for)
            for (Student s : hs) {
                System.out.println(s.getName() + "," + s.getAge());
            }
        }
    }

#### 六、自然排序Comparable的使用 ####

*  案例需求
    
     *  存储学生对象并遍历，创建TreeSet集合使用无参构造方法
     *  要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
 *  实现步骤
    
     *  用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
     *  自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
     *  重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

public class Student implements Comparable<Student> {
        private String name;
        private int age;
    
        public Student() {
        }
    
        public Student(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;
        }
    
        @Override
        public int compareTo(Student s) {
    //        return 0;
    //        return 1;
    //        return -1;
            //按照年龄从小到大排序
           int num = this.age - s.age;
    //        int num = s.age - this.age;
            //年龄相同时，按照姓名的字母顺序排序
           int num2 = num==0?this.name.compareTo(s.name):num;
            return num2;
        }
    }

public class TreeSetDemo02 {
        public static void main(String[] args) {
            //创建集合对象
            TreeSet<Student> ts = new TreeSet<Student>();
    
            //创建学生对象
            Student s1 = new Student("xishi", 29);
            Student s2 = new Student("wangzhaojun", 28);
            Student s3 = new Student("diaochan", 30);
            Student s4 = new Student("yangyuhuan", 33);
    
            Student s5 = new Student("linqingxia",33);
            Student s6 = new Student("linqingxia",33);
    
            //把学生添加到集合
            ts.add(s1);
            ts.add(s2);
            ts.add(s3);
            ts.add(s4);
            ts.add(s5);
            ts.add(s6);
    
            //遍历集合
            for (Student s : ts) {
                System.out.println(s.getName() + "," + s.getAge());
            }
        }
    }

#### 七、比较器排序Comparator的使用【应用】 ####

*  案例需求
    
     *  存储学生对象并遍历，创建TreeSet集合使用带参构造方法
     *  要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
 *  实现步骤
    
     *  用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
     *  比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
     *  重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

public class TreeSetDemo {
        public static void main(String[] args) {
            //创建集合对象
            TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
                @Override
                public int compare(Student s1, Student s2) {
                    //this.age - s.age
                    //s1,s2
                    int num = s1.getAge() - s2.getAge();
                    int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                    return num2;
                }
            });
    
            //创建学生对象
            Student s1 = new Student("xishi", 29);
            Student s2 = new Student("wangzhaojun", 28);
            Student s3 = new Student("diaochan", 30);
            Student s4 = new Student("yangyuhuan", 33);
    
            Student s5 = new Student("linqingxia",33);
            Student s6 = new Student("linqingxia",33);
    
            //把学生添加到集合
            ts.add(s1);
            ts.add(s2);
            ts.add(s3);
            ts.add(s4);
            ts.add(s5);
            ts.add(s6);
    
            //遍历集合
            for (Student s : ts) {
                System.out.println(s.getName() + "," + s.getAge());
            }
        }
    }

#### 八、Map集合的遍历(方式1) ####

*  遍历思路
    
     *  我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
        
         *  把所有的丈夫给集中起来
         *  遍历丈夫的集合，获取到每一个丈夫
         *  根据丈夫去找对应的妻子
 *  步骤分析
    
     *  获取所有键的集合。用keySet()方法实现
     *  遍历键的集合，获取到每一个键。用增强for实现
     *  根据键去找值。用get(Object key)方法实现

public class MapDemo01 {
        public static void main(String[] args) {
            //创建集合对象
            Map<String, String> map = new HashMap<String, String>();
    
            //添加元素
            map.put("张无忌", "赵敏");
            map.put("郭靖", "黄蓉");
            map.put("杨过", "小龙女");
    
            //获取所有键的集合。用keySet()方法实现
            Set<String> keySet = map.keySet();
            //遍历键的集合，获取到每一个键。用增强for实现
            for (String key : keySet) {
                //根据键去找值。用get(Object key)方法实现
                String value = map.get(key);
                System.out.println(key + "," + value);
            }
        }
    }

#### 九、Map集合的遍历(方式2) ####

*  遍历思路
    
     *  我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
        
         *  获取所有结婚证的集合
         *  遍历结婚证的集合，得到每一个结婚证
         *  根据结婚证获取丈夫和妻子
 *  步骤分析
    
     *  获取所有键值对对象的集合
        
         *  Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合
     *  遍历键值对对象的集合，得到每一个键值对对象
        
         *  用增强for实现，得到每一个Map.Entry
     *  根据键值对对象获取键和值
        
         *  用getKey()得到键
         *  用getValue()得到值

public class MapDemo02 {
        public static void main(String[] args) {
            //创建集合对象
            Map<String, String> map = new HashMap<String, String>();
    
            //添加元素
            map.put("张无忌", "赵敏");
            map.put("郭靖", "黄蓉");
            map.put("杨过", "小龙女");
    
            //获取所有键值对对象的集合
            Set<Map.Entry<String, String>> entrySet = map.entrySet();
            //遍历键值对对象的集合，得到每一个键值对对象
            for (Map.Entry<String, String> me : entrySet) {
                //根据键值对对象获取键和值
                String key = me.getKey();
                String value = me.getValue();
                System.out.println(key + "," + value);
            }
        }
    }