Java集合常用操作【List集合嵌套存储和遍历，TreeSet集合、HashMap集合基础操作】

约定不等于承诺〃 2022-05-18 04:14 212阅读 0赞

package test;
    
    import java.util.ArrayList;
    
    import java.util.List;
    import java.util.ListIterator;
    
    public class Main {
        public static void main(String[] args) {
            List list = new ArrayList();
    
            list.add("均可");
            list.add("均");
            list.add("复能否");
            list.add("大家");
            list.add("我偶偶");
    
            //迭代器的方式添加，此方法为ArrayList特有
            ListIterator lit = list.listIterator();
            while(lit.hasNext()) {
    
                if("大家".equals((String)lit.next())) {
                    lit.add("kan");
                }
            }
    
    //      如果通过迭代器来添加元素，同时输出的话，会报错
    //      java.util.NoSuchElementException
    
    //      ListIterator lit = list.listIterator();
    //      while(lit.hasNext()) {
    //          
    //          if("大家".equals((String)lit.next())) {
    //              lit.add("kan");
    //          }
    //          System.out.println(lit.next());
    //      }
    
            //逆序遍历（只能在正序遍历后进行）
            while(lit.hasPrevious()) {
                System.out.println(lit.previous());
            }
    
            //用集合的方式遍历集合
            for(int i = 0; i < list.size(); i++) { 
                System.out.println(list.get(i));
            }
    
        }
    }

**ArrayList集合嵌套存储和遍历：**

package test;
    
    import java.util.ArrayList;
    
    public class Main {
        public static void main(String[] args) {
            ArrayList<ArrayList<Student>> bigArray = new ArrayList<ArrayList<Student>>();
    
            ArrayList<Student> array1 = new ArrayList<Student>();
            array1.add(new Student("白骨精", 3));
            array1.add(new Student("唐僧", 43));
            array1.add(new Student("孙猴子", 5));
            bigArray.add(array1);
    
            ArrayList<Student> array2 = new ArrayList<Student>();
            array2.add(new Student("武松", 53));
            array2.add(new Student("潘金莲", 93));
            array2.add(new Student("西门庆", 45));
            array2.add(new Student("松江", 15));
            bigArray.add(array2);
    
            ArrayList<Student> array3 = new ArrayList<Student>();
            array3.add(new Student("诸葛亮", 34));
            array3.add(new Student("张飞", 6));
            bigArray.add(array3);
    
            for(ArrayList<Student> s : bigArray) {
                for(Student ss : s) {
                    System.out.println(ss.getName()+"---"+ss.getAge());
                }
            }
    
        }
    }

**创建Student类：**

package test;
    
    public class Student { 
    
        private String name;
        private int age;
    
        public Student() {
            super();
            // TODO Auto-generated constructor stub
        }
    
        public Student(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }
    
        /** * @return the name */
        public String getName() {
            return name;
        }
    
        /** * @param name the name to set */
        public void setName(String name) {
            this.name = name;
        }
    
        /** * @return the age */
        public int getAge() {
            return age;
        }
    
        /** * @param age the age to set */
        public void setAge(int age) {
            this.age = age;
        }
    
        /* (non-Javadoc) * @see java.lang.Object#toString() */
        @Override
        public String toString() {
            return "Student [name=" + name + ", age=" + age + "]";
        }
        public int compareTo(Student o) {
    
                int n = this.name.compareTo(o.name);
                if(n == 0) return this.age-o.age;
                return n;
            }
    
    }

**TreeSet集合基础操作：**

package test;
    
    import java.util.Comparator;
    import java.util.TreeSet;
    
    public class Main { 
        public static void main(String[] args) {
    
            //HashSet<Student> hs = new HashSet<Student>();
            //TreeSet<Student> ts = new TreeSet<Student>();//自然排序为无参构造，需在Student中重写compareTo()方法
            //比较器排序
            TreeSet<Student> ts = new TreeSet<Student>(new  Comparator<Student>() {
                public int compare (Student s1, Student s2) {
                    int num = s1.getName().compareTo(s2.getName());
                    if(num == 0) return s1.getAge()-s2.getAge();
                    return num;
                }
            }); 
    
    
            ts.add(new Student("秦风", 10));
            ts.add(new Student("徐江", 2));
            ts.add(new Student("jfk", 2));
            ts.add(new Student("zhijin", 2));
            ts.add(new Student("武松", 263));
            ts.add(new Student("徐江", 2));
            ts.add(new Student("java", 22));
            ts.add(new Student("徐", 53));
    
            for(Student s : ts) {
                System.out.println(s);
            }
    
        }
    }

**HashMap映射基础操作：**

package test;
    
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    public class Main {
        public static void main(String[] args) {
    
            Map<String, String> map = new HashMap<String, String>();
    
            map.put("计科", "机房");
            map.put("基本", "今");
            map.put("机房", "交话费卡");
            map.put("周杰伦", "昆凌");
    
            //如果添加的键映射中不存在，则添加键和值，并返回null，表示之前该键不存在
            System.out.println(map.put("九分裤", "京东方可"));
    
            //如果添加的键映射中存在，则把值替换为新值，并返回旧值
            System.out.println(map.put("周杰伦", "蔡依林"));
    
            //如果此映射包含指定键的映射关系，则返回 true
            System.out.println(map.containsKey("机房"));
    
            //如果此映射将一个或多个键映射到指定值，则返回 true
            System.out.println(map.containsValue("今"));
    
            //返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null
            System.out.println(map.get("基本"));
    
            //返回此映射中的键-值映射关系数
            System.out.println(map.size());
    
            //如果此映射未包含键-值映射关系，则返回 true。
            System.out.println(map.isEmpty());
    
            //如果存在一个键的映射关系，则将其从此映射中移除，并返回其对应的值
            System.out.println(map.remove("机房"));
    
            System.out.println("-----------------");
    
            //返回此映射中包含的键的 Set 视图
            Set<String> set = map.keySet();
            //遍历集合中的键
            for(String s : set) {
                System.out.println(s);
            }
    
            System.out.println("-----------------");
    
            //返回此映射中包含的值的 Collection 视图
            Collection<String> co = map.values();
            //遍历映射中所有的值
            for(String s : co) {
                System.out.println(s);
            }
    
            System.out.println("-----------------");
    
            //遍历映射中所有关系 方法一：
            Set<String> set2 = map.keySet();
            for(String s : set2) {
                System.out.println(s+"----"+map.get(s));
            }
    
            System.out.println("-----------------");
    
            //遍历映射中所有关系方法二：
            //返回此映射中包含的映射关系的 Set 视图
            Set<Map.Entry<String, String>> set3 = map.entrySet();
            //遍历映射中所有关系
            for(Map.Entry<String, String> s : set3) {
                System.out.println(s.getKey()+"---"+s.getValue());
            }
    
        }
    }

**TreeMap的两种遍历方式：**

package test;
    
    import java.util.Collection;
    import java.util.Comparator;
    import java.util.Map;
    import java.util.Set;
    import java.util.TreeMap;
    
    public class Main {
        public static void main(String[] args) {
    
            TreeMap<String, String> tm = new TreeMap<String, String>(
                    new Comparator<String>() {
                        public int compare(String s1, String s2) {
                            return s1.compareTo(s2);
                        }
                    });//重写compare方法
    
            tm.put("计科", "机房");
            tm.put("基本", "今");
            tm.put("机房", "交话费卡");
            tm.put("周杰伦", "昆凌");
    
            Set<String> set = tm.keySet();
            for(String s : set) {
                System.out.println(s+"---"+tm.get(s));
            }
    
            System.out.println("-------------");
    
            Set<Map.Entry<String, String>> set2 = tm.entrySet();
            for(Map.Entry<String, String> s : set2) {
                System.out.println(s.getKey()+"---"+s.getValue());
            }
        }
    }