猿创征文|【JavaSE】 Collection集合全家桶

目录

  • Collection集合
    • 概述
    • Collection集合继承结构图
      • 详细介绍
    • Collection接口的常用方法
      • 详细介绍
      • Collection的两个方法需要注意的问题
    • Iterator迭代器
      • 迭代器的代码实现
      • 迭代器和remove方法冲突问题
    • 增强for循环
  • Collection集合的子类
    • List接口独有的常用方法
    • ArratList集合介绍
      • 三种构造方法
    • LinkedList集合
      • 链表的优缺点
      • 常用方法
    • Vector集合
    • HashSet集合
    • TreeSet集合
    • 可变参数
  • Collections集合工具类
    • addAll和shuffle方法
    • sort方法1
    • sort方法2

Collection集合

概述

什么是集合?有什么用?
数组其实就是一个集合。集合实际上就是一个容器。可以来容纳其它类型的数据。
集合为什么说在开发中使用较多?
集合是一个容器,是一个载体,可以一次容纳多个对象。在实际开发中,假设连接数据库,数据库当中有10条记录,那么假设把这10条记录查询出来,在java程序中会将10条数据封装成10个java对象,然后将10个java对象放到某一个集合当中,将集合传到前端,然后遍历集合,将一个数据一个数据展现出来。

集合不能直接存储基本数据类型,另外集合也不能直接存储java对象,集合当中存储的都是java对象的内存地址。(或者说集合中存储的是引用。)
list.add(100);//自动装箱Integer
注意: 集合在iava中本身是一个容器,是一个对象。集合中任何时候存储的都是"引用"。

集合和数组既然都是容器,它们有啥区别呢? 。
数组的长度是固定的。集合的长度是可变的。
数组中存储的是同一类型的元素,可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候,使用集合进行存储。

在iava中每一个不同的集合,底层会对应不同的数据结构。往不同的集合中存储元素,等于将数据放到了不同的数据结构当中。什么是数据结构?数据存储的结构就是数据结构。不同的数据结构,数据存储方式不同。例如:
数组、二叉树、链表、哈希表…以上这些都是常见的数据结构,
你往集合c1中放数据,可能是放到数组上了。你往集合c2中放数据,可能是放到二叉树上了。
你使用不同的集合等同于使用了不同的数据结构。不同集合对应不同数据结构。
你在iava集合这一章节,你需要掌握的不是精通数据结构。java中已经将数据结构实现了,已经写好了这些常用的集合类,你只需要掌握怎么用?在什么情况下选择哪一种合适的集合去使用即可。
new ArrayList();创建一个集合,底层是数组。
new LinkedList();创建一个集合对象,底层是链表。
new TreeSet();创建一个集合对象,底层是二叉树。

集合在java JDK中哪个包下?
java.util.*; 所有的集合类和集合接口都在java util包下。
为了让大家掌握集合这块的内容,最好能将集合的继承结构图背会!!! 集合整个这个体系是怎样的一个结构,需要有印象,后面会介绍继承结构图

在java中集合分为两大类:
一类是单个方式存储元素: 单个方式存储元素,这一类集合中超级父接口:java.util.Collection
一类是以键值对儿的方式存储元素 以键值对的方式存储元素,这一类集合中超级父接口:java.util.Map; 本篇文章会详细介绍Collection集合的全家桶。

Collection集合继承结构图

猿创征文|【JavaSE】 Collection集合全家桶_第1张图片
以后的开发主要是用这几个实现类,所以在这个图上就介绍这几个,并不代表就只有这些。

详细介绍

Iterable:可迭代的,可遍历的,所有集合元素都是可迭代的,可遍历的。所有集合继承 Iterable的含义是,所有集合都是可迭代的。

Iterator:集合的迭代器对象。 Collection继承Iterable中的iterator()方法,调用此方法返回Iterator迭代器对象,这个迭代器对象中有 hasNext()方法、next()方法、remove()方法来完成集合的遍历。

Collection:定义的是所有单列集合中共性的方法,所有单列集合都可以使用共性的方法,没有带索引的方法。

List集合存储元素特点:有序可重复,存储的元素有下标。有序实际上是说存进去是这个顺序,取出来还是这个顺序,这里的顺序不是说按照大小排序。有序是因为List集合都有下标,下标从0开始,以1递增。

ArrayList集合:底层采用了数组这种数据结构,ArrayList 集合是非线程安全的。

LinkedList集合:底层采用了双向链表数据结构,对于链表数据结构来说,随机增删效率较高,检索效率较低,链表中的元素,在空间存储上,内存地址不连续。

Vector集合:底层采用了数组这种数据结构,Vector集合是线程安全的,Vector所有方法都有syndronized关键字修饰,所以线程安全,但是效率较低,现在保证线程安全有别的方案,所以Vector使用较少了。

Set焦合存储元素特点:无字不可重复,无序表示存进去是这个顺序,取出来就不一定是这个顺字了,另外Set集合中元素没有下标。 Set集合中的元素还不能重复。

HashSet集合:在new的时候,底层实际上new了一个HashMap集合。向HashSet集合中存储元素,实际上是存储到HashMap集合中了。HashMap集合是一个哈希表数据结构,HashSet集合初始化容量16。扩容:扩容之后是原容量的2倍。

SortedSet集合存储元素的特点:由于继承了Set集合,所以它的特点也是无序不可重复,但是放在SortedSet集合中的元素可以自动排序。我们成为可排序集合。放到该集合中的元素是自动按照大小顺序排序的。

TreeSet集合:底层实际上是TreeMap newTreeSet集合的时候,底层实际上 new了一个TreeMap集合。往TreeSet集合中放数据的时候,实际上是将数据放到TreeMap集合中了。TreeMap集合底层采用了二叉树数据结构。

Collection接口的常用方法

猿创征文|【JavaSE】 Collection集合全家桶_第2张图片

详细介绍

public class Collection集合常用方法 {
    public static void main(String[] args) {
        //创建集合对象 可以使用多态
        Collection<String> coll =new ArrayList<>();
        System.out.println(coll); //重写了toString方法  []

        /*
            public boolean add(E e): 把给定的对象添加到当前集合
            返回值是一个Boolean值,一般都返回ture 所以可以不用接收
            添加成功返回ture,一般都成功
         */
        boolean b1 = coll.add("张三");
        System.out.println("b1:"+b1); //b1:true
        System.out.println(coll); //[张三]
        coll.add("李四");
        coll.add("王五");
        coll.add("赵六");
        coll.add("田七");
        System.out.println(coll); //[张三, 李四, 王五, 赵六, 田七]

        /*
            public boolean remove(E e): 把给定的对象在当前集合中删除。
            返回值是一个boolean值,集合中存在元素,删除元素,返回ture
                                 集合中不存在元素,删除失败,返回false
         */
        boolean b2 = coll.remove("赵六");
        System.out.println("b2:"+b2); //b2:true

        boolean b3 = coll.remove("赵四");
        System.out.println("b3:"+b3); //b3:false 不存在 所以返回false
        System.out.println(coll); //[张三, 李四, 王五, 田七]

        /*
            public boolean contains(E e): 判断当前集合是否包含给定的对象
            包含返回 ture
            不包含返回 false
         */
        boolean b4 = coll.contains("李四");
        System.out.println("b4:"+b4);  //b4:true

        boolean b5 = coll.contains("赵四");
        System.out.println("b5:"+b5); //b5:false

        /*
            public boolean isEmpty(): 判断集合是否为空
            集合为空:返回ture
            集合不为空:返回false
         */
        boolean b6 = coll.isEmpty();
        System.out.println("b6:"+b6); //b6:false


        /*
            public int size(): 返回集合中元素的个数
         */
        int size = coll.size();
        System.out.println("size:"+size); //size:4

        /*
            public Onject[] toArray():把集合的元素,存储到数组中
         */
        Object[] arr = coll.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        /*
            public void clear() :清空集合所有元素。但是不删除集合,集合还存在
         */
        coll.clear();
        System.out.println(coll); //[]
        System.out.println(coll.isEmpty()); //true

        /*这些就是这个集合通用的方法
        上面玩的是多态 :把ArrayList集合变成别的子类集合,一样通用
                */
    }
}

Collection的两个方法需要注意的问题

猿创征文|【JavaSE】 Collection集合全家桶_第3张图片
猿创征文|【JavaSE】 Collection集合全家桶_第4张图片猿创征文|【JavaSE】 Collection集合全家桶_第5张图片

猿创征文|【JavaSE】 Collection集合全家桶_第6张图片
在这里插入图片描述
猿创征文|【JavaSE】 Collection集合全家桶_第7张图片

Iterator迭代器

猿创征文|【JavaSE】 Collection集合全家桶_第8张图片

猿创征文|【JavaSE】 Collection集合全家桶_第9张图片

迭代器的代码实现

猿创征文|【JavaSE】 Collection集合全家桶_第10张图片

public class 迭代器 {
    public static void main(String[] args) {
        //创建一个集合对象
        Collection<String> coll = new ArrayList<>();
        //往集合添加元素
        coll.add("飞飞");
        coll.add("东海");
        coll.add("彬彬");
        coll.add("家庆");
        coll.add("奥迪");
        coll.add("雨朋");

        /*
            1.使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)
            注意:
                Iterator 接口也是有泛型的,迭代器的泛型跟着集合走,
                集合是什么泛型,迭代器就是什么泛型
         */
        // 多态  接口                  实现类对象
        Iterator<String> it = coll.iterator();
        //2.使用Iterator接口中的方法hasNext判断还有没有下一个元素
        boolean b = it.hasNext();
        System.out.println(b); //ture 返回ture 有元素
        //3.使用Iterator接口中的方法next取出集合下一个元素
        String next = it.next();
        System.out.println(next); //游飞

       /*
            后面重复上面两行代码,就可以取出后面的,一直到最后,没有下一个元素返回false
            发现使用迭代器取出集合中元素的代码,是一个重复的过程
            所以我们可以使用循环优化
            不知道集合中有多少元素,使用while循环
            循环结束条件,hasNext方法返回false
       */
        while (it.hasNext()){
            String e = it.next();
            System.out.println(e);
        }
    }
}

迭代器和remove方法冲突问题

猿创征文|【JavaSE】 Collection集合全家桶_第11张图片
猿创征文|【JavaSE】 Collection集合全家桶_第12张图片
总结:猿创征文|【JavaSE】 Collection集合全家桶_第13张图片

增强for循环

猿创征文|【JavaSE】 Collection集合全家桶_第14张图片

注意:增强for循环必须有遍历的目标。
目标只能是Collection或者是数组
增强for循环仅仅只能是作为遍历操作出现
工作或者学习过程中,只要是遍历,就使用增强for循环

Collection集合的子类

List接口独有的常用方法

猿创征文|【JavaSE】 Collection集合全家桶_第15张图片
举例介绍

public class List接口常用方法 {
    public static void main(String[] args) {
        List list = new ArrayList();

        list.add("aa");
        list.add("bb");
        //add()在列表的指定位置上插入指定元素(第一个参数是下标)
        //这个方法使用不多,因为对于ArrayList集合来说效率不较
        list.add(1,"cc");

        //get()根据下标获取元素
        Object o = list.get(1);
        System.out.println(o);//cc

        //因为有下标,所以List集合有自己比较特殊的遍历方式
        //通过下标遍历。【List集合特有的方式,Set没有】
        for (int i = 0; i < list.size(); i++) {
            Object o1 = list.get(i);
            System.out.println(o1); //aa cc bb
        }

        //indexOf 获取指定对象第一次出现的索引
        int index = list.indexOf("cc");
        System.out.println(index); //1

        //lastIndexOf 获取指定对象最后一次出现的索引
        int index1 = list.lastIndexOf("bb");
        System.out.println(index1); //2

        System.out.println("======================");
        //remove:删除指定下标位置的元素。
        list.remove(0);
        for (int i = 0; i < list.size(); i++) {
            Object o1 = list.get(i);
            System.out.println(o1); // cc bb
        }

        //set:修改指定位置的元素
        list.set(1,"aaa");

        System.out.println("======================");

        for (int i = 0; i < list.size(); i++) {
            Object o1 = list.get(i);
            System.out.println(o1); // cc aaa
        }


    }
}

ArratList集合介绍

猿创征文|【JavaSE】 Collection集合全家桶_第16张图片
猿创征文|【JavaSE】 Collection集合全家桶_第17张图片
在这里插入图片描述

三种构造方法


/**
 * 三种构造方法
 */

public class ArratList集合 {
    public static void main(String[] args) {
        //无参构造 默认初始化容量为10
        List list = new ArrayList();

        //有参构造更改初始化容量为20
        List list1 = new ArrayList(20);

        //创建一个HashSet集合
        Collection c =new HashSet();
        c.add(1);
        c.add(2);
        c.add(6);
        c.add(4);

        //通过这个构造方法 可以将HashSet集合转换成List集合
        List list2 =new ArrayList(c);
        for (int i =0;i<list2.size();i++){
            System.out.println(list2.get(i));
        }
    }
}

LinkedList集合

猿创征文|【JavaSE】 Collection集合全家桶_第18张图片

链表的优缺点

猿创征文|【JavaSE】 Collection集合全家桶_第19张图片

常用方法

private static void domed01() {
        /*
            public void addFirst(E w):将指定元素添加到此列表的开头 此方法等效push
            public void addLast(E e):将指定元素添加到此列表的结尾  此方法等效于add
            public void push(E e):将元素推入此列表所表示发堆栈 此方法等效addFirst
         */

        // 创建LinkedList
        LinkedList<String> lin = new LinkedList<String>();
        // 使用add方法往集合添加元素
        lin.add("a");
        lin.add("b");
        lin.add("c");
        System.out.println(lin); // [a, b, c]

        //public void addFirst(E w):将指定元素添加到此列表的开头 此方法等效push
//        lin.addFirst("www");
        lin.push("www");
        System.out.println(lin); //[www, a, b, c]

        //public void addLast(E e):将指定元素添加到此列表的结尾 此方法等效于add
        lin.addLast("com");
        System.out.println(lin);//[www, a, b, c, com]
    }

    private static void domed02() {
        /*
            public E getFirst():返回此列表第一个元素
            public E getLast():返回此列表最后一个元素
         */

        // 创建LinkedList
        LinkedList<String> lin = new LinkedList<String>();
        // 使用add方法往集合添加元素
        lin.add("a");
        lin.add("b");
        lin.add("c");

//        lin.clear(); //清空集合中的元素,在获取集合中的元素会抛出NoSuchElementException
        //添加判断
        // public boolean isEmpty(): 如果列表不包含元素,则返回ture ;空的返回ture
        if (!lin.isEmpty()) { //!lin.isEmpty()添加取反,不是空的返回ture,才执行;是空的就不获取了
            String first = lin.getFirst();
            System.out.println(first); //a
            String last = lin.getLast();
            System.out.println(last); //c
        }

    }

    private static void domed03() {
        /*
            public E removeFirst(): 移除并返回此列表的第一个元素
            public E removeLast():移除并返回此列表的最后一个元素
            public E pop(): 从此列表所表示的堆栈处弹出一个元素。此方法相当于removeFirst
         */

        // 创建LinkedList
        LinkedList<String> lin = new LinkedList<String>();
        // 使用add方法往集合添加元素
        lin.add("a");
        lin.add("b");
        lin.add("c");
        System.out.println(lin); // [a, b, c]

        String s = lin.removeFirst();
//        String pop = lin.pop();
        System.out.println("被移除的以一个元素:"+s); //被移除的以一个元素:a
        String s1 = lin.removeLast();
        System.out.println("被移除的最后一个元素:"+s1); //被移除的最后一个元素:c
    }

Vector集合

猿创征文|【JavaSE】 Collection集合全家桶_第20张图片
猿创征文|【JavaSE】 Collection集合全家桶_第21张图片

HashSet集合

猿创征文|【JavaSE】 Collection集合全家桶_第22张图片
在这里插入图片描述
代码示例

public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        //使用add方法添加元素
        set.add(1);
        set.add(3);
        set.add(2);
        set.add(1);
        System.out.println(set); //[1, 2, 3]

        //使用迭代器遍历
        Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()){
            Integer next = iterator.next();
            System.out.println(next);
        }

        //使用增强for
        for (Integer integer : set) {
            System.out.println(integer);
        }
    }

TreeSet集合

猿创征文|【JavaSE】 Collection集合全家桶_第23张图片
在这里插入图片描述

猿创征文|【JavaSE】 Collection集合全家桶_第24张图片
猿创征文|【JavaSE】 Collection集合全家桶_第25张图片

可变参数

猿创征文|【JavaSE】 Collection集合全家桶_第26张图片
代码示例

 public static void main(String[] args) {
//        int i = add();
//        int i = add(10);
//        int i = add(10,20);
        int i = add(10,20,30,40,50,60,70,80,90,100);
        System.out.println(i);
        aa(1,2.3,"iws");
    }
    /*
        定义计算(0-n)个整数和的方法
        已知:计算整数的和,数据类型已经确定int
        但是参数的个数不确定,不知道要计算几个整数的和,就可以使用可变参数

        调用add();方法,就会创建一个长度为0的数组,new int[0]
        调用add(10);方法,就会创建一个长度为1的数组,存储传递过来的参数 new int[]{10};
        调用add(10,20);方法,就会创建一个长度为2的数组,存储传递过来的参数 new int[]{10,20};
        调用add(10,20,30,40,50,60,70,80,90,100);方法,就会创建一个长度为10的数组,存储传递过来的参数
        new int[]{10,20,30,40,50,60,70,80,90,100};

        add(10);
     */
    public static int add(int...arr){
//        System.out.println(arr); //[I@7c30a502 底层是一个数组
//        System.out.println(arr.length);//0,1,2,10
        //定义一个初始化变量,记录累加和求和
        int sum = 0;
        //遍历数组,获取数组中的每一个元素
        for (int i : arr) {
            sum+=i;
        }
        //把求和结果返回
        return sum;
    }
    //可变参数终极写法
    public static void aa(Object...obj){
        System.out.println(obj.length);
    }
}

Collections集合工具类

猿创征文|【JavaSE】 Collection集合全家桶_第27张图片
猿创征文|【JavaSE】 Collection集合全家桶_第28张图片

addAll和shuffle方法


代码示例

/*
    public static  boolean addAll(collection c,T...elements):往集合添加多个元素
    public static void shuffle(List list) 打乱顺序:打乱集合顺序
 */
public class aa {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        //往集合添加多个元素
        list.add("a");
        list.add("b");
        list.add("c"); //要一个一个加
        //public static  boolean addAll(collection c,T...elements):往集合添加多个元素
        Collections.addAll(list,"a","b","c"); //它的参数是可变参数,可以传递任意多个元素
        System.out.println(list); //[a, b, c, a, b, c]

        //public static void shuffle(List list) 打乱顺序:打乱集合顺序
        Collections.shuffle(list);
        System.out.println(list); //[c, a, b, b, c, a] 每次重复的都不一样

    }
}

sort方法1

猿创征文|【JavaSE】 Collection集合全家桶_第29张图片
代码示例

/*
    public static  void sort(List list):将集合中元素按照,默认规则排序  (里面只能传递list集合不能set)
    注意事项:
        sort(List list)使用前提 (传递的是自定义类型的话)
        被排序的集合里面存储的元素,必须实现Comparable接口,重写接口中的方法compareTo定义排序的规则
    Comparable排序规则:
        自己(this)-参数;升序
 */
public class bb {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(3);
        list01.add(2);
        System.out.println(list01);//[1, 3, 2]

        //public static  void sort(List list):将集合中元素按照,默认规则排序
        Collections.sort(list01); // 默认是升序
        System.out.println(list01); //[1, 2, 3]

        ArrayList<String> list02 = new ArrayList<>();
        Collections.addAll(list02,"a","c","b");
        System.out.println(list02); //[a, c, b]

        Collections.sort(list02); // 默认是升序
        System.out.println(list02); //[a, b, c]

        //对自定义类型排序
        ArrayList<person> list03 = new ArrayList<>();
        list03.add(new person("张三",18));
        list03.add(new person("李四",20));
        list03.add(new person("王五",15));
        System.out.println(list03);//[person{name='张三', age=18}, person{name='李四', age=20}, person{name='王五', age=15}]
        Collections.sort(list03);
        System.out.println(list03);//[person{name='王五', age=15}, person{name='张三', age=18}, person{name='李四', age=20}]
    }
}

public class person implements Comparable<person>{
    private String name;
    private int age;

    //重写排序的规则
    @Override
    public int compareTo(person o) {
//        return 0; //认为元素都是相同的
        //自定义比较的规则,比较两个人的年龄(this,person)
        return this.getAge()-o.getAge(); //年龄升序排序
//        return o.getAge()-this.getAge(); //年龄降序排序
    }

    public person() {
    }
    public person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
}

sort方法2

猿创征文|【JavaSE】 Collection集合全家桶_第30张图片
代码示例

public class cc {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(3);
        list01.add(2);
        System.out.println(list01);//[1, 3, 2]
        Collections.sort(list01, new Comparator<Integer>() { //使用匿名内部类
            //重写比较的规则
            @Override
            public int compare(Integer o1, Integer o2) {
//                return o1-o2;//升序
                return o2-o1;//降序
            }
        });
        System.out.println(list01); //[3, 2, 1]

        //比较自定义类型
        ArrayList<Student> list02 = new ArrayList<>();
        list02.add(new Student("迪丽热巴",18));
        list02.add(new Student("古力娜扎",20));
        list02.add(new Student("杨幂",17));
        System.out.println(list02);
        //[Student{name='迪丽热巴', age=18}, Student{name='古力娜扎', age=20}, Student{name='杨幂', age=17}]

        Collections.sort(list02, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //按照年龄升序排序
                return o1.getAge()- o2.getAge();
            }
        });
        System.out.println(list02);
        //[Student{name='杨幂', age=17}, Student{name='迪丽热巴', age=18}, Student{name='古力娜扎', age=20}]
    }
}


public class Student {
    private String name;
    private int age;

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

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

你可能感兴趣的:(JAVA学习,java,数据结构,链表)