Java基础十五、十六和十七天合：集合+Collection接口+List接口+ArrayList+LinkedList+Set接口+HashSet+Map接口+HashMap+Collections

集合

1.概述

数组：长度一旦定义不能改+数据的类型必须统一+优势是查询快

集合：长度可变+元素的类型不限+有查的快的，有增删快的

2.泛型

用来约束集合中元素类型，标志是<> ----+编译器报错

< >----不能是基本类型，必须是引用类型

3.泛型使用位置

类上/接口上–class Demo< >{ }

方法上----------public < > void show(E e){ }

4.继承机构

Collection：顶级接口，不能new，学方法

​ List：子接口，不能new，学方法

​ ArrayList：实现类，学习new

​ LinkedList：实现类，学习new

​ Set：子接口，不能new，学方法

​ HashSet：实现类，学习new

​ TreeSet：实现类，学习new

Collection接口

1.概述

Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。

2.共性方法

boolean	**add**(E e) 确保此 collection 包含指定的元素（可选操作）。
boolean	**addAll**(Collection<? extends E> c) 将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
void	**clear**() 移除此 collection 中的所有元素（可选操作）。
boolean	**contains**(Object o) 如果此 collection 包含指定的元素，则返回 true。
boolean	**containsAll**(Collection<?> c) 如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean	**equals**(Object o) 比较此 collection 与指定对象是否相等。
int	**hashCode**() 返回此 collection 的哈希码值。
boolean	**isEmpty**() 如果此 collection 不包含元素，则返回 true。
Iterator<E>	**iterator**() 返回在此 collection 的元素上进行迭代的迭代器。
boolean	**remove**(Object o) 从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
boolean	**removeAll**(Collection<?> c) 移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
boolean	**retainAll**(Collection<?> c) 仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
int	**size**() 返回此 collection 中的元素数。
Object[]	**toArray**() 返回包含此 collection 中所有元素的数组。
<T> T[]	**toArray**(T[] a) 返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

List接口

1.特点

​ 有序

​ 有索引

​ 可以重复

​ 存多个null

2.常用方法

继承自Collection接口的

自己扩展特有的（根据索引的操作）

void	**add**(int index, E element) 在列表的指定位置插入指定元素（可选操作）。
boolean	**addAll**(int index, Collection<? extends E> c) 将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
E	**get**(int index) 返回列表中指定位置的元素。
int	**indexOf**(Object o) 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
int	**lastIndexOf**(Object o) 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
ListIterator<E>	**listIterator**() 返回此列表元素的列表迭代器（按适当顺序）。
ListIterator<E>	**listIterator**(int index) 返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
E	**remove**(int index) 移除列表中指定位置的元素（可选操作）。
E	**set**(int index, E element) 用指定元素替换列表中指定位置的元素（可选操作）。
List<E>	**subList**(int fromIndex, int toIndex) 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。

List集合的迭代方式

方式一：

Iterator<>  iterator()    ---继承自Collection
while (it.hasNext()){
            Integer in = it.next();
            System.out.println(in+"------");
        }

方式二：

ListIterator<>  listIterator()	---继承自子接口List
while (lit.hasNext()){
            Integer in = lit.next();
            System.out.println(in+"------");
        }
        System.out.println("------------------");
        //逆向遍历---前提是：必须先顺序遍历
        while (lit.hasPrevious()){
            Integer in = lit.previous();
            System.out.println(in+"------");
        }

方式三：普通for，根据下标迭代

for (int i = 0; i < list1.size(); i++) {//list.size()是集合的长度
            System.out.println(list1.get(i));//根据下标i获取元素
        }

方式四：增强for

for (Integer in:list1) { 
    System.out.println(in);
}

iterator和listIterator的区别

iterator()来自父接口Collection

listIterator()是List子接口特有的

返回值不同，是父子接口关系，子接口listIterator能用所有父接口Iterator的功能，而且扩展了逆向遍历的方法

ArrayList

1.结构

是List接口的实现类，底层维护的是一个 可变长的 数组Object[ ]

方便查询

2.创建对象

ArrayList()

3.常用方法

同List接口

LinkedList

1.特点

是List接口的实现类，拥有List接口的所有特点

底层维护了一个链表结构，对于链表上的节点，有2个特殊位置，开头和结尾的元素的位置。

2.创建对象

LinkedList()

​ 构造一个空列表

3.常用方法

void	**addFirst**(E e) 将指定元素插入此列表的开头。
void	**addLast**(E e) 将指定元素添加到此列表的结尾。
E	**element**() 获取但不移除此列表的头（第一个元素）。
E	**getFirst**() 返回此列表的第一个元素。
E	**getLast**() 返回此列表的最后一个元素。
E	**removeFirst**() 移除并返回此列表的第一个元素。
E	**removeLast**() 移除并返回此列表的最后一个元素。
boolean	**offer**(E e) 将指定元素添加到此列表的末尾（最后一个元素）。
boolean	**offerFirst**(E e) 在此列表的开头插入指定的元素。
boolean	**offerLast**(E e) 在此列表末尾插入指定的元素。
E	**peekFirst**() 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E	**peekLast**() 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
E	**pollFirst**() 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E	**pollLast**() 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

ArrayList 和 LinkedList

ArrayList：

​ 底层是数组

​ 连续空间

​ 适合查询

LinkedList：

​ 底层是链表

​ 不连续

​ 适合增删

Set接口

1.概述

Set接口是Collection接口的子接口

能用父接口的所有方法

2.特点

无序

不重复

能存一个null

没下标

3.常用方法

继承自Collection接口的

HashSet

1.概述

是Set接口的实现类，拥有Set接口的所有特点和方法

HashSet底层维护的是一个 哈希表/散列表

常用来去重

2.创建对象

**HashSet**()

3.常用方法

略 同set

练习题

统计list集合中，元素出现的次数

    private static void count() {
        Random rd = new Random();
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(rd.nextInt(5) + 1);
        }

        int one = 0;
        int two = 0;
        int three = 0;
        int four = 0;
        int five = 0;
        Iterator<Integer> it = list.iterator();
        while (it.hasNext()) {
            Integer in = it.next();
            if (in == 1) {
                one++;
            } else if (in == 2) {
                two++;
            } else if (in == 3) {
                three++;
            } else if (in == 4) {
                four++;
            } else if (in == 5) {
                five++;
            }
        }
        System.out.println("1出现的次数是：" + one);
        System.out.println("2出现的次数是：" + two);
        System.out.println("3出现的次数是：" + three);
        System.out.println("4出现的次数是：" + four);
        System.out.println("5出现的次数是：" + five);

    }

向list添加随机数，但是不能重复

    private static void method() {
        List<Integer> list = new LinkedList<>();
        for (int i = 0; i < 10; i++) {
            int in = new Random().nextInt(10);
            if (!list.contains(in)) {
                list.add(in);
            }
        }
        System.out.println(list);

    }

    private static void setTest() {
        Random rd = new Random();
        HashSet<Integer> hs = new HashSet<>();
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            hs.add(rd.nextInt(100) + 1);
        }
        list.addAll(hs);
        System.out.println(list.size());
        for (Integer it : list
        ) {
            System.out.println(it);
        }

    }

Map接口

1.概述

Map接口里的数据有格式上的要求，必须是以组键值对的形式。

Map<K,V>：K - 此映射所维护的键的类型（键） V - 映射值的类型（值）

K不能重复，V可以重复

2.特点

键不能重复

每个键只能映射一个值

数据无序

3.常用方法

V	**put**(K key, V value) 将指定的值与此映射中的指定键关联（可选操作）。
void	**clear**() 从此映射中移除所有映射关系（可选操作）。
boolean	**containsKey**(Object key) 如果此映射包含指定键的映射关系，则返回 true。
boolean	**containsValue**(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true。
boolean	**equals**(Object o) 比较指定的对象与此映射是否相等。
V	**get**(Object key) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
int	**hashCode**() 返回此映射的哈希码值。
boolean	**isEmpty**() 如果此映射未包含键-值映射关系，则返回 true。
V	**remove**(Object key) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
int	**size**() 返回此映射中的键-值映射关系数。
void	**putAll**(Map<? extends K,? extends V> m) 从指定映射中将所有映射关系复制到此映射中（可选操作）。
Set<K>	**keySet**() 返回此映射中包含的键的 Set 视图。
Collection<V>	**values**() 返回此映射中包含的值的 Collection 视图。

4.迭代Map集合的方式

方式一：

Set<K> keySet()  ---把map里的key存入set

方式二：

Set<Map.Entry<K,V>> entrySet()---把map里的key和value存入到Entry对象中，通过Entry获得key和value

方式三：

Collection<V> values()----把map里的所有value获取出来，存入Collection

HashMap

1.创建对象

**HashMap**() 构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。

2.常用方法

同Map接口

3.原理

HashMap中存放数据时，拿着你的数据，开始计算存储位置（哈希算法）

开始存，

1.这个位置是空的，没存过数据，把数据存入数组

2.这个位置存过了，有数据了，就会形成链表结构（把新的数据挂在老数据下面）

3.最好把数据都放在数组节点上，如果链表太长，会影响查询效率

Collections集合的工具类

常用方法

static <T> boolean	**addAll**(Collection<? super T> c, T... elements) 将所有指定元素添加到指定 collection 中。
tic <T extends Object & Comparable<? super T>> T	**max**(Collection<? extends T> coll) 根据元素的自然顺序，返回给定 collection 的最大元素。
static <T> T	**min**(Collection<? extends T> coll, Comparator<? super T> comp) 根据指定比较器产生的顺序，返回给定 collection 的最小元素。
static void	**reverse**(List<?> list) 反转指定列表中元素的顺序。
static <T extends Comparable<? super T>> void	**sort**(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序。
static void	**swap**(List<?> list, int i, int j) 在指定列表的指定位置处交换元素。