集合框架(复盘)

1.什么是集合框架

java Collection框架由接口和类组成,集合框架是用于存储数据和操作一组对象的统一架构.

集合框架只能存储引用数据类型,如果要存基本数据类型,需要存对应的包装类(拆箱和装箱)

1.1 集合和数组的区别是什么?

1.数组只能存储相同类型的数据

2.集合可以存放不同类型的数据

3.数组可以存基本数据类型和引用数据类型,而集合只能存引用数据类型.

4.数组长度固定,集合长度不固定.

2.集合类体系结构

2.1 Collection 集合(接口)

一.Collection集合概述

是单列集合的顶层接口,JDK不提供此接口的任何直接实现,只提供子接口实现.

二.Collection集合常用的方法

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
boolean removeIf(Object o)	根据条件进行移除
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

 2.2 List集合(接口)

一.List集合概述

1.存取有序

2.可以存储重复数据

3.有索引值

二.常用的方法

方法名	描述
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

 2.3ArrayList集合(List集合的实现类)

一.ArrayList集合概述

1.ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。ArrayList 继承了 AbstractList ，并实现了 List 接口。

2.底层是数组结构:有索引---查询快,修改数据块,但是增删慢.

3.线程不安全,在List下还有一个古老的实现类,Vector是线程安全的但是效率很低,底层也是数组.

4.底层实现:

因为底层是数组默认创建了一个长度为10 的数组,如果添加元素导致容量不够,就会触发扩容.

int newCapacity = oldCapacity + (oldCapacity >> 1);

 新的容量=旧 的容量+0.5倍旧的容量.

5.简单了解下victor类的扩容机制:底层创建一个长度为10 的数组,扩容的是2倍.

2.4LinkedList集合(List集合的实现类)

一.LinkedList集合概述

1.底层是链表结构:查询慢(没有随机遍历 ),但是增删很快.

二.特有方法

方法名	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

 2.5Set集合(接口)

一.集合概述

1.存储无序

2.不能存储重复元素,没有索引

3.继承Collection接口

4.注意:没有特有方法都是使用Collection接口里面的公共方法.

2.6HashSet集合(Set的实现类)

一.概述

1.底层数据结构是哈希表(在jdk1.8之前是数组+链表,1.8后是数组+链表+红黑树)

2.简单说说底层实现:

jdk1.8之前是数组+链表,HashSet默认创建一个长度为16,默认加载因子为0.75的数组,存入元素的时候,通过数组的长度计算存入的位置,如果这个位置为null直接存储,如果不为空就通过equals方法比较属性值,如果一样不存,不一样新的元素就挂在旧的下.

问题:如果这个链表很长就会导致查询慢,效率低.所以在jdk1.8后就加入了红黑树,防止链表的长度过长.

3.存储无序

4.不能存储重复元素

5.没有索引

6.可以放一个null

二.遍历集合

package day16;

import java.util.*;

class Student {
    private String name;
    private Integer age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

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

public class test {
    public static void main(String[] args) {
        HashSet<Student> stu = new HashSet<>();
        //创建学生对象,添加元素
        stu.add(new Student("小明", 23));
        stu.add(new Student("Lisa", 23));
        stu.add(new Student("小雷", 23));
        stu.add(new Student("明天", 23));

        for (Student s:stu){
            System.out.println(s);
        }
    }
}

 2.7TreeSet集合(Set的实现类)

一.集合概述

1.不可以重复存储元素

2.没有索引

3.不能存储

4.可以排序(自然排序和比较器排序)

5.LinkedHashSet:是HashSet的子类.

二.TreeSet的基本使用

1.自然排序Comparable接口的使用.

自然排序就是让元素所属的类实现Comparable接口,重写comparaTo(T o)方法.

package day16;

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

    public Student() {
    }

    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 int compareTo(Student o) {

        int result = this.age - o.age;   
                //次要判断条件: 年龄相同时，按照姓名的字母顺序排序
        result = result == 0 ? this.name.compareTo(o.getName()) : result;
        return result;
    }
}

package day16;

import java.util.TreeSet;

public class MyTreeSet2 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> students = new TreeSet<>();

        //创建Student集合
        Student stu2 = new Student("Lisa", 14);
        Student stu3 = new Student("张杰", 14);
        Student stu4 = new Student("马云", 1);
        Student stu5 = new Student("冰冷的40亿", 10);

        students.add(stu2);
        students.add(stu3);
        students.add(stu4);
        students.add(stu5);

        //遍历集合
        for (Student s:students){
            System.out.println(s);
        }
    }

}

 2.比较器排序Comparator接口的使用

比较器排序,就是让集合构造方法接收Comparator的实现类对象,重写compare(T o1,T o2)

package day16;

import java.util.Comparator;
import java.util.TreeSet;

public class MyTreeSet2 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> students = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //主要条件
                int result=o1.getAge()-o2.getAge();
                //次要条件
               result= result==0? o1.getFraction()-o2.getFraction():result;

                result=result==0?o1.getName().compareTo(o2.getName()):result;
                return result;
            }
        });

        //创建Student集合
        Student stu2 = new Student("Lisa", 14,89);
        Student stu3 = new Student("张杰", 14,90);
        Student stu4 = new Student("马云", 1,20);
        Student stu5 = new Student("冰冷的40亿", 10,100);

        students.add(stu2);
        students.add(stu3);
        students.add(stu4);
        students.add(stu5);

        //遍历集合
        for (Student s:students){
            System.out.println(s);
        }
    }

}

package day16;

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

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

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

    public int getFraction() {
        return fraction;
    }

    public void setFraction(int fraction) {
        this.fraction = fraction;
    }

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

    public Student() {
    }

}

 3.迭代器

集合专用的遍历方式

Iterator<E> iteratoa():返回集合中元素的迭代器,通过集合对象的iterator()方法得到

Iterator里面的常用方法

boolean hasNext(): 判断当前位置是否有元素可以被取出 ​

E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

案列:遍历Collection集合

public class test {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<String> c = new ArrayList();
        //添加元素
        Collections.addAll(c,"小明","校长","小李","Lisa");
        //利用iteraor方法创建Iterator对象
        Iterator<String> iterator = c.iterator();
        //利用while循环改进元素的判断和获取
        while (iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }
    }
}