类集之List与Set接口

其他 2020-01-28 11:19:46 阅读次数: 0

文章目录

1. Collection

类集实际上就属于动态对象数组，在实际开发之中，数组的使用出现的几率并不高，因为数组本身有一个最大的缺陷 : 数组长度是固定的. 由于此问题的存在，从JDK1.2开始，Java为了解决这种数组长度问题，提供了动态的对象数组实现框架------Java类集框架.

Java集合类框架实际上就是Java针对于数据结构的一种实现，在Java的类集里面(java.util包)提供了两个最为核心的接口 : Collection、Map接口

Collection接口的定义如下:

public interface Collection<E> extends Iterable<E>

Collection接口中定义的常用方法如下:

No. 方法名称 类型 作用
1. boolean add(E e); 普通 向集合中添加一条数据
2. boolean addAll(Collection<? extends E> c); 普通 向集合中添加一组数据
3. void clear(); 普通 清空集合中的数据
4. boolean contains(Object o); 普通 查找集合中某一条数据是否存在，需要覆写equals()
5. boolean remove(Object o); 普通 移除集合中某一条数据，需要覆写equals()
6. int size(); 普通 取得集合的长度
7. Object[] toArray(); 普通 将集合变为数组对象返回
8. Iterator iterator(); 普通 取得Iterator，用于集合的迭代输出

在实际中如果按照使用频率来讲: add()、iterator()方法用到的最多.

很少会直接使用Collection接口，Collection接口只是一个存储数据的标准，并不能区分存储类型. 例如：要存放的数据需要区分重复与不重复. 在实际开发之中，往往会考虑使用Collection接口的子接口: List(允许数据重复)Set(不允许数据重复).

2. List

List与Set考点（MyGithub）

元素有序，可重复

在这里插入图片描述

相对使用频率 ： 80%

  1. index 与数组相同，从0开始编号
  2. 根据下标返回元素 ： E get(int index)
  3. 根据下标修改元素，返回修改前的元素 ： E set(int index,E element)

Collection是List的父类，而我们更常用的是List

List接口中提供的方法,在这个接口中有两个重要的扩充方法 :

No. 方法名称 类型 作用
1. E get(int index); 普通 根据索引取得数据
2. E set(int index, E element); 普通 根据索引修改数据

对集合元素的增删改查

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

/**
 * @Author: Mr.Q
 * @Date: 2019-08-22 17:56
 * @Description:List接口方法的使用
 */
public class ListMethod {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add(2,"Mr.Q");
        System.out.println(list);
        System.out.println(list.contains(3));
        System.out.println(list.size());
        //remove的并不是对象本身，而是在容器中的地址
        System.out.println("移除指定元素" + list.remove(2));
        System.out.println(list.get(0));
        System.out.println(list.set(0,"7"));
        System.out.println(list);
    }
}

在这里插入图片描述

I. 向List集合中添加自定义类

线程安全操作 : 多线程并发修改内容时，不会产生数据异常

  • contains
  • remove
  • 需要覆写equals

equals方法的覆写

  • 1.判断是否为当前对象.true
  • 2.判断传入的是否为空或者不是当前类的对象.false
  • 3.向下转型取得 当前类的对象.true
public boolean equals(Object obj) {
        //当前对象和传入的对象地址是否相同
        if(obj == this) {
            return true;
        }
        //如果为其他类型或者为空
        else if(obj == null) {
            return  false;
        }
        //判断传入的对象是否为 Person()类的子类;如果不是则比较的不是同一个类(Person & Dog)
        else if(!(obj instanceof  Person)) {
            return  false;
        }
        //上面三个分支都走完，则表示传入的是 Person()的对象,而且和当前的对象不是同一个对象
        //向下转型，还原为 Person()对象,取出属性值比较
        Person per = (Person) obj;
        return this.name.equals((per.name)) && this.age.equals(per.age);
    }

Demo : 向List集合中添加Person类

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

/**
 * @Description:1.向集合保存简单的java类对象
 * @Description:2.覆写equals()
 */

class Person {
    //自定义的类中属性必须使用包装类
    private String name;
    private Integer age;

    public Person(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 boolean equals(Object obj) {
        //当前对象和传入的对象地址是否相同
        if(obj == this) {
            return true;
        }
        //如果为其他类型或者为空
        else if(obj == null) {
            return  false;
        }
        //判断传入的对象是否为 Person()类的子类;如果不是则比较的不是同一个类(Person & Dog)
        else if(!(obj instanceof  Person)) {
            return  false;
        }
        //上面三个分支都走完，则表示传入的是 Person()的对象,而且和当前的对象不是同一个对象
        //向下转型，还原为 Person()对象,取出属性值比较
        Person per = (Person) obj;
        return this.name.equals((per.name)) && this.age.equals(per.age);
    }

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

public class ListAddClass {
    public static void main(String[] args) {
        //保存自定义的 Person()对象
        List<Person> list = new ArrayList<>();
        list.add(new Person("张三",20));//匿名对象
        list.add(new Person("李四",18));
        System.out.println(list);
        // new 的原因:未知集合中是否存在目标对象，new创建之后再比较
        System.out.println(list.contains(new Person("张三",20)));
        System.out.println(list.remove(new Person("李四",18)));
        System.out.println(list);
    }
}

在这里插入图片描述

II. List子类及实现动态数组

List接口下有三个常用子类：ArrayList、Vector、LinkedList
在这里插入图片描述

通过数组来实现动态数组扩容

import java.util.Arrays;

/**
 * @Author: Mr.Q
 * @Date: 2019-08-22 20:07
 * @Description:数组---实现动态数组扩容
 */
class MyArray<E> {
    private E[] elementData; //实际存放元素的数组
    private final static int DEFAULT_SIZE = 10; //默认的初始容量
    private int size; //实际容量

    public MyArray() {
        //无参构造调用第一个有参构造
        this(DEFAULT_SIZE);
    }
    public MyArray(int initCap) {
        this.elementData = (E[]) new Object [initCap];
    }
    public void add(E e) {
        if(size == elementData.length) {  //此时数组已达到默认的初始容量
            int oldCap = elementData.length;
            // DEFAULT_SIZE < 64,扩容2倍; DEFAULT_SIZE > 64,扩容1.5倍
            int newCap = oldCap + ((size < 64) ? oldCap : oldCap >> 1);
            if(newCap > Integer.MAX_VALUE - 8) {
                throw new IllegalArgumentException("Array element too many！！");
            }
            //将 oldCap 的内容拷贝到 newCap
            elementData = Arrays.copyOf(elementData, newCap);
        }
        elementData[size++] = e;
    }

    //查看指定索引值
    public E get(int index) {
        checkRange(index);
        return (E) elementData [index];
    }

    //设置指定索引值
    public void set(E element,int index) {
        checkRange(index);
        elementData[index] = element;
    }

    //索引合法判断 [0,size]
    public void checkRange(int index) {
        if(index < 0 || index > size - 1) {
            throw new IllegalArgumentException("index is error!!");
        }
    }

    @Override
    public String toString() {
        return "MyArray { " +
                "elementData=" + Arrays.toString(elementData) +
                ", size=" + size +
                " }";
    }
}

public class ArrayOfDynamicArray {
    public static void main(String[] args) {
        MyArray<String> msg = new MyArray<>();
        msg.add("SchoolStarts..");
        msg.add("大三了！！");
        msg.add("A");
        msg.add("B");
        msg.add("C");
        msg.add("D");
        System.out.println("下标为3的元素为: " + msg.get(3));
        msg.set("Mr.Q",5);
        System.out.println(msg);
    }
}

在这里插入图片描述

通过链表来实现动态数组扩容

/**
 * @Author: Mr.Q
 * @Date: 2019-08-22 20:28
 * @Description:链表---实现动态数组扩容
 */
class MyArrayOfList<E> {
    private class Node {
        E data; //数据
        Node next; //前指针
        Node prev; //后指针

        Node(E data, Node next, Node prev) {
            this.data = data;
            this.next = next;
            this.prev = prev;
        }
    }
    private int size;
    private Node head; //链表头指针
    private Node tail; //链表尾指针


    public void add(E data) {
        // 双向链表--->尾插
        Node node = new Node(data,null,tail);
        if(tail == null) {
            //此时链表为空
            head = tail = node;
        }
        tail.next = node;
        tail = node;
        size++;
    }

    @Override
    public String toString() {
        return "MyArrayOfList{" +
                "size=" + size +
                '}';
    }
}
public class ListOfDynamicArray {
    public static void main(String[] args) {
        MyArrayOfList<String> msg = new MyArrayOfList<>();
        msg.add("SchoolStarts..");
        msg.add("大三了！！");
        msg.add("A");
        msg.add("B");
        msg.add("C");
        msg.add("D");
        System.out.println(msg);
    }
}

在这里插入图片描述

III. ArrayList

  • 实现： 底层用数组实现的存储(JDK 1.2)
  • 特点 ：查询效率高，增删效率低
  • 线程不安全
  • 初始化策略 ： 懒加载策略，只有当Array对象第一次使用add()时，内部的数组才会初始化长度为10的数组
  • 扩容策略 ： 扩容为源数组1.5倍

IV. Vector

  • 实现： 底层用数组实现的存储(JDK 1.0)
  • 特点 ：查询效率高，增删效率低
  • 线程安全 ： 使用synchronized同步方法来确保线程安全性
  • 初始化策略 ： 当产生Vector对象时，内部的数组就初始化长度为10的数组
  • 扩容策略 ： 扩容为源数组2倍
  • 特殊 ： JDK 内置的Stack继承 Vector

V. LinkedList

  • 实现 ： 基于双向链表的动态数组
  • 特点 ： 查询效率低，增删效率高
  • 线程安全 : 线程不安全
  • 特殊 ： 继承JDK内置的Queueu

查看JDK源码中的双向链表

3. Set

Set : 本质是 Map Interface

元素无序，不可重复

  • HashSet() ： 无序存储(可以存放空值) 底层实现 -> 哈希表 + 红黑树（JDK 1.8之前只有哈希表）
  • TreeSet() ： 有序存储，升序(不可以存放空值) 底层实现 -> 红黑树(二分搜索平衡树)

TreeSet 如何保证升序？

  • 自定义类要想使用TreeSet，前提是自定义类实现了Comparable，或者从外部传入该类的比较器对象(实现了Comparator接口)
  1. 自定义类实现了Comparable，表示此类具备了可比较的性质

​ java.lang.Comparable : 内部排序接口

​ int compareTo(T o)

> 0 大于目标对象
< 0 小于目标对象
= 0 等于

  1. 类本身不具备可比较性，专门有一个类来比较自定义类的大小

    java.util.Comparator : 外部排序接口(推荐使用) 策略模式

    int compare(T o1, T o2)

Comparator比较自定义对象的大小

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

/**
 * @Author: Mr.Q
 * @Date: 2019-08-27 18:23
 * @Description:TreeSet升序Test,Comparator比较自定义对象的大小
 */

class Person {
    private String name;
    private Integer age;

    public Person(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 "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

/**
 * @比较器  此类专门比较俩个自定义Person的大小
 */
class PersonAgeAsc implements Comparator<Person> {

    @Override
    public int compare(Person o1, Person o2) {
        if(o1.getAge() < o2.getAge()) {
            return - 1;
        }
        if(o1.getAge() > o2.getAge()) {
            return 1;
        }
        return 0;
    }
}

public class TreeSetTestComparator {
    public static void main(String[] args) {
        PersonAgeAsc per = new PersonAgeAsc();
        Set<Person> set = new TreeSet<> (per);
        set.add(new Person("Mr.Q",21));
        set.add(new Person("IQQcode",20));
        set.add(new Person("Mr.Q",22));
        System.out.println(set);
    }
}

在这里插入图片描述

4. HashSet

  • TreeSet : 根据比较接口的返回值来判断两个元素是否重复
  • HashSet : 使用eauals 与 hashCode共同来判断元素是否重复
  • hashCode : 对象在内存中的地址根据 Hash 算法转为 int

a. equals 相同，hashCode 一定返回相同吗？ ----- 一定相同（属性相同，hash之后也一定相同）

b. hashCode 相同，equals 一定返回相同吗？ ----- 不一定相同（算法不一定相同）

//hash Algorithm A
// x = 10
 hash(int x) {
     return i + 1; 
 }

//hash Algorithm B
// y = 20
 hash(int y) {
     return i - 9; 
 }

此时，hashCode = 11 相同，但 equals(x = 10, y = 20) 不同

哈希表 ：

在这里插入图片描述

结语：类集的内容较多，分成两篇来记录.

IDEA换背景啦，写代码感觉又有了新鲜感. 附上我之前和现在的壁纸鸭！
在这里插入图片描述
在这里插入图片描述

Mr.Q_
发布了77 篇原创文章 · 获赞 118 · 访问量 2万+
私信 关注

猜你喜欢

转载自blog.csdn.net/weixin_43232955/article/details/100175357
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
基本数据类型封装类比较 Java源码解读(一) 8种基本类型对应的封装类型
JS实现无缝滚动上
深入解析HashMap原理（基于JDK1.8）
mysql的连接池
关于.htc
linux下的ubuntu12.04图形界面
【数论】好推不好记的扩展欧几里德
设备树详解
cscope + tags 简单设置
xml学习
每日归档
更多
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022