JavaSE进阶557-560 集合类复习回顾

开始时间 2020-11-22

集合复习

1、集合这块最主要掌握什么内容?
1.1、每个集合对象的创建( new）
1.2、向集合中添加元紊 add/put
1.3、从集合中取出某个元紊 迭代器/get
1.4、遍历集合
1.5、主要的集合指:

• ArrayList
• LinkedList
• Hashset
• Treeset
• HashMap
• PropertiesreeMap

遍历方法
1.foreach
2.迭代器
3.下标方式（不是所有都能用）

Map集合遍历：
1.先获取所有的Key，遍历Key，通过key获取value
2.将Map转为Set，Set每一个元素都是Node（调用map的entrySet方法）

ArrayListTest

package Review;

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

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        /*
        这两个使用起来可以通用
        LinkedList<String> list = new LinkedList<>();
         */

        list.add("xiaoming");
        list.add("xiaohong");
        list.add("xiaogang");
        //取出元素找下标
        String first_ele = list.get(0);
        System.out.println(first_ele);
        //三种遍历方式：for循环;foreach;迭代器（Collection通用）
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        for (String s : list) {
            System.out.println(s);
        }
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String s = iterator.next();
            System.out.println(s);
        }
    }
}

HashSetTest

package Review;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Objects;
import java.util.Set;

public class HashSetTest {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        HashSet set1 = new HashSet();

        set.add("acx");
        set.add("xcx");
        set.add("bcx");

        set1.add("acx");
        set1.add("xcx");
        set1.add(123);
        //遍历集合，没有下标用迭代器
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            String s = iterator.next();
            System.out.println(s);
        }
        //for each也可以实现遍历
        //不用泛型的话s就直接是一个对象才行
        for (Object s : set1) {
            System.out.println(s);
        }
        //set的特点是无序不可重复
        set.add("king");
        System.out.println(set.size());
        set.add("king");
        set.add("king");
        //这俩king加不进去
        System.out.println(set.size());
        Set<Student> set2 = new HashSet<>();
        Student s1 = new Student(15, "张三");
        Student s2 = new Student(25, "张四");
        Student s3 = new Student(5, "李三");
        set2.add(s1);
        set2.add(s2);
        set2.add(s3);
        for (Student s : set2) {
            System.out.println(s);
        }
    }
}

//定义学生类，辅助理解HashSet

class Student {
    int age;
    String name;

    public Student() {
    }

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

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

    //equals 和 HashCode要同时重写
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(age, name);
    }
}

TreeSetTest

package Review;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetTest {
    public static void main(String[] args) {
        TreeSet<Integer> ts = new TreeSet<>();
        //若想实现降序输出，写比较器改变规则
        /*
        TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
         */

        ts.add(12);
        ts.add(123);
        ts.add(124);
        ts.add(121);
        ts.add(121);
        //迭代器遍历，排序不可重复
        Iterator<Integer> iterator = ts.iterator();
        while (iterator.hasNext()) {
            Integer i = iterator.next();
            System.out.println(i);
        }
        //传一个自定义类，调用接口排序
        TreeSet<A> treeSet = new TreeSet<>();
        treeSet.add(new A(14));
        treeSet.add(new A(143));
        treeSet.add(new A(114));
        for (A a : treeSet) {
            System.out.println(a);
        }
        //传一个自定义类，调用比较器排序
        //  TreeSet<B> treeSet2 = new TreeSet<>(new BComparator());
        //或者使用匿名内部类
        TreeSet<B> treeSet2 = new TreeSet<>(new Comparator<B>() {
            public int compare(B o1, B o2) {
                return o1.age - o2.age;
            }
        });
        treeSet2.add(new B(14));
        treeSet2.add(new B(143));
        treeSet2.add(new B(114));
        for (B b : treeSet2) {
            System.out.println(b);
        }
    }
}

class A implements Comparable<A> {
    int age;

    public A(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "A{" +
                "age=" + age +
                '}';
    }

    //需要重写一下compareTo方法
    @Override
    public int compareTo(A o) {
        return this.age - o.age;
    }
}

class B {
    int age;

    public B(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "B{" +
                "age=" + age +
                '}';
    }
}
//如果调用比较器，则用下面的代码，如果调用匿名内部类，则不需要下面的代码
/*
class BComparator implements Comparator<B> {

    @Override
    public int compare(B o1, B o2) {
        return o1.age - o2.age;
    }
}
 */

HashMapTest

package Review;

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

public class HashMapTest {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "Zhangsan");
        map.put(2, "wangwu");
        map.put(2, "chongfu");
        map.put(22, "wwaf");
        //key重复value会覆盖
        System.out.println(map.size());
        //取key为1的元素
        System.out.println(map.get(1));
        //遍历方式一：通过key取元素的value
        Set<Integer> keySet = map.keySet();
        for (Integer key : keySet) {
            System.out.println(key + "=" + map.get(key));
        }
        //遍历方式二：将Map转为Set集合，Set集合中每一个元素都是Node
        Set<Map.Entry<Integer, String>> nodes = map.entrySet();
        for (Map.Entry<Integer, String> node : nodes) {
            System.out.println(node.getKey() + "=" + node.getValue());
        }
    }
}

PropertiesTest

package Review;

import java.util.Properties;

public class PropertiesTest {
    public static void main(String[] args) {
        Properties pro = new Properties();
        pro.setProperty("username", "zhangsan");
        pro.setProperty("password", "666");
        String name = pro.getProperty("username");
        String password = pro.getProperty("password");
        System.out.println("name:" + name + "password:" + password);
    }
}

结束时间 2020-11-22