【转】Collection接口，List(ArrayList集合,LinkedList集合)，Set(HashSet集合,LinkedHashSet集合,TreeSet集合)

Collection

集合概述：

1. 集合作为容器用来存储，管理大量的对象（引用），这些集合内部用了不同的数据结构来存储元素，这些数据结构的不同导致了每种集合的增删改查效率不同。
2. 内部存储的只能是“对象引用”，子类使用多态存储基本数据类型时，泛型需要使用他们对应的包装类。
   Java常用集合体系：
   

Collection接口的常用方法

由于Collection是一个接口，所以该类中全部都是抽象方法，调用时会使用多态（父类型引用指向子类型对象）。主要了解这些方法的作用。

增：

public boolean add(E e);//把给定的对象添加到集合中

删：

1. public void clear();//清空集合中所有元素。
2. public boolean remove(E e);//把给定的对象在集合中删除

改：【无】

查：

1. public boolean contains(Object obj);//判断当前集合是否包含给定元素
2. public boolean isEmpty();//判断集合是否为空
3. public int size();//返回当前集合元素的个数。
4. public Object[] toArray();//把集合中的元素储存在数组中。
5. public Iterator iterator();//获取一个迭代器，用于遍历集合元素

代码演示：

package Collection集合的增删改查Test;

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

public class Demo01 {
    public static void main(String[] args) {
        //多态，父类型引用指向子类型对象

        Collection<String> list = new ArrayList<String>();
        //增：
        //调用子类ArrayList重写的add方法：向集合中添加元素
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        list.add("冯七");
        for (String s:list) {
            System.out.println(s);
        }
        //删：
        //clear()删除集合中所有元素：
        //list.clear();
        System.out.println(list.size());
        //remove(E e):将给定的元素在集合中删除。返回boolean值
        list.remove("张三");
        System.out.println("移除后元素有：");
        for(String s:list){
            System.out.println(s);
        }
        //改【无】
        //查：
        //contains(Object obj):查询给定元素是否存在集合中，返回boolean
        boolean boo = list.contains("李四");
        System.out.println(boo);
        //isEmpty():判断集合是否为空，返回boolean;
        boo = list.isEmpty();
        System.out.println(boo);
        //size()返回集合中元素的个数：
        int sum = list.size();
        System.out.println(sum);
        //toArray()：把集合元素储存在数组中;返回一个Object[]数组
        Object[] obj = list.toArray();
        for (int i = 0; i <obj.length ; i++) {
            System.out.println(obj[i]);
        }
    }
}

List（接口）集合-继承Collection接口

List继承了Collection接口的方法

List集合的特点：

1).有序的；

2).可以存储重复元素；(不验证元素的重复性)

3).可以通过索引访问；(因为有序的) 

新增方法：

1. 增：public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
2. 删：public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
3. 改：public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
4. 查：public E get(int index) :返回集合中指定位置的元素。
   共同特点是都带了“索引”的参数！

ArrayList集合：

1. 底层是数组。
2. 扩容机制：扩容后是原容量的1.5倍，初始容量为10.
3. 没有新增方法。使用的都是List和Collection中的定义的方法
4. 作用跟“数组”一样，作为“容器”，存储、管理大量的“对象(引用)”。
5. 查询效率高，增删效率低

常用方法

1).增：

1).public boolean add(E e)：向集合添加一个元素。返回值：对于ArrayList，永远返回true。

2).public void add(int index,E e)：向集合的index位置插入元素e。

2).删：

3). public boolean remove(Object o)：从集合中移出参数o。删除成功返回true，否则返回false。

4). public E remove(int index)：从集合中移出index位置上的元素。

3).改：

5).public E set(int index,E e)：用e替换当前集合中index位置上的元素，将“被替换的元素返回”。

4).查：

6). public E get(int index)：获取index位置上的元素；

7). public int size()：获取集合大小。和get()方法结合，就可以对集合进行遍历了。

代码演示：

测试类

package com.itheima.demo02_ArrayList概述;

import java.util.ArrayList;

public class Demo02 {
    public static void main(String[] args) {
        Student stu1 = new Student(1, "张三", 20);
        Student stu2 = new Student(2, "李四", 19);
        Student stu3 = new Student(3, "王五", 22);

        //1.创建一个ArrayList集合对象
        ArrayList<Student> stuList = new ArrayList<>();

        //1).添加：add(E e)
        stuList.add(stu1);//相当于：arr[0] = stu1;
        stuList.add(stu2);//相当于：arr[1] = stu2;
        stuList.add(stu3);//相当于：arr[2] = stu3;

        stuList.add(new Student(4, "周六", 21));//第四个元素：相当于：arr[3] = new Student(4,"周六",21);

        //2).添加：add(int index,E e)
        //向"李四"的前面插入一个new Student(5,"成龙",22);
        stuList.add(1, new Student(5, "成龙", 22));


        //3).删除：remove(Object o)：
        System.out.println("删除stu1：" + stuList.remove(stu1));

        System.out.println(stuList);

        //4).public E remove​(int index)
        System.out.println("删除索引0的元素：" + stuList.remove(0));


        //5).public E set(int index,E e)
        //将"王五"替换为：new Student(6,"柳岩",18);
        System.out.println("替换索引为1替换为'柳岩'：" + stuList.set(1, new Student(6, "柳岩", 18)));


        //6).public E get(int index)
        System.out.println("获取索引为1的元素：" + stuList.get(1));

        //7).public int size()
        System.out.println("集合大小：" + stuList.size());

        //8).size() + get()对集合遍历
        for(int i = 0; i < stuList.size() ; i++) {
            Student stu = stuList.get(i);
            System.out.println(stu);
        }
        //8.1使用iterator迭代器进行遍历：
        Iterator it = stuList.iterator();
        while(it.hasNext()){
            System.out.prinltn(it.next());
        }
        //8.2使用foreach（for增强循环）进行遍历：
        for(Student s : stuList){
            System.out.println(s);
        }

        //9).public int indexOf(Object o)：查询参数对象在集合中的索引位置
        System.out.println("stu2的索引：" + stuList.indexOf(stu2));
    }
}

Student学生类

package com.itheima.demo02_ArrayList概述;

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

    public Student() {
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

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

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

LinkedList集合：

1. 底层是链表结构（增删快，查询慢）
2. 无扩容机制

新增（常用）方法：

1. public E pop() :从此列表所表示的堆栈处弹出一个元素。【弹栈】
2. public void push(E e) :将元素推入此列表所表示的堆栈【压栈】
3. public void addLast(E e)：将元素添加到当前队列的末尾【排队】，跟add()方法一样。

代码演示：

    public class Demo02 {
    public static void main(String[] args) {
        //1.定义一个LinkedList集合
        LinkedList<String> list = new LinkedList<>();

        //2.模拟"栈"
//        list.addFirst("aaa");
        list.push("aaa");
        list.push("bbb");
        list.push("ccc");

        System.out.println("初始集合大小：" + list.size());
        //3.弹栈
        while (list.size() > 0) {
            System.out.println(list.pop());
        }

        System.out.println("----------------------------");
        //******************************************************************//
        //模拟队列
        LinkedList<String> list2 = new LinkedList<>();
        list2.addLast("aaa");//用add()也可以
        list2.addLast("bbb");
        list2.addLast("ccc");

        //遍历取出
        while (list2.size() > 0) {
            System.out.println(list2.pop());
        }
    }
}

LinkedList源码图解

Set接口–继承Collection接口

1).Set集合的特点：

1).无序

2).不能存储重复元素

3).不能通过“索引”访问元素。

 

2).它没有新增方法，都是Collection的。

HashSet集合

代码演示：HashSet集合存储字符串

    public class Demo07 {
    public static void main(String[] args) {
        //1.定义一个Set集合
        Set<String> set = new HashSet<>();

        set.add("郭德纲");
        set.add("于谦");
        set.add("杨幂");
        set.add("迪丽热巴");
        set.add("迪丽热巴");//不存储重复元素
        set.add("郭德纲");//不存储重复元素
        
        System.out.println(set);//[于谦, 郭德纲, 迪丽热巴, 杨幂]——无序的
        //1.可以使用"迭代器"遍历
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println("------------------------------");
        //2.可以使用"增强for"遍历
        for (String s : set) {
            System.out.println(s);
        }
    }
}

代码演示：HashSet存储自定义对象

自定义类(需要重写hashCode()和equals())：

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

    public Student(String name, int age) {
        this.name = name;
        this.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;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        System.out.println("equals()...");
        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() {
        System.out.println("hashCode()...");
        return Objects.hash(name, age);
    }
}

 

1. 测试类：
   

   public class Demo08 {
       public static void main(String[] args) {
           //1.定义一个Set
           Set<Student> stuSet = new HashSet<>();
   
           stuSet.add(new Student("张三", 18));
           stuSet.add(new Student("李四", 19));
   
           stuSet.add(new Student("李四", 19));//如果重写了hashCode()和equals()，不存储
   
           for (Student stu : stuSet) {
               System.out.println(stu);//只有两个元素。
           }
       }
   }

   代码图解（哈希表结构）

   

   LinkedHashSet集合

   1. LinkedHashSet：链表 + 哈希表结构，它是Set特例，它是“有序的”但仍然不能通过“索引”访问。

   代码演示：

   public class Demo09 {
       public static void main(String[] args) {
           LinkedHashSet<String> set = new LinkedHashSet<>();
           set.add("郭德纲");
           set.add("于谦");
           set.add("杨幂");
           set.add("迪丽热巴");
           set.add("迪丽热巴");//不能存储重复元素【哈希表结构】
   
           for (String s : set) {
               System.out.println(s);//有序的【链表结构】
           }
       }
   }

   TreeSet集合

   1. TreeSet：红黑树结构(平衡二叉树)

   代码演示：

       public class Demo10 {
       public static void main(String[] args) {
           TreeSet<Integer> treeSet = new TreeSet<>();
   
           treeSet.add(60);
           treeSet.add(10);//它内部的"比较"是基于对象的compareTo()方法
           treeSet.add(20);
           treeSet.add(70);
           treeSet.add(15);
           treeSet.add(18);
           treeSet.add(55);
           treeSet.add(55);//不存
   
           //遍历
           for (Integer n : treeSet) {
               System.out.println(n);
           }
       }
   }

   转自于原文链接：https://blog.csdn.net/weixin_45144691/article/details/107343478