黑马程序员技术交流社区

标题: 【石家庄校区】List和Set集合 [打印本页]
作者: 冬雪    时间: 2018-8-1 11:09
标题: 【石家庄校区】List和Set集合

上期回顾:  



file://D:/%E9%BB%91%E9%A9%AC%E7%A8%8B%E5%BA%8F%E5%91%98/2018Java%E5%9F%BA%E7%A1%80%E7%AC%AC%E4%BA%8C%E9%98%B6%E6%AE%B5/%E8%87%AA%E5%B7%B1%E6%80%BB%E7%BB%93/img/Collection%E9%9B%86%E5%90%88%E6%A1%86%E6%9E%B6.jpg?lastModify=1533092632
数据结构
数据结构就是数据的存储方式；       
栈
特点：
​        先进后出(FILO,First In Last Out)
​        入口和出口在同一侧
适用场景：
​        JVM中栈中程序运行机制
​        反转内容（车尾变车头，进出在出来就反转了）
队列
特点：
​        先进先出 （FIFO，first in first out）
​        出口入口在两侧
适用场景：
​        处理高并发场景
​        秒杀，抢购
​        在线售票
file://D:/%E9%BB%91%E9%A9%AC%E7%A8%8B%E5%BA%8F%E5%91%98/2018Java%E5%9F%BA%E7%A1%80%E7%AC%AC%E4%BA%8C%E9%98%B6%E6%AE%B5/%E8%87%AA%E5%B7%B1%E6%80%BB%E7%BB%93/img/%E9%AB%98%E5%B9%B6%E5%8F%91%E5%9B%BE%E7%A4%BA?lastModify=1533092632
数组
特点：
​        查询快：地址连续，有索引 （第一个元素地址值+索引）可以快速计算出该索引元素的地址值
​        增删慢：长度固定，增删需要新建数组并复制数据
适用场景：
​        查询多，增删少
链表
链表: 链表由多个 节点(Node / Entry) 组成
​        特点：
​                查询慢：地址不连续，每次查询从头开始
​                增删快：增删元素对链表整体机构无影响,只需要修改保存的下一个节点的地址值
适用场景：
​        查询少，增删多
补充
参考Map中Entry节点红黑树
特点:        元素存储过程中就完成了大小排序        查询比链表快, 增删比数组快 (数组和链表的折中)
适用场景:        查询和增删都有, 需要元素自动排序的场景
List集合
特点：        （数组结构决定）
​        1. 元素存取有序 (存入和取出元素的顺序一致)
​        2. 元素可以重复
​        3.有索引
特有方法：

void add(int index,E element)
E get(int index)
E remove(int index)
E set(int index,E element)ArrayList集合
ArrayList底层的数据结构:         数组ArrayList的特点:        查询快        增删慢        线程不安全, 效率高          不使用锁对象
ArrayList适用场景:        存储的数据查询多, 增删少的场景
LinkedList集合
LinkedList底层的数据结构:         链表LinkedList的特点:        查询慢        增删快        线程不安全, 效率高    不使用锁对象LinkedList适用场景:        存储的数据查询少, 增删多的场景
特有方法：

void addFirst(E e)
void addLast(E e)
E getFirst(E e)
E getLast(E e)
E removeFirst()
E Pop()
void push(E e)Vector集合
目前几乎无人使用
Set集合
特点：
​        元素不能重复   重写了hashCode()和equals()方法           应用：对集合重复元素去重
​        无索引        哈希表结构（数组+链表结构/红黑树）
​        无序（TreeSet例外）        哈希表结构
HashSet集合
常用方法：

boolean add(E e)
自定义的JavaBean对象去重：
​        重写hashCode()和equals()方法  Alt+Ins
补充：

HashSet集合保证添加元素不重复的原理:
    调用 add(E e) 添加元素时, 先调用 hashCode() 获取哈希值, 和当前HashSet集合中的元素比较
        如果哈希值不同, 则认为元素不重复, 添加, 并返回true
        如果哈希值相同, 则有可能是哈希冲突, 所以继续调用元素的 equals() 方法和所有哈希值相同的元素比较
            如果 equals() 比较所有元素都没有相同的, 则认为元素不重复, 添加, 并返回true
            如果 equals() 比较出有相同的元素, 则认为元素重复, 不添加, 并返回falseLinkedHashSet集合
特有特点：
​        存取有序  哈希表+链表（数组+链表/红黑树+链表）
可变参数格式: 用在方法的参数中
        修饰符 返回值类型 方法名(参数类型... 变量名) {
            // 可以直接将 变量名 当作 数组名 使用
        }
​
注意事项:
    1. 可变参数可以传递的参数个数, 可以是 0个, 1个, 多个
    2. 一个方法的参数列表中, 只能有一个可变参数
    3. 如果方法的参数有多个, 可变参数必须写在参数列表的最后Collections集合工具类
常用方法：

static <T> boolean addAll(Collection<T> c,T...elements)
static void shuffle(List<?> list)
static <T> void sort(List<T> list)： 实现Comparable<E>接口，重写int CompareTo(T e)方法
static <T> void sort(List<T> list,Comparator<?super T>):比较器排序
Collections集合工具类：自定义JavaBean对象sort<List<T> list>排序
第一种：

需要实现 Comparable<E> 接口, 重写 int compareTo(E e) 方法
    大小的比较通过 compareTo() 方法的返回值确定:
        负数: 当前元素比被比较元素小
        0: 当前元素与被比较元素相等
        正数: 当前元素比被比较元素大
    规则:
        this-参数: 升序
        参数-this: 降序
@Override
    public int compareTo(Person o) {
        // 比较的规则:
        // this.属性值 - 参数o.属性值: 升序
        // 参数o.属性值 - this.属性值: 降序
        return this.age - o.age;  // 升序
//        return o.age - this.age;  // 升序
    }
第二种：

Comparator使用方式:
    定义类作为比较器, 实现Comparator接口, 重写int compare(E o1, E o2)方法, 泛型为要比较的元素的类型
    在Collections.sort(List<T> list，Comparator<? super T>)方法中传入自定义比较器对象
    规则:
        o1-o2: 升序
        o2-o1: 降序
Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                // o1 - o2: 升序
                // o2 - o1: 降序
                return o1.getAge() - o2.getAge();
            }
        });
Comparable接口和Comparetor接口的区别：

Comparable: 让JavaBean自身具有可比较性 (自己和其他人比)
​
Comparator: 定义一个比较器类, 用比较器对象比 (让第三个人来帮两个人比较)
​
​       







欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2