Java项目实战开发Day13 2020-04-05

内容

1.Collection集合
2.Map集合

一.Collection集合

详细请参看：​​https://www.jianshu.com/p/793f29870d50​​​ 和​​https://www.jianshu.com/p/c93b56e57c10​​

1.Collection集合继承关系图

Collection集合继承关系图

2.Collection集合介绍

Collection是集合类的一个接口，定义了集合共有的方法。它有两个子接口，List和Set。
(1)List类似列表，Set即集合。
②List存储的对象有序可重复，存进去是什么顺序，拿出来就是什么顺序。
③Set存储的对象无序不可重复。
(2)List下有ArrayList类和LinkedList类
①两者都是List接口的具体的实现类。
②ArrayList内部使用数组存储元素，当需要频繁查询数据时，用这个(日常使用也是用的更多)
③LinkedList内部使用链表存储元素。当需要频繁增删数据时，用这个
(3)Set下有HashSet，主要就是用这个。

Collection

3.创建集合

两种方式创建，上面的两个运用了多态，下面的没有

//因为Collection是接口，不能new，所以使用多态
        Collection c = new ArrayList();

        List<Person> people = new ArrayList<Person>();//注意这里也有()

        ArrayList<Person> personList = new ArrayList<Person>();

4.ArrayList常用方法介绍

①添加元素

//添加
        personList.add(new Person());       
        personList.add(1, new Person());//在某个位置插入数据
        //其实还可以插入多个数据

②获取对象

//获取对象
        personList.get(0);

③遍历数组

//遍历这个数组
        //1.使用for循环遍历,是关心索引值的
        for(int i = 0;i < personList.size();i++) {
            Person p = personList.get(i);
            
            //删除某个对象
            personList.remove(i);
            personList.remove(p);
        }
        //2.使用增强for循环，不关心索引值
        for(Person person:personList) {
            
        }
        //3.使用Iterator遍历器来遍历，不关心索引值
        //和前者主要的区别：当在遍历的同时需要删除对象的时候，Iterator不会跳过对象进而有可能越界去删除，进而不会导致有的对象没有被删除，有的对象不该删除却可能被删除了
        Iterator<Person> iterator = personList.iterator();//获取数组对应的遍历器对象
        while(iterator.hasNext()) {
            Person p = iterator.next();
            iterator.remove();//删除对象
        }

重点注意迭代器：当在遍历的同时需要删除对象的时候，Iterator不会跳过对象进而有可能越界去删除，进而不会导致有的对象没有被删除，有的对象不该删除却可能被删除了(一般不会，因为会报错)

④删除对象

可以使用迭代器删除，也可以用下面的方法删除

//按照条件删除
        //1.创建Predicate的子类对象，因为Predicate是个接口
        MyPredicate predicate = new MyPredicate();
        personList.removeIf(predicate);
        //2.使用匿名内部类
        personList.removeIf(new Predicate<Person>() {//new的这个不是接口，而是接口的实现类
            @Override
            public boolean test(Person t) {
                // TODO 自动生成的方法存根
                if(1 > 0) {
                    return true;
                }
                return false;
            }           
        });

//以上是main方法
//创建一个类实现Predicate接口
class MyPredicate implements Predicate<Person>{

    @Override
    public boolean test(Person arg0) {
        // TODO 自动生成的方法存根
        if(1 > 0) {
            return true;//这样就能删除
        }
        return false;
    }

}

即有两种方式，一种是创建一个类实现Predicate，进而实现test方法。一种是直接匿名内部类实现test方法。注意，匿名内部类里new抽象类的时候(比如上面new Predicate())，不是创建了抽象类，而是创建了抽象类的实现类。

⑤排序

两种方式，一种是使用Collection的sort方法，一种是用对象的sort方法
(1)用Collection的sort方法的时候，需要把自己定义的类实现Comparable接口，并且实现compareTo方法
(2)用对象的sort方法的时候，需要new一个匿名内部类并且实现compare方法，一般在compare方法里面还有comparaTo的调用。
其实这里我现在还是有点模糊，再精细一些的话，等两天再返回来研究，现在先知道有这么一个事。

class Person implements Comparable<Person>{

    int age;
    String name;
    
    @Override
    public int compareTo(Person arg0) {
        // TODO 自动生成的方法存根
        //确定比较的方式
        if(this.age > arg0.age) {
            return 1;
        }
        else if(this.age == arg0.age){
            return 0;
        }
        return -1;      
    }
    
}

//排序
        //1.自己定义的类必须实现Comparable接口和compareTo方法
        Collections.sort(personList);
        //2.使用对象的
        personList.sort(new Comparator<Person>() {

            @Override
            public int compare(Person arg0, Person arg1) {
                // TODO 自动生成的方法存根
                //制定比较的规则
                return arg0.name.compareTo(arg1.name);//可以调用String类的compareTo方法，因为它默认实现了Comparable接口，但是这里如果比较age就不行了，因为不能调用基本类型 int 的 compareTo(int)
                //也就是说调用compareTo方法的时候一般只能比较字符串。注意，是自己显式调用的时候
            }
            
        });

⑥剩下的比较简单

//是否包括某个元素
        personList.contains(personList.get(0));//比较的是对象是否相同，而不是对象的内容。也就是比较的内存地址
        
        //获取某个对象的索引值
        System.out.println(personList.indexOf(personList.get(0)));
        
        //重新改变某个值
        personList.set(0, person);把索引值为0的替换为person
        
        //清空
        personList.clear();

二.Map集合

详细请看：​​https://www.jianshu.com/p/65044852d5a8​​

1.Map集合继承关系图

Map集合继承关系图

2.Map集合简单介绍

Map集合相对用的少
(1)Map也是一个接口。没有顺序且存储数据不可重复。类似映射 ，以键值对的方式存储数据
key：键。value：值
所以映射里面就是 【key，value】
(2)Map有子接口HashMap 管理键值对(主要用这个)
ConcurrentMap 是线程安全的
LinkedHashMap

3.Map中方法使用

①创建键值对

Map<String,Person> map = new HashMap();

②添加键值对

//添加键值对
        map.put("Jack", new Person());
        map.put("Merry", new Person());

③获取键值对的个数

//获取键值对的个数
        System.out.println(map.size());//2

④是否包含某个key或value

//是否包含某一个key
        System.out.println(map.containsKey("Jack"));//true
        
        //是否包含某个value
        System.out.println(map.containsValue(new Person()));//false

⑤获取某个key对应的值

//获取某个key对应的值
        Person p = map.get("Jack");

⑥删除键值对

//删除键值对
        map.remove("Jack");//传的参数是key

⑦替换某个键对应的值

//替换某一个键对应的值
        map.replace("Jack",new Person());

⑧清空

//清空
        map.clear();

⑨遍历

遍历是最难的

//map遍历
        Set<Map.Entry<String, Person>> entries = map.entrySet();
        for(Map.Entry<String,Person> entry:entries) {
            System.out.println(entry.getKey() + entry.getValue());
        }