java集合-CSDN博客

本文链接：https://blog.csdn.net/weixin_43913960/article/details/112559259

java集合

一集合简介

1.集合和数组的区别

1.长度区别：数组固定，集合可变。
2.内容区别：数组可以是基本类型(int a[])和引用类型(指针)，集合只能是引用类型。
3.元素内容：数组智能存储一种类型，集合可以存储不同的类型。

//将集合的泛型设置成Object类
        List<Object> list = new ArrayList<Object>();
        list.add("abc");
        list.add(123);
        list.add(new HashMap<Integer,String>());
        Map hsahmap=new HashMap<Integer,String>();
        hsahmap.put(1,"11");
        hsahmap.put(2,"22");
        list.add(hsahmap);
        System.out.println(list);

//        List list1 = new ArrayList();//和上面一样

        //使用反射
        //在编译成class文件时泛型，被javaJVM剔除了，也就是说在编写java代码时有泛型而在编译成class文件时，泛型被去除了。
        ArrayList<Integer> list2 = new ArrayList<Integer>();
        list2.add(123);
        Class<?> clz = list.getClass();//获取类对象
        try {
            Method method = clz.getMethod("add", Object.class);//获取add方法
            method.invoke(list2, "qwe");//执行add方法
            method.invoke(list2, "haha");
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        System.out.println(list2);
    }

2.集合主要分为两大类

1.Collection：表示一组对象，每组对象中的每一个对象是独立的。
1).List接口：列表，有序，可重。
(1).LinkedList:链表，适合插入删除，不同步，线程不安全。
(2).ArrayList:数组，适合随机访问，不同步，线程不安全。
(3).Vector:数组，适合随机访问，同步，线程安全。
(4).Stack:堆栈，先进后出，继承于Vector。
2).Set：集合，无重，内排序。
(1).HashSet:使用hash表（数组）存储元素，底层实现为HashMap，Value=PRESENT。
(2).LinkedHashSet:链表维护元素的插入次序,
(3).SortedSet(接口)：有序，需要写比较器comparator。
(4).TreeSet:SortedSet的实现类，底层实现为二叉树，元素排好序。
2.Map:表示一组映射关系的键值对。
(1).Hashtable:无序，key无重，同步，线程安全。
(2).HashMap:无序，key无重，不同步，线程不安全。
LinkedHashMap:双向链表和哈希表实现。
WeakHashMap:弱连接。
(3).TreeMap:有序，key无重，红黑树对所有的key进行排序。
(4).IdentifyHashMap：

3.Collection集合接口

List和Set的区别

1.有序性：List保证插入的顺序排序，Set存储和取出顺序不一致。
2.唯一性：List可以重复，Set元素唯一。
3.获取元素方法：List可以通过索引直接操作元素，Set不能。
4.List特点：元素有放入顺序，元素可重复，Set特点：元素无放入顺序，元素不可重复，重复元素会覆盖掉，（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的，加入Set 的Object必须定义equals()方法，另外list支持for循环，也就是通过下标来遍历，也可以用迭代器，但是set只能用迭代，因为他无序，无法用下标来取得想要的值。）
Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。
List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变。

List

分类：
LinkedList:底层是链表，查询慢，增删块，线程不安全，效率高。
添加：addFirst(),addLast()
删除：removeFirst(),removeLast()
获取：getFirst(),getLast()
ArrayList:地产是数组，查询快(可随机查询)，增删慢，线程不安全，效率高。

**Vector**:底层是数组，查询快(可随机查询)，增删慢，线程安全，效率低。
			添加：public void addElement(E obj)
			删除：public E elementAt(int index)
			迭代：public Enumeration<E> elements()
**Stack**:底层是Vector，堆栈
				入栈：push()将元素追加到数组末尾。
				出栈：peek()取栈顶元素不删除,pop()取栈顶元素且删除

Set

Collection方法

1.添加元素
boolean add(E e):添加一个元素e，成功？true：false。
boolean addAll(Collection<? extends E> c):将指定的集合c中所有元素添加进来。集合发送变化？true：false。
2.删除元素
void clear()清空所有元素
boolean remove(Object o)删除第一个找到的元素
boolean removeAll(Collection<? extends E> c)删除于c集合相同的元素
boolean retainAll(Collection<? extends E> c)删除与c集合不相同的元素
3.查询元素
boolean isEmpty()是否为空集合
boolean contains(Object o)是否包含某个元素
boolean contains(Collection<? extends E> c)是否包含集合c所有元素
int size()返回集合的元素个数
4.遍历
(1).Object[] toArray()转成数组
(2).foreach:for(集合的元素类型元素名:容器名字)
使用了Iterator迭代器来遍历集合，只要实现了java.lang.Iterable&ItT&gt接口即可使用，数组编译器会自动实现这个接口， Collection接口继承了Iterator接口。不能允许修改元素个数。
(3).使用迭代器：Iterator iterator()返回一个专门遍历当前集合的迭代器，这个方法是从Iterator接口继承的。可修改元素。
Iterator这个类有两个方法用于遍历集合,
1.boolean hasNext():判断后面是否有其他元素
2.E next():取出元素

//转数组
        Collection<Integer> c=new ArrayList<Integer>();
        c.add(1);
        c.add(2);
        Object[] array=c.toArray();
        for (int i=0;i< array.length;i++){
            System.out.println(array[i]);
        }

        //foreach
        for (Integer i : c){
            System.out.println(i);
        }

        //Iterator
        Iterator<Integer> iterator=c.iterator();
        while (iterator.hasNext()){//判断后面是否还有元素
            Integer next=iterator.next();
            System.out.println(next);
        }

java.lang.Iterable:表示可迭代的，实现了其抽象方法Iterable Iterable()即可使用foreach。如Collection，Map则不能。
java.util.Iterator:表示迭代器,每一种实现了Iterator接口的集合内部，都会有一个内部类实现接口。其子接口：ListIterator。

List系列

有序，可以通过索引和下标进行操作。
可重复，调用equals相同的元素。

List集合的API

在Collection基础上增加。
1.添加
add(int index,E e)在index位置(第index个元素后)添加一个元素。
addAll(int index,Collection c)在index位置(第index个元素后)添加多个元素。
2.删除
E remove(int index)在index位置(第index个元素后)删除一个元素，返回被删除的元素。
3.修改
E set(int index,E e)替换index位置(第index个元素后)元素，返回被替换的元素。
4.查询
E get(int index)查询index位置的元素。
List subList(int start,int end)截取[start,end)部分的元素。
int indexOf(Object obj)返回obj在列表第一次出现的下标。
int lastindexOf(Object obj)返回obj在列表最后一次出现的下标。
ListIterator listerator(int index)默认游标在index位置。有逆向功能，可操作元素。

ArrayList
public ArrayList()：构造一个初始数组大小为10的空列表。
public ArrayList(int initialCapacity)：构造指定数组大小的空列表。
public ArrayList(Collection c)：构造一个包含集合c所有元素的列表
LinkedList
public LinkedList():构造空列表
public LinkedList(Collection c)：构造一个包含集合c所有元素的列表.

Set系列

可以存储null元素，元素的唯一性是靠所存储元素类型是否重写hashCode()和equals()方法来保证的，如果没有重写这两个方法，则无法保证元素的唯一性。
不可重复。
TreeSet：按大小排序，LinkedHashSet：按照添加的顺序，LinkedHashSet：无序。
LinkedHashSet和LinkedHashSet依赖元素的hashCode和equals方法。
TreeSet：要不指定java.util.Comparator接口的实现类对象，重写int compare(T t1,T t2)方法。(不需要改元素代码)
要不实现java.lang.Comparable接口重写int compareTo(T t)方法。


class 比较器类名 implements Comparator<key类名>{
	@Override
	public int compare(key类名 a,key类名 b){
		return 1:a大,0:一样大,-1:b大;//这里不能存在一样大
	}
}

class key类名 implements Comparable<key类名>{
	@Override
	public int compareTo(T t){
		return 1:a大,0:一样大,-1:b大;//这里不能存在一样大
	}
}

Set的API

Set具有与Collection完全一样的接口，因此没有任何额外的功能。

4.Map映射接口

Map简介

java.util.Map不是java.util.Collection的子接口,Map中存储的是<key,value>的键值对和其映射，分别包含key集合，value集合，entry集合。
TreeMap：按大小排序，LinkedHashSet：按照添加的顺序，LinkedHashSet：无序。
LinkedHashSet和LinkedHashSet依赖元素的hashCode和equals方法。
TreeSet：要不指定java.util.Comparator接口的实现类对象，重写int compare(T t1,T t2)方法。(不需要改元素代码)
要不实现java.lang.Comparable接口重写int compareTo(T t)方法。
HashMap:元素的唯一性是靠所存储元素类型是否重写hashCode()和equals()方法来保证的，如果没有重写这两个方法，则无法保证元素的唯一性。

区别

HashTable与HashMap
1.线程安全：HashTable同步的线程安全的，HashMap线程不安全。
2.空值：HashMap可以有应该null的key无数个null的value，HashTable不能有null。
3.性能：HashMap性能好，HashTable性能差。
必须实现hashCode和equals。
不能保证顺序。
尽量不使用可变对象作为key。

IdentityHashMap和LinkedHashMap和HashMap
LinkedHashMap：使用双向链表维护键值对的顺序，性能低于HashMap。
IdentityHashMap：使用 == 判断两个key是否相等，即对比地址。

Map方法

1.添加
Object put(K key,V value)添加一组键值对，如果key有相同则覆盖value。
putAll(Map m)将应该map中的所有键值对添加到当前map中。
2.删除
void clear()清空
Object remove(Object key)根据key删除key-value
3.查询
int size()：键值对数量。
boolean containsKey(Object key)：是否包含某个key。
boolean containsValue(Object value)：是否包含某个value。
V get(Object key)：根据key获取value。
boolean isEmpty()：Map是否为空，空则ture。
4.遍历
Set<Entry<K,V>> entrySet()：遍历所有键值对。
Set keySet()：遍历所有的key。
Collection values()遍历所有的value。
5.内部类Entry
Object getKey()：返回该Entry包含的key。
Object getValue()：返回该Entry包含的value。
Object setValue()：设置该Entry包含的value，并返回新的value。

HashMap

1.元素的唯一性是靠所存储元素类型是否重写hashCode()(先)和equals()(后)方法来保证的，如果没有重写这两个方法，则无法保证元素的唯一性。
2.通过某个hash函数f，计算出这个Entry的存储位置index。
3.当这个存储位置哈希冲突时，在此处插入一个Entry链表。
4.Entry对象由对象的哈希码，Object key，Object value,Entry next组成。
5.容量：Entry数组的大小默认16。加载因子(0-1)默认0.75：当元素个数大于容量*加载因子时扩容到2倍。
6.冲突8次就会自动转为TreeSet。

HashMapAPI

构造函数可设置容量和加载因子。

TreeMap

1.实现SortedMap接口，是以红黑树实现映射的集合，内部由一个存储Entry类型节点的二叉树组成。一个Entry对象包含Object key，Object value，Entry left，Entry right，Entry parent组成。
2.要不指定java.util.Comparator接口的实现类对象，重写int compare(T t1,T t2)方法。(不需要改元素代码)要不实现java.lang.Comparable接口重写int compareTo(T t)方法。

TreeMapAPI

Object firstKey()：返回第一个key。
Object lastKey()：返回最后一个key。
SortedMap headMap(Object toKey)：返回一个子集，小于toKey。
SortedSet tailMap(Object fromKey,Object toKey)：[fromKey，toKey)的子集。
Comparator comparator()：返回比较器。
TreeMap(Comparator c)：使用c比较器构造一个TreeMap。
TreeMap(Map m)：
TreeMap(SortedMap s)：