Day16-集合

集合

1.继承结构与主要集合
集合的顶级根接口是Collection–添加元素/删除元素/管理元素的父接口公共方法
子接口1 List–数据有下标，有序，可重复
实现类1 ArrayList
实现类2 LinkedList
子接口2 Set–数据无下标，无序，不可重复【常用于数据去重】
实现类1 HashSet
实现类2 TreeSet–红黑树
其他集合：Map 接口–键值对【Entry<K,V>】的方式存数据
实现类1 HashMap
实现类2 TreeMap

2.单个集合的 常用方法

boolean add(E e)
确保此collection包含指定的元素
void clear()
移除此collection中的所有元素
boolean contains(Object o)
如果此collection包含指定的元素，则返回true
boolean equals(Object o)
比较此collection于指定对象是否相等
int hashCode()
返回此collection的哈希码值
boolean isEmpty()
如果此collection不包含元素【集合为空】则返回true
boolean remove(Object o)
从此collection中移除指定元素的单个实例，如果存在的话
Object[ ]toArray()
返回包含此collection中所有云素的数组
int size()
返回此collection中元素的个数

3.集合间的常用方法

boolean addAll(Collection<? extends E> c) 【泛型的上/下限】
将指定 collection 中的所有元素都添加到此 collection 中
boolean removeAll(Collection<?> c)
移除此 collection 中那些也包含在指定 collection 中的所有元素
boolean containsAll(Collection<?> c)
如果此 collection 包含指定 collection 中的所有元素，则返回 true
boolean retainAll(Collection<?> c)
仅保留此 collection 中那些也包含在指定 collection 的元素【取交集】
4集合的迭代

步骤：
1）获取迭代器
Iterator iterator()返回在此collection的元素上进行迭代的迭代器
2)销魂换迭代集合中的所有元素
boolean hasNext()如果仍有元素可以迭代，则返回true
3）获取本轮循环迭代到的元素
E next()返回迭代的下一个元素

5.List单个集合方法总结

boolean add(E e) 向列表的尾部【追加】添加指定的元素
void add(int index, E element) 在列表的指定位置插入指定元素
E get(int index) 返回列表中指定位置的元素
int indexOf(Object o) 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
int lastIndexOf(Object o) 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
E remove(int index) 移除列表中指定位置的元素
boolean remove(Object o) 从此列表中移除第一次出现的指定元素
E set(int index, E element) 用指定元素替换列表中指定位置的元素
List subList(int fromIndex, int toIndex) 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的集合元素
6.List集合间的操作

boolean addAll(int index, Collection<? extends E> c)
将指定 collection 中的所有元素都插入到列表中的指定位置

7.List集合的迭代

ListIterator listIterator()
返回此列表元素的列表迭代器，本迭代器可以逆序遍历，但是不常用

8.ArrayList与LinkedList的区别
ArrayList,是一个集合，底层维护的是数组结构
数组结构，查询比较快，增删慢
LinkedList,是一个集合，底层维护的是链表结构
链表结构，查询比较慢，增删快
TIPS:两者指的都是数据量比较大的情况，而且链表首尾操作还是比较快的，中间慢

9.Map --键值对<KEY,VALUE>–Entry<K,V>–映射关系
1.Map的key不可以重复，如果重复，值会被覆盖
2.Map的初始容量是16，加载因子【存到什么程度就扩容】是0.75f
10.决定Map结构的查询性能的两个因素：
初始容量：16–数组的初始长度
加载因子：0.75f–数组的数据的存入程度
TIPS:扩容只和数组存入数据的程度有关，与链表无关
不要将初始容量设置的太高–桶的数目太多，不好迭代
不要将加载因子设置的太低
–太容易达到扩容的程度，频繁扩容，频繁rehash【重建内部数据结构】,效率会被拉低

可以扩展的部分：【头插法与尾插法】

Collection

package cn.tedu.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

//本类用于测试collection相关API
public class TestCollection {
    public static void main(String[] args) {
        /*<Integer>是泛型，用来约束集合c中可以存入的元素类型
        * 泛型中的<Type>只能是引用类型，不能是基本类型*/
        Collection<Integer> c = new ArrayList();
        c.add(100);
        c.add(200);
        c.add(300);
        c.add(400);
        c.add(500);
        System.out.println(c);
//        c.clear();
//        System.out.println(c);
        System.out.println(c.contains(300));//true
        System.out.println(c.hashCode());//127240651
        System.out.println(c.isEmpty());//false
        System.out.println(c.remove(300));//true
        System.out.println(c);
        System.out.println(c.size());//4
        System.out.println(c.equals(200));//false
        Object[] array = c.toArray();
        System.out.println(Arrays.toString(array));//[100, 200, 400, 500]
        Collection<Integer> c2 = new ArrayList<>();
        c2.add(5);
        c2.add(78);
        c2.add(444);
        System.out.println(c2);
        c.addAll(c2);
        System.out.println(c);
        System.out.println(c2);
        System.out.println(c.contains(c2));//false
        System.out.println(c.containsAll(c2));//true
//        System.out.println(c.retainAll(c2));//true 交集
        System.out.println(c);//[5, 78, 444]
//        System.out.println(c.removeAll(c2));//删除c集合中属于c2集合的所有元素
        System.out.println(c);//[]
        //遍历/迭代集合中的元素
        /*1.获取集合对应的迭代器  Iterator<E> it =    c.iterator()
        * 2.判断集合中是否有下个元素 it.hasNext()
        * 3.获取当前迭代到的元素 it.next()*/
        Iterator<Integer> t = c.iterator();
        while (t.hasNext()){
            Integer next = t.next();
            System.out.println(next);
        }
    }
}

List

package cn.tedu.collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

//本类用于进一步测试List接口
public class TestList2 {
    public static void main(String[] args) {
        List<String> t = new ArrayList();
        t.add("史尔特尔");
        t.add("泥岩");
        t.add("空弦");
        t.add("四月");
        /*集合迭代的方式：
        * 1.for循环
        * 2.高效/增强for循环
        * 3.iterator
        * 4.listIterator*/
        for(int i = 0;i<t.size();i++){
            System.out.print(t.get(i));
        }
        System.out.println();
        for(String s:t){
            System.out.print(s);
        }
        System.out.println();
        Iterator<String> z = t.iterator();
        while(z.hasNext()){
            System.out.print(z.next());
        }
        System.out.println();
        /*ListIterator是Iterator的子接口，拥有逆向遍历的特有功能*/
        ListIterator<String> c = t.listIterator();
        while (c.hasNext()){
            System.out.print(c.next());
        }   
    }
}

Map

package cn.rua.list;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class TestMap {
    public static void main(String[] args) {
        System.out.println("请输入要统计的数据");
        String t = new Scanner(System.in).nextLine();
        Map<Character,Integer> z = new HashMap<>();
        for(int i = 0;i<t.length();i++){
            char y = t.charAt(i);
            Integer r = z.get(y);
            if(r==null){
                z.put(y,1);
            }else{
                z.put(y,r+1);
            }
        }
        System.out.println(z);
     }
}