黑马Java——集合进阶(List、Set、泛型、树)

黑马Java——集合进阶(List、Set、泛型、树)_第1张图片

一、集合的体系结构

黑马Java——集合进阶(List、Set、泛型、树)_第2张图片

1、单列集合(Collection)

黑马Java——集合进阶(List、Set、泛型、树)_第3张图片

 二、Collection集合

1、Collection常见方法

黑马Java——集合进阶(List、Set、泛型、树)_第4张图片

1.1代码实现:

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

public class A01_CollectionDemo1 {
    public static void main(String[] args) {
/*
        public boolean add(E e)             添加
        public void clear()                 清空
        public boolean remove(E e)          删除
        public boolean contains(Object obj) 判断是否包含
        public boolean isEmpty()            判断是否为空
        public int size()                   集合长度


       注意点:
        Collection是一个接口,我们不能直接创建他的对象。
        所以,现在我们学习他的方法时,只能创建他实现类的对象。
        实现类:ArrayList
*/
        //目的:为了学习Collection接口里面的方法
        //自己在做一些练习的时候,还是按照之前的方式去创建对象。
        Collection coll = new ArrayList<>();


        //1.添加元素
        //细节1:如果我们要往List系列集合中添加数据,那么方法永远返回true,因为List系列的是允许元素重复的。
        //细节2:如果我们要往Set系列集合中添加数据,如果当前要添加元素不存在,方法返回true,表示添加成功。
        //                                       如果当前要添加的元素已经存在,方法返回false,表示添加失败。
        //                                       因为Set系列的集合不允许重复。
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        System.out.println(coll);

        //2.清空
        //coll.clear();

        //3.删除
        //细节1:因为Collection里面定义的是共性的方法,所以此时不能通过索引进行删除。只能通过元素的对象进行删除。
        //细节2:方法会有一个布尔类型的返回值,删除成功返回true,删除失败返回false
        //如果要删除的元素不存在,就会删除失败。
        System.out.println(coll.remove("aaa"));
        System.out.println(coll);


        //4.判断元素是否包含
        //细节:底层是依赖equals方法进行判断是否存在的。
        //所以,如果集合中存储的是自定义对象,也想通过contains方法来判断是否包含,那么在javabean类中,一定要重写equals方法。
        boolean result1 = coll.contains("bbb");
        System.out.println(result1);



        //5.判断集合是否为空
        boolean result2 = coll.isEmpty();
        System.out.println(result2);//false


        //6.获取集合的长度
        coll.add("ddd");
        int size = coll.size();
        System.out.println(size);//3

    }
}

1.2 contains方法重写equals方法示例:(idea可自动重写)

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

public class A02_CollectionDemo2 {
    public static void main(String[] args) {
        //1.创建集合的对象
        Collection coll = new ArrayList<>();


        //2.创建三个学生对象
        Student s1 = new Student("zhangsan",23);
        Student s2 = new Student("lisi",24);
        Student s3 = new Student("wangwu",25);


        //3.把学生对象添加到集合当中
        coll.add(s1);
        coll.add(s2);
        coll.add(s3);

        //4.判断集合中某一个学生对象是否包含
        Student s4 = new Student("zhangsan",23);
        //因为contains方法在底层依赖equals方法判断对象是否一致的。
        //如果存的是自定义对象,没有重写equals方法,那么默认使用Object类中的equals方法进行判断,而Object类中equals方法,依赖地址值进行判断。
        //需求:如果同姓名和同年龄,就认为是同一个学生。
        //所以,需要在自定义的Javabean类中,重写equals方法就可以了。
        System.out.println(coll.contains(s4));
    }
}

重写

 @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);
    }

2、Collection的遍历方式(3种)

Collection的遍历的三种方式:

  • 迭代器遍历
  • 增强for循环
  • Lambda表达式

2.1迭代器遍历

黑马Java——集合进阶(List、Set、泛型、树)_第5张图片

迭代器不依赖索引

 黑马Java——集合进阶(List、Set、泛型、树)_第6张图片

循环遍历: 

 //2.获取迭代器对象
        //迭代器就好比是一个箭头,默认指向集合的0索引处
        Iterator it = coll.iterator();
        //3.利用循环不断的去获取集合中的每一个元素
        while(it.hasNext()){
            //4.next方法的两件事情:获取元素并移动指针
            String str = it.next();
            System.out.println(str);
        }

示例代码:(不依赖索引,而是通过指针移动的方式)

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

public class A03_CollectionDemo3 {
    public static void main(String[] args) {
        /*
            Collection系列集合三种通用的遍历方式:
                1.迭代器遍历
                2.增强for遍历
                3.lambda表达式遍历


             迭代器遍历相关的三个方法:
                    Iterator iterator()  :获取一个迭代器对象
                    boolean hasNext()       :判断当前指向的位置是否有元素
                    E next()                :获取当前指向的元素并移动指针
        */

        //1.创建集合并添加元素
        Collection coll = new ArrayList<>();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");

        //2.获取迭代器对象
        //迭代器就好比是一个箭头,默认指向集合的0索引处
        Iterator it = coll.iterator();
        //3.利用循环不断的去获取集合中的每一个元素
        while(it.hasNext()){
            //4.next方法的两件事情:获取元素并移动指针
            String str = it.next();
            System.out.println(str);
        }

    }
}

迭代器书写的小细节:黑马Java——集合进阶(List、Set、泛型、树)_第7张图片

迭代器细节注意点:

 
        迭代器的细节注意点:
            1.报错NoSuchElementException
            2.迭代器遍历完毕,指针不会复位
            3.循环中只能用一次next方法
            4.迭代器遍历时,不能用集合的方法进行增加或者删除
                暂时当做一个结论先行记忆,在今天我们会讲解源码详细的再来分析。
                如果我实在要删除:那么可以用迭代器提供的remove方法进行删除。
                如果我要添加,暂时没有办法。
       
//当上面循环结束之后,迭代器的指针已经指向了最后没有元素的位置
        //System.out.println(it.next());//NoSuchElementException

        //迭代器遍历完毕,指针不会复位
        System.out.println(it.hasNext());

        //如果我们要继续第二次遍历集合,只能再次获取一个新的迭代器对象
        Iterator it2 = coll.iterator();
        while(it2.hasNext()){
            String str = it2.next();
            System.out.println(str);
        }

 



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

public class A05_CollectionDemo5 {
    public static void main(String[] args) {
     

        //1.创建集合并添加元素
        Collection coll = new ArrayList<>();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");
        coll.add("eee");

        //2.获取迭代器对象
        //迭代器就好比是一个箭头,默认指向集合的0索引处
        Iterator it = coll.iterator();
        //3.利用循环不断的去获取集合中的每一个元素
        while(it.hasNext()){
            //4.next方法的两件事情:获取元素,并移动指针
            String str = it.next();
            if("bbb".equals(str)){
                //coll.remove("bbb");
                it.remove();
            }
        }
        System.out.println(coll);

    }
}

小结:

Interator方法:

黑马Java——集合进阶(List、Set、泛型、树)_第8张图片

黑马Java——集合进阶(List、Set、泛型、树)_第9张图片

2.2增强for循环

黑马Java——集合进阶(List、Set、泛型、树)_第10张图片

示例代码:

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

public class A06_CollectionDemo6 {
    public static void main(String[] args) {
       /* Collection系列集合三种通用的遍历方式:
        1.迭代器遍历
        2.增强for遍历
        3.lambda表达式遍历

        增强for格式:
            for(数据类型 变量名: 集合/数组){

            }

        快速生成方式:
            集合的名字 + for 回车

        */


        //1.创建集合并添加元素
        Collection coll = new ArrayList<>();
        coll.add("zhangsan");
        coll.add("lisi");
        coll.add("wangwu");

        //2.利用增强for进行遍历
        //注意点:
        //s其实就是一个第三方变量,在循环的过程中依次表示集合中的每一个数据
        for(String s : coll){
            s = "qqq";
        }

        System.out.println(coll);//zhangsan lisi wangwu
    }
}

黑马Java——集合进阶(List、Set、泛型、树)_第11张图片

 2.3Lambda表达式遍历

黑马Java——集合进阶(List、Set、泛型、树)_第12张图片

示例代码:

//1.创建集合并添加元素
        Collection coll = new ArrayList<>();
        coll.add("zhangsan");
        coll.add("lisi");
        coll.add("wangwu");
        //2.利用匿名内部类的形式
        //底层原理:
        //其实也会自己遍历集合,依次得到每一个元素
        //把得到的每一个元素,传递给下面的accept方法
        //s依次表示集合中的每一个数据
       /* coll.forEach(new Consumer() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/

        //lambda表达式
        coll.forEach(s -> System.out.println(s));

 3、小结

黑马Java——集合进阶(List、Set、泛型、树)_第13张图片

 

 

三、List集合

黑马Java——集合进阶(List、Set、泛型、树)_第14张图片
1、List集合特有的方法(操作索引的4个方法)

黑马Java——集合进阶(List、Set、泛型、树)_第15张图片
示例代码:

import java.util.ArrayList;
import java.util.List;

public class A01_ListDemo1 {
    public static void main(String[] args) {
       /*

        List系列集合独有的方法:
            void add(int index,E element)       在此集合中的指定位置插入指定的元素
            E remove(int index)                 删除指定索引处的元素,返回被删除的元素
            E set(int index,E element)          修改指定索引处的元素,返回被修改的元素
            E get(int index)                    返回指定索引处的元素
        */


        //1.创建一个集合
        List list = new ArrayList<>();

        //2.添加元素
        list.add("aaa");
        list.add("bbb");//1
        list.add("ccc");


        //void add(int index,E element)       在此集合中的指定位置插入指定的元素
        //细节:原来索引上的元素会依次往后移
        //list.add(1,"QQQ");

        //E remove(int index)                 删除指定索引处的元素,返回被删除的元素
        //String remove = list.remove(0);
        //System.out.println(remove);//aaa


        //E set(int index,E element)          修改指定索引处的元素,返回被修改的元素
        //String result = list.set(0, "QQQ");
        //System.out.println(result);

        // E get(int index)                    返回指定索引处的元素
        //String s = list.get(0);
        //System.out.println(s);


        //3.打印集合
        System.out.println(list);


    }
}

add方法:


        //1.创建一个集合
        List list = new ArrayList<>();

        //2.添加元素
        list.add("aaa");
        list.add("bbb");//1
        list.add("ccc");


        //void add(int index,E element)       在此集合中的指定位置插入指定的元素
        //细节:原来索引上的元素会依次往后移
        list.add(1,"QQQ");

        

remove方法:


        E remove(int index)                 //删除指定索引处的元素,返回被删除的元素
        String remove = list.remove(0);
        System.out.println(remove);//aaa


List删除的小细节:

//List系列集合中的两个删除的方法
        //1.直接删除元素
        //2.通过索引进行删除

        //1.创建集合并添加元素
        List list = new ArrayList<>();

        list.add(1);
        list.add(2);
        list.add(3);


        //2.删除元素
        //请问:此时删除的是1这个元素,还是1索引上的元素?
        //为什么?
        //因为在调用方法的时候,如果方法出现了重载现象
        //优先调用,实参跟形参类型一致的那个方法。

        //list.remove(1);


        //手动装箱,手动把基本数据类型的1,变成Integer类型
        Integer i = Integer.valueOf(1);

        list.remove(i);

        System.out.println(list);

set & get方法:


        //E set(int index,E element)          修改指定索引处的元素,返回被修改的元素
        //String result = list.set(0, "QQQ");
        //System.out.println(result);

        // E get(int index)                    返回指定索引处的元素
        //String s = list.get(0);
        //System.out.println(s);

2、List集合的遍历方式(5种)

  • 迭代器遍历
  • 列表迭代器遍历
  • 增强for遍历
  • Lambda表达式遍历
  • 普通for循环(因为List集合存在索引)

2.1迭代器遍历:


        /*
            List系列集合的五种遍历方式:
                1.迭代器
                2.列表迭代器
                3.增强for
                4.Lambda表达式
                5.普通for循环
         */


        //创建集合并添加元素
        List list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        //1.迭代器
        Iterator it = list.iterator();
        while(it.hasNext()){
            String str = it.next();
            System.out.println(str);
        }


        

2.2增强for:


        //2.增强for
        //下面的变量s,其实就是一个第三方的变量而已。
        //在循环的过程中,依次表示集合中的每一个元素
        for (String s : list) {
            System.out.println(s);
        }

        

2.3Lambda表达式



        //3.Lambda表达式
        //forEach方法的底层其实就是一个循环遍历,依次得到集合中的每一个元素
        //并把每一个元素传递给下面的accept方法
        //accept方法的形参s,依次表示集合中的每一个元素
        list.forEach(s->System.out.println(s) );


       
   

2.4普通for循环


        //4.普通for循环
        //size方法跟get方法还有循环结合的方式,利用索引获取到集合中的每一个元素
        for (int i = 0; i < list.size(); i++) {
            //i:依次表示集合中的每一个索引
            String s = list.get(i);
            System.out.println(s);
        }

    

2.5列表迭代器(ListIterator,继承于Iterator)

黑马Java——集合进阶(List、Set、泛型、树)_第16张图片


        // 5.列表迭代器
        //获取一个列表迭代器的对象,里面的指针默认也是指向0索引的

        //额外添加了一个方法:在遍历的过程中,可以添加元素
        ListIterator it = list.listIterator();
        while(it.hasNext()){
            String str = it.next();
            if("bbb".equals(str)){
                //qqq
                it.add("qqq");
            }
        }
   

但迭代器默认指向0索引,想要使用previous方法需要先移动到后面

小结

黑马Java——集合进阶(List、Set、泛型、树)_第17张图片

四、数据结构(常见有8种)

1、什么是数据结构呢?

数据结构就是计算机存储、组织数据的方式

不同的业务场景要选择不同的数据结构

2、数据结构概述

黑马Java——集合进阶(List、Set、泛型、树)_第18张图片

常见的数据结构:

栈、队列、数组、链表、二叉树、二叉树查找


3、栈(后进先出,先进后出)

黑马Java——集合进阶(List、Set、泛型、树)_第19张图片
 

4、队列(先进先出,后进后出)

  • 数据从后端进入队列模型的过程称为:入队列
  • 数据从前端离开队列模型的过程称为:出队列

黑马Java——集合进阶(List、Set、泛型、树)_第20张图片


5、栈与队列小结

黑马Java——集合进阶(List、Set、泛型、树)_第21张图片


6、数组

黑马Java——集合进阶(List、Set、泛型、树)_第22张图片
7、链表(与数组相对)

黑马Java——集合进阶(List、Set、泛型、树)_第23张图片

黑马Java——集合进阶(List、Set、泛型、树)_第24张图片

黑马Java——集合进阶(List、Set、泛型、树)_第25张图片

黑马Java——集合进阶(List、Set、泛型、树)_第26张图片

双向链表可以提高查询效率:

黑马Java——集合进阶(List、Set、泛型、树)_第27张图片

小结

黑马Java——集合进阶(List、Set、泛型、树)_第28张图片

五、ArrayList原码分析

黑马Java——集合进阶(List、Set、泛型、树)_第29张图片

 1、ArrayList集合底层原理

黑马Java——集合进阶(List、Set、泛型、树)_第30张图片

2、ArrayList源码分析

idea快捷键:Alt + 7:列出方法大纲

添加的数据长度不超过10:黑马Java——集合进阶(List、Set、泛型、树)_第31张图片

 一次添加多个,超过10,但不超过15:

黑马Java——集合进阶(List、Set、泛型、树)_第32张图片

六、LinkedList集合

黑马Java——集合进阶(List、Set、泛型、树)_第33张图片

1、LinkedList特有方法

黑马Java——集合进阶(List、Set、泛型、树)_第34张图片

2、LinkedList源码分析

黑马Java——集合进阶(List、Set、泛型、树)_第35张图片

3、迭代器源码分析 黑马Java——集合进阶(List、Set、泛型、树)_第36张图片

 

modCount:集合变化的次数

expectedModCount:创建对象时,传递过来的次数

结论:
在以后如何避免并发修改异常
在使用迭代器或者是增强for遍历集合的过程中,不要使用集合的方法去添加
或者删除元素即可

你可能感兴趣的:(java,list,开发语言)