Java学习16 2020-02-21

内容

1.集合简单介绍
2.集合继承结构图
3.Map继承结构图
4.链表示意图
5.Collection中常用方法讲解

一.集合简单介绍

集合就类似于一种容器，可以装东西。就比如用篮子装水果和用塑料袋装水果，这个篮子和塑料袋都可以说时集合。注意：集合只能存储引用类型

二.集合继承结构图

Collection继承结构图

三.Map继承结构图

Map继承结构图

四.链表示意图

1.单向链表

单向链表

2.双向链表

双向链表

五.Collection中常用方法讲解

Collection中主要掌握这些方法

Collection中常用方法

1.使用示例①

以下程序展示了add();
clear();
isEmpty();
size();
toArray();
方法的使用

import java.util.ArrayList;
import java.util.Collection;

public class 测试程序 {                                                                                                             
                                                                                                                                
                                                                                                                                
    public static void main(String[] args)  {                                                                                   
             
        //1.创建集合。
        //因为Collection是接口，不能new，所以使用多态
        Collection c = new ArrayList();
        
        //2.添加元素
        c.add(1);//自动装箱
        c.add(new Integer(100));
        
        Object o = new Object();
        c.add(o);//Collection只能单个存储元素，并且只能存储引用类型
        
        Customer cus = new Customer("JACK",20);
        c.add(cus);
        
        //3.获取元素的个数
        System.out.println(c.size());//输出4
        System.out.println(c.isEmpty());//输出false
        
        //4.将集合转换成Object类型的数组
        Object[] objs = c.toArray();
        
        //遍历数组
        for(int i = 0;i < objs.length;i++) {
            System.out.println(objs[i]);
        }
        
        //5.清空
        c.clear();
        System.out.println(c.size());//输出0
        System.out.println(c.isEmpty());//输出true
    }                                                                                                                           
}      

//创建一个类
class Customer{
    String name;
    int age;
    
    //构造方法
    Customer(String name,int age){
        this.name = name;
        this.age = age;
    }
    
    //重写Object中的toString方法
    public String toString() {
        return "Customer[name = "+name+",age = "+age+"]";
    }
}
/*
  输出结果
4
false
1
100
java.lang.Object@15db9742//因为Object中toString方法没有重写，所以打印出地址
Customer[name = JACK,age = 20]
0
true

 */

2.使用示例②

迭代器使用

import java.util.*;



public class 测试程序 {                                                                                                             
                                                                                                                                
                                                                                                                                
    public static void main(String[] args)  {                                                                                   
             
        //1.创建集合对象
        Collection c = new ArrayList();
        
        //2.添加元素
        c.add(1);//自动装箱
        c.add(3.14);//自动装箱
        c.add(false);//自动装箱
        
        //3.获取迭代器对象
        Iterator it = c.iterator();
        //①不需要关心底层集合的具体类型，所有集合依赖的迭代器都实现了java.util.Iterator接口
        //②迭代器是面向接口编程
        //③it是引用，保存了内存地址，指向堆中的“迭代器对象”
        
        //4.打印it
        System.out.println(it);//如果是ArrayList则输出java.util.ArrayList$Itr@15db9742
                               //如果是LinkedList则输出java.util.LinkedList$ListItr@15db9742
    
        //所以java.util.ArrayList$Itr类是ArrayList集合所依赖的迭代器      
        //同理，java.util.LinkedList$ListItr类是LinkedList集合所依赖的迭代器
        
        //5.开始调用方法，完成遍历/迭代
        while(it.hasNext()){
            Object element = it.next();
            
            System.out.println(element);
        }
        
        //6.用for循环迭代
        for(Iterator a = c.iterator();a.hasNext();) {
            Object o = a.next();
            System.out.println(o);
        }
    }                                                                                                                           
}      
/*
 * hasNext()是判断是否有更多的元素，如果有就返回true
 * next()是将迭代器向下移动一位，并且取出指向的元素
 */

3.使用示例③

contains()方法使用

重点掌握contains方法的底层实现原理，另外回顾一下equals方法怎么重写

import java.util.*;
/*
 * 使用contains方法
 * boolean contains(Object o);
 */


public class 测试程序 {                                                                                                             
                                                                                                                                
                                                                                                                                
    public static void main(String[] args)  {                                                                                   
    
        //1.创建集合
        Collection o = new ArrayList();
        
        //2.创建Integer类型的对象
        Integer i1 = new Integer(10);
        
        //3.添加元素
        o.add(i1);
        
        //4.判断集合中是否包含i1
        System.out.println(o.contains(i1));//true
        
        //5.再创建一个Integer类型的对象
        Integer i2 = new Integer(10);
        
        //6.判断集合中是否包含i2
        System.out.println(o.contains(i2));//虽然没有把i2加入集合，但是输出结果还是true
        //原因是i1和i2都是10。说明contains方法底层调用的是equals方法
        //equals返回true，就是包含，如果equals返回false，就是不包含
        
        //7.添加m1
        Manager m1 = new Manager(100,"jack");
        o.add(m1);
        
        //8.判断集合中是否有m1
        System.out.println(o.contains(m1));//true
        
        //9.创建m2
        Manager m2 = new Manager(100,"jack");

        //8.判断集合中是否有m2
        System.out.println(o.contains(m2));
        //没有重写equals方法的时候，这里输出的是false。
        //但是这样显示不符合现实的业务逻辑，所以将equals方法重写之后，就输出true
        
        
    
    }                                                                                                                           
}     

//创建Manager类
class Manager{
    int num;
    String name;
    
    //构造方法
    Manager(int num,String name){
        this.num = num;
        this.name = name;
    }
    
    //重写equals方法
    //让equals方法不再比较内存地址，而是比较内容
    //重写equals方法是基本功
    public boolean equals(Object o) {
        if(this == o)  return true;
        if(o instanceof Manager) {
            Manager m = (Manager)o;
            if(m.num == this.num &&m.name.equals(this.name)) {
                return true;
            }
        }
        return false;
    }
}

4.使用示例④

remove方法

重点掌握remove方法底层实现原理以及如何重写equals方法

import java.util.*;
/*
 使用remove方法
 boolean remove(Object o)
 
 remove和contains方法都需要集合中的元素重写equals方法。因为Object和equals方法
 比较内存地址，在现实的业务逻辑当中不能比较内存地址，而应比较内容
 */


public class 测试程序 {                                                                                                             
                                                                                                                                
                                                                                                                                
    public static void main(String[] args)  {                                                                                   
    
        //1.创建集合
        Collection o = new ArrayList();
        
        //2.创建Integer类型的对象
        Integer i1 = new Integer(10);
        
        //3.添加元素
        o.add(i1);
        
        //4.删除(用i2来删除)
        Integer i2 = new Integer(10);
        o.remove(i2);
        
        System.out.println(o.size());
        
        //5.创建Manager类的对象
        Manager m1 = new Manager(100,"jack");
        
        //6.添加元素
        o.add(m1);
        
        //7.再创建一个Manager类的对象
        Manager m2 = new Manager(100,"jack");
        
        //8.删除元素(用m2删)
        o.remove(m2);
        
        System.out.println(o.size());
    
    }                                                                                                                           
}     

//创建Manager类
class Manager{
    int num;
    String name;
    
    //构造方法
    Manager(int num,String name){
        this.num = num;
        this.name = name;
    }
    
    //重写equals方法
    //让equals方法不再比较内存地址，而是比较内容
    //重写equals方法是基本功
    public boolean equals(Object o) {
        if(this == o)  return true;
        if(o instanceof Manager) {
            Manager m = (Manager)o;
            if(m.num == this.num &&m.name.equals(this.name)) {
                return true;
            }
        }
        return false;
    }
}

5.深入remove方法

上面的程序是一个一个元素地删，用的是集合自己的remove方法。
下面的程序是把集合的remove方法和迭代器的remove方法进行了比较

import java.util.*;
/*
深入remove
①使用迭代器的remove方法删除(推荐这种方式)
②使用集合自身地remove方法删除(单个删除可以，当利用循环删除多个时就不行了)
因为每删除一个元素，就得需要一个新的迭代器，而此时用的还是旧的，所以就会出错。
*/


public class 测试程序 {                                                                                                             
                                                                                                                                
                                                                                                                                
    public static void main(String[] args)  {                                                                                   
    
        //1.创建集合
        Collection o = new ArrayList();
        
        //2.添加元素
        o.add(1);
        o.add(2);
        o.add(2);
        
        //3.使用迭代器遍历
        Iterator it = o.iterator();
        
        while(it.hasNext()) {
            //使用迭代器的remove方法(推荐)
            
            it.next();
            //删除
            it.remove();
            
            
            /*//使用集合自身所带的remove方法删除
            Object element = it.next();
            
            //删除
            o.remove(element);*/
             
        }
    
        System.out.println(o.size());
    }                                                                                                                           
}