Java集合框架

最新推荐文章于 2024-08-28 20:58:28 发布

Java_小学徒

最新推荐文章于 2024-08-28 20:58:28 发布

阅读量55

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_45734499/article/details/116561262

版权

Java集合框架

文章目录

前言
一、collection体系
二、Map体系

前言

集合的概念

对象的容器，定义了多个对象进行操作的的常用方法。可实现数组。
数组长度固定，可以存放基本类型和引用类型
位置：java.util.*

集合的框架

1.总体分为两个体系，collection和Map。collection体系都实现了Iterator接口
2.collection分别被List和Set、Queue继承，主要还是List和Set
3.List的实现类有ArrayList，LinkList和VectorList
4.Set的实现类有HashSet和TreeSet
5.Map有两个比较常用的实现类TreeMap和HashMap

Iterator迭代器

是用来遍历集合的（Map除外），有三个方法常用方法

public static void main(String [] args){
        Collection<String> lin = new ArrayList<>();
        lin.add("小鸟");//添加元素
        lin.add("乌龟");
        lin.add("螃蟹");
        System.out.println(lin.size());//计算集合大小
        System.out.println(lin);
        Iterator<String> it = lin.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
    //运行结果：
    //3
	//[小鸟, 乌龟, 螃蟹]
	//小鸟
	//乌龟
	//螃蟹

一、collection体系

coullection体系集合

Collection接口

特点：无序（插入和取出顺序不一定相同），无下标，可重复

方法

boolean add(E e)
确保此集合包含指定的元素（可选操作）。
boolean addAll(Collection<? extends E> c)
将指定集合中的所有元素添加到此集合（可选操作）。
void clear()
从此集合中删除所有元素（可选操作）。
boolean contains(Object o)
如果此集合包含指定的元素，则返回 true 。
boolean containsAll(Collection<?> c)
如果此集合包含指定集合中的所有元素，则返回true。
boolean equals(Object o)
将指定的对象与此集合进行比较以获得相等性。
int hashCode()
返回此集合的哈希码值。
boolean isEmpty()
如果此集合不包含元素，则返回 true 。
Iterator iterator()
返回此集合中的元素的迭代器。
default Stream parallelStream()
返回可能并行的 Stream与此集合作为其来源。
boolean remove(Object o)
从该集合中删除指定元素的单个实例（如果存在）（可选操作）。
boolean removeAll(Collection<?> c)
删除指定集合中包含的所有此集合的元素（可选操作）。
default boolean removeIf(Predicate<? super E> filter)
删除满足给定谓词的此集合的所有元素。
boolean retainAll(Collection<?> c)
仅保留此集合中包含在指定集合中的元素（可选操作）。
int size()
返回此集合中的元素数。
default Spliterator spliterator()
创建一个Spliterator在这个集合中的元素。
default Stream stream()
返回以此集合作为源的顺序 Stream 。
Object[] toArray()
返回一个包含此集合中所有元素的数组。
T[] toArray(T[] a)
返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。

将对比较常用的方法进行代码演示

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

public class test1 {
    public static void main(String [] args){
        Collection<String> lin1 = new ArrayList<>();//Collection是接口只能new实现类，这里用ArrayList
        Collection<String> lin2 = new ArrayList<>();
        lin1.add("小鸟");//向集合添加元素
        lin1.add("乌龟");
        lin1.add("螃蟹");
        System.out.println(lin1.size());//输出集合元素个数
        System.out.println(lin1);//掉用toString方法，因为String已近重写了toString方法，所以若其他是需要重写toString方法的
        lin2.add("皮皮虾");
        lin2.add("小猴");
        lin1.addAll(lin2);//向集合添加lin2整个集合
        System.out.println(lin1.size());
        System.out.println(lin1);
        /*  3
            [小鸟, 乌龟, 螃蟹]
            5
            [小鸟, 乌龟, 螃蟹, 皮皮虾, 小猴]
         */
        System.out.println(lin2.size());
        lin2.clear();//清空集合的元素,
        System.out.println(lin2.size());
        /*2
          0
         */
        if(lin1.contains("皮皮虾"))//若集合含有皮皮虾，则返回true，否则返回flash
            System.out.println("我有皮皮虾");
        else
            System.out.println("唉，我没有皮皮虾");
        if(lin1.contains("小姐鱼"))
            System.out.println("我有小姐鱼");
        else
            System.out.println("唉，我没有小姐鱼");
        /*
        我有皮皮虾
        唉，我没有小姐鱼
         */
        System.out.println(lin1.isEmpty());//若元素为空则放回true，否则放回flash
        System.out.println(lin2.isEmpty());
        /*  flash
            true
         */
        lin1.remove("皮皮虾");//删除皮皮虾元素
     //   lin1.removeAll(lin2);删除lin1中包含lin2的全部元素
     //   lin1.retainAll(lin2);保留lin1和lin2共有的元素，类似于求交集
        Iterator<String> it = lin1.iterator();//返回一个迭代器，用来遍历集合
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //迭代器遍历
        for(String a:lin1){
            System.out.println(a);
        }
        //增强for遍历
    }
 }

List接口

特点：有序（插入元素与取出元素相同），要下标，可重复

方法
继承自Collection接口，拥有Collection接口的全部方法；也有新加的方法

void add(int index, E element)
将指定的元素插入此列表中的指定位置（可选操作）。
boolean addAll(int index, Collection<? extends E> c)
将指定集合中的所有元素插入到此列表中的指定位置（可选操作）。
E get(int index)
返回此列表中指定位置的元素。
int indexOf(Object o)
返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
int lastIndexOf(Object o)
返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
ListIterator listIterator()//这个的返回值是ListIterator
返回列表中的列表迭代器（按适当的顺序）。
ListIterator listIterator(int index)//这个的返回值是ListIterator
从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
E remove(int index)
删除该列表中指定位置的元素（可选操作）。
E set(int index, E element)
用指定的元素（可选操作）替换此列表中指定位置的元素。

上代码前先解释一下ListIterator，这个也是一个迭代器，他的继承至Iterator，他拥有更强的功能，在之后代码遍历是会用一下，以下是他的方法

void add(E e)
将指定的元素插入列表（可选操作）。
boolean hasNext()
返回 true如果遍历正向列表，列表迭代器有多个元素。
boolean hasPrevious()
返回 true如果遍历反向列表，列表迭代器有多个元素。
E next()
返回列表中的下一个元素，并且前进光标位置。
int nextIndex()
返回随后调用 next()返回的元素的索引。
E previous()
返回列表中的上一个元素，并向后移动光标位置。
int previousIndex()
返回由后续调用 previous()返回的元素的索引。
void remove()
从列表中删除由 next()或 previous()返回的最后一个元素（可选操作）。
void set(E e)
用指定的元素替换由 next()或 previous()返回的最后一个元素（可选操作）。

上代码

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

public class test2 {
    public static void main(String [] args){
        List<String> li1 = new ArrayList<>();
        List<String> li2 = new ArrayList<>();
        li1.add("苹果");
        li1.add("荔枝");
        li1.add("香蕉");
        li1.add("苹果");
        li2.add("西瓜");
        li2.add("哈密瓜");
        System.out.println("li:"+li1);
        li1.add(3,"火龙果");//在特定位置插入元素
        System.out.println("li:"+li1);
        /*
        li1:[苹果, 荔枝, 香蕉, 苹果]
        li1:[苹果, 荔枝, 香蕉, 火龙果, 苹果]
         */
        System.out.println("li2:"+li2);
        li1.addAll(2,li2);//在特定位置插入整个集合
        System.out.println("li:"+li1);
        /*
        li2:[西瓜, 哈密瓜]
        li1:[苹果, 荔枝, 西瓜, 哈密瓜, 香蕉, 火龙果, 苹果]
         */
        System.out.println(li1.get(2));//获取指定位置的元素
        //西瓜
        System.out.println(li1.indexOf("西瓜"));//重头开始查找，即从第一个元素开始查找
        System.out.println(li1.lastIndexOf("西瓜"));//从最后一个元素开始查找
        /*
        2
        2
         */
        System.out.println("li1:"+li1);
        li1.remove(2);//删除指定位置上的元素
        System.out.println("li1:"+li1);
        li1.set(2,"梨子");//把指定位置上的元素代替掉
        System.out.println("li1:"+li1);
        /*
        li1:[苹果, 荔枝, 西瓜, 哈密瓜, 香蕉, 火龙果, 苹果]
        li1:[苹果, 荔枝, 哈密瓜, 香蕉, 火龙果, 苹果]
        li1:[苹果, 荔枝, 梨子, 香蕉, 火龙果, 苹果]
         */
        //开始遍历，因为有下标所以可以用普通的for进行遍历
        for(int i=0;i<li1.size();i++) {
            System.out.print(li1.get(i)+" ");
        }
        System.out.println();
        for(String a:li1){
            System.out.print(a+" ");
        }
        ListIterator<String> lit = li1.listIterator();
        while(lit.hasNext()){//正向遍历
            System.out.println(lit.next());
        }
        while(lit.hasPrevious()){
            //反向遍历，用之前指针要指向后面，因为上面正常遍历了一次，指针已经到最后，如果需要可调用listIterator(int index)函数
            System.out.println(lit.previous());
        }

    }
}

List实现类

ArrayList类：底层采用数组实现，查询快，增删慢，线程不安全
如果未向集合添加元素，容量为0，添加1个元素后容量为10，之后以1.5倍空间增长空间。
构造方法
public ArrayList(int initialCapacity)
构造具有指定初始容量的空列表。
public ArrayList()
构造一个初始容量为十的空列表。
public ArrayList(Collection<? extends E> c)
构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。

import java.util.ArrayList;
import java.util.ListIterator;

public class test3 {
    public static void main(String []args){
        ArrayList<String> ali = new ArrayList<>();
        ali.add("椅子");
        ali.add("桌子");
        ali.add("床");
        ali.add("沙发");
        System.out.println("ali:"+ali);
        ali.remove(3);
        System.out.println("ali:"+ali);
        //遍历
        for(int i=0;i<ali.size();i++){
            System.out.print(ali.get(i)+" ");
        }
        System.out.println();
        for(String a:ali){
            System.out.print(a+" ");
        }
        System.out.println();
        ListIterator<String> lit = ali.listIterator();
        while(lit.hasNext()){
            System.out.print(lit.next()+" ");
        }
        System.out.println();
        while(lit.hasPrevious()){
            System.out.print(lit.previous()+" ");
        }
    }
}
/*
ali:[椅子, 桌子, 床, 沙发]
ali:[椅子, 桌子, 床]
椅子 桌子 床 
椅子 桌子 床 
椅子 桌子 床 
床 桌子 椅子 
*/

LinkedList类：底层采用链表实现，查询慢，增删快，线程不安全

构造方法：

LinkedList()
构造一个空列表。
LinkedList(Collection<? extends E> c)
构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。

新增的方法
void addFirst(E e)
在该列表开头插入指定的元素。
void addLast(E e)
将指定的元素追加到此列表的末尾。
E getFirst()
返回此列表中的第一个元素。
E getLast()
返回此列表中的最后一个元素。
E peek()
检索但不删除此列表的头（第一个元素）。
E peekFirst()
检索但不删除此列表的第一个元素，如果此列表为空，则返回 null 。
E peekLast()
检索但不删除此列表的最后一个元素，如果此列表为空，则返回 null 。
E poll()
检索并删除此列表的头（第一个元素）。
E pollFirst()
检索并删除此列表的第一个元素，如果此列表为空，则返回 null 。
E pollLast()
检索并删除此列表的最后一个元素，如果此列表为空，则返回 null 。
E pop()
从此列表表示的堆栈中弹出一个元素。与removeFirst一样，实际上它就是removeFirst
void push(E e)
将元素推送到由此列表表示的堆栈上。与addFirst一样，实际上它就是addFirst
E remove()
检索并删除此列表的头（第一个元素）。
E remove(int index)
删除该列表中指定位置的元素。
boolean remove(Object o)
从列表中删除指定元素的第一个出现（如果存在）。
E removeFirst()
从此列表中删除并返回第一个元素。
boolean removeFirstOccurrence(Object o)
删除此列表中指定元素的第一个出现（从头到尾遍历列表时）。
E removeLast()
从此列表中删除并返回最后一个元素。

import java.util.LinkedList;

public class test4 {
    public static void main(String []args){
        LinkedList<String> linkList = new LinkedList<>();
        linkList.add("two");
        linkList.add("three");//在尾部添加元素
        System.out.println(linkList);
        //[two, three]
        linkList.addFirst("one");//在头部插入元素
        linkList.addLast("four");//在尾部插入元素
        //[one, two, three, four]
        System.out.println(linkList);
        linkList.add(4,"five");
        System.out.println(linkList);
        //[one, two, three, four, five]
        linkList.remove();//删除第一个元素
        System.out.println(linkList);
        //[two, three, four, five]
        linkList.removeFirst();//删除第一个元素
        linkList.removeLast();//删除最后一个元素
        System.out.println(linkList);
        //[three, four]
        linkList.remove(0);
        linkList.remove("four");
        System.out.println(linkList);
        //[]
        linkList.add("one");
        linkList.add("two");
        linkList.add("three");
        linkList.add("four");
        linkList.add("five");
        linkList.add("six");
        System.out.println(linkList);
        System.out.println("get(index): " + linkList.get(3));//获取下表为3的元素
        System.out.println("getFirst: " + linkList.getFirst());//获取第一个元素
        System.out.println("getLast: " + linkList.getLast());//获取最后一个元素
        /*
        [one, two, three, four, five, six]
        get(index): four
        getFirst: one
        getLast: six
         */
        linkList.clear();//清空集合
        linkList.push("one");//在头部插入元素
        linkList.push("two");
        linkList.push("three");
        linkList.push("four");
        linkList.push("five");
        linkList.push("six");
        System.out.println(linkList);
        System.out.println("pop: " + linkList.pop());//删除最后一个元素
        System.out.println("after pop: " + linkList);
        /*
        [six, five, four, three, two, one]
        pop: six
        after pop: [five, four, three, two, one]
         */
        System.out.println("poll: " + linkList.poll());//检索第一个元素并删除
        System.out.println("after poll: " + linkList);
        /*
        poll: five
        after poll: [four, three, two, one]
         */
        System.out.println("peek: " + linkList.peek());//检索第一个元素不删除
        System.out.println("after peek: " + linkList);
        /*
        peek: four
        after peek: [four, three, two, one]
         */



    }
}

Vector类（不太常用，用ArrayList较多）：底层采用数组实现，查询快，增删慢，线程安全，已2倍扩展。比较少用，需要直接看下面方法。
方法
boolean add(E e)
将指定的元素追加到此Vector的末尾。
void add(int index, E element)
在此Vector中的指定位置插入指定的元素。
boolean addAll(Collection<? extends E> c)
将指定集合中的所有元素追加到该向量的末尾，按照它们由指定集合的迭代器返回的顺序。
boolean addAll(int index, Collection<? extends E> c)
将指定集合中的所有元素插入到此向量中的指定位置。
void addElement(E obj)
将指定的组件添加到此向量的末尾，将其大小增加1。
int capacity()
返回此向量的当前容量。
void clear()
从此Vector中删除所有元素。
Object clone()
返回此向量的克隆。
boolean contains(Object o)
如果此向量包含指定的元素，则返回 true 。
boolean containsAll(Collection<?> c)
如果此向量包含指定集合中的所有元素，则返回true。
void copyInto(Object[] anArray)
将此向量的组件复制到指定的数组中。
E elementAt(int index)
返回指定索引处的组件。
Enumeration elements()
返回此向量的组件的枚举。
void ensureCapacity(int minCapacity)
如果需要，增加此向量的容量，以确保它可以至少保存最小容量参数指定的组件数。
boolean equals(Object o)
将指定的对象与此向量进行比较以获得相等性。
E firstElement()
返回此向量的第一个组件（索引号为 0的项目）。
void forEach(Consumer<? super E> action)
对 Iterable的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常。
E get(int index)
返回此向量中指定位置的元素。
int hashCode()
返回此Vector的哈希码值。
int indexOf(Object o)
返回此向量中指定元素的第一次出现的索引，如果此向量不包含元素，则返回-1。
int indexOf(Object o, int index)
返回此向量中指定元素的第一次出现的索引，从 index向前 index ，如果未找到该元素，则返回-1。
void insertElementAt(E obj, int index)
在指定的index插入指定对象作为该向量中的一个 index 。
boolean isEmpty()
测试此矢量是否没有组件。
Iterator iterator()
以正确的顺序返回该列表中的元素的迭代器。
E lastElement()
返回向量的最后一个组件。
int lastIndexOf(Object o)
返回此向量中指定元素的最后一次出现的索引，如果此向量不包含元素，则返回-1。
int lastIndexOf(Object o, int index)
返回此向量中指定元素的最后一次出现的索引，从 index ，如果未找到元素，则返回-1。
ListIterator listIterator()
返回列表中的列表迭代器（按适当的顺序）。
ListIterator listIterator(int index)
从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
E remove(int index)
删除此向量中指定位置的元素。
boolean remove(Object o)
删除此向量中指定元素的第一个出现如果Vector不包含元素，则它不会更改。
boolean removeAll(Collection<?> c)
从此Vector中删除指定集合中包含的所有元素。
void removeAllElements()
从该向量中删除所有组件，并将其大小设置为零。
boolean removeElement(Object obj)
从此向量中删除参数的第一个（最低索引）出现次数。
void removeElementAt(int index)
删除指定索引处的组件。
boolean removeIf(Predicate<? super E> filter)
删除满足给定谓词的此集合的所有元素。
protected void removeRange(int fromIndex, int toIndex)
从此列表中删除所有索引为 fromIndex （含）和 toIndex之间的元素。
void replaceAll(UnaryOperator operator)
将该列表的每个元素替换为将该运算符应用于该元素的结果。
boolean retainAll(Collection<?> c)
仅保留此向量中包含在指定集合中的元素。
E set(int index, E element)
用指定的元素替换此Vector中指定位置的元素。
void setElementAt(E obj, int index)
设置在指定的组件 index此向量的要指定的对象。
void setSize(int newSize)
设置此向量的大小。
int size()
返回此向量中的组件数。
void sort(Comparator<? super E> c)
使用提供的 Comparator对此列表进行排序以比较元素。
Spliterator spliterator()
在此列表中的元素上创建late-binding和故障切换 Spliterator 。
List subList(int fromIndex, int toIndex)
返回此列表之间的fromIndex（包括）和toIndex之间的独占视图。
Object[] toArray()
以正确的顺序返回一个包含此Vector中所有元素的数组。
T[] toArray(T[] a)
以正确的顺序返回一个包含此Vector中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。
String toString()
返回此Vector的字符串表示形式，其中包含每个元素的String表示形式。
void trimToSize()
修改该向量的容量成为向量的当前大小。

Set接口

特点：无序（插入顺序和取出顺序不一定相同），无下标，不可重复

方法：继承至Collection接口，方法类似
这两个方法要注意，存储位置和这两个函数有关，后面讲解
int hashCode()
返回此集合的哈希码值。
boolean equals(Object o)
将指定的对象与此集合进行比较以实现相等。

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class test5 {
    public static void main(String []args){
        Set<String> s = new HashSet<>();
        //增
        s.add("one");
        s.add("two");
        s.add("three");
        s.add("four");
        s.add("four");//不可重复
        System.out.println(s);
        //[four, one, two, three]
        //删
        s.remove("four");
        System.out.println(s);
        //[one, two, three]
        //遍历
        for(String a : s){
            System.out.println(a);
        }
        Iterator it = s.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

Set实现类

HashSet
底层采用哈希表（数组+链表+红黑树）实现。
构造方法：
HashSet()
构造一个新的空集合; 背景HashMap实例具有默认初始容量（16）和负载因子（0.75）。
HashSet(Collection<? extends E> c)
构造一个包含指定集合中的元素的新集合。
HashSet(int initialCapacity)
构造一个新的空集合; 背景HashMap实例具有指定的初始容量和默认负载因子（0.75）。
HashSet(int initialCapacity, float loadFactor)
构造一个新的空集合; 背景HashMap实例具有指定的初始容量和指定的负载因子。
这里解释一下负载因子：比如说当前的容器容量是16，负载因子是0.75,16*0.75=12，当容量达到了12的时候就会进行扩容操作。
方法

import java.util.HashSet;
import java.util.Iterator;

public class test6 {
    public static void main(String []args){
        HashSet<String> hs = new HashSet<>();
        hs.add("松树");
        hs.add("柳树");
        hs.add("槐树");
        hs.add("葵树");
        System.out.println(hs);
        hs.remove("葵树");
        System.out.println(hs);
        //[柳树, 槐树, 葵树, 松树]
        //[柳树, 槐树, 松树]
        Iterator<String> it = hs.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        for(String a:hs){
            System.out.println(a);
        }
    }
}

最后再说一下HashSet的存储方式，要插入元素是先调用 hashCode()来决定存储的位置，在调用equals方法来比较是否要存储
在这里插入图片描述

TreeSet：
特点： TreeSet的底层数据结构是红黑树，特点：唯一且有序， TreeSet集合会自动对元素进行排序，默认是升序排序。要改变排序方式可通过改变比较器。
构造方法：
TreeSet()
构造一个新的，空的树组，根据其元素的自然排序进行排序。
TreeSet(Collection<? extends E> c)
构造一个包含指定集合中的元素的新树集，根据其元素的自然排序进行排序。
TreeSet(Comparator<? super E> comparator)
构造一个新的，空的树集，根据指定的比较器进行排序。
TreeSet(SortedSet s)
构造一个包含相同元素的新树，并使用与指定排序集相同的顺序。

主要了解下面这个方法：
Comparator<? super E> comparator()
返回用于对该集合中的元素进行排序的比较器，或null，如果此集合使用其元素的natural ordering 。

import java.util.Comparator;
import java.util.Objects;

public class Students implements Comparator<Students>{
    String name;
    int id;
    Students(){}
    Students(String n,int i){
        name = n;
        id = i;
    }
    public String toString() {//重写toString方法
        return "{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }

    public boolean equals(Students o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        if(o.id == this.id){
            return false;
        }
        else{
            return true;
        }
    }
    public int hashCode() {
        return Objects.hash(name, id);
    }
    public int compare(Students o1, Students o2) {
        if(o1.id == o2.id){
            return o2.name.compareTo(o1.name);
        }
        else if(o1.id<o2.id){
            return 1;
        }
        else {
            return -1;
        }
    }
}

import java.util.Objects;

public class People implements Comparable<People>{
    String name;
    int id;
    People(String name,int id){
        this.name=name;
        this.id=id;
    }
    public String toString() {//重写toString方法
        return "{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
    public boolean equals(People o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        if(o.id == this.id){
            return false;
        }
        else{
            return true;
        }
    }
    public int hashCode() {
        return Objects.hash(name, id);
    }
    
    public int compareTo(People o) {
        if(this.id == o.id){
            return o.name.compareTo(this.name);
        }
        else if(this.id>o.id){
            return 1;
        }
        else {
            return -1;
        }
    }

}

import java.util.Iterator;
import java.util.TreeSet;

public class test7 {
    public static void main(String []args){
        TreeSet<Students> ts =new TreeSet<>(new Students());
        ts.add(new Students("刘德华",1));
        ts.add(new Students("周润发",2));
        ts.add(new Students("周星驰",3));
        ts.add(new Students("彭于晏",4));
        ts.add(new Students("陈冠希",5));
        ts.add(new Students("刘德华",6));
        System.out.println(ts);
        //[{name='刘德华', id=6}, {name='陈冠希', id=5}, {name='彭于晏', id=4}, {name='周星驰', id=3}, {name='周润发', id=2}, {name='刘德华', id=1}]
        TreeSet<People> ts1 =new TreeSet<>();
        ts1.add(new People("刘德华",1));
        ts1.add(new People("周润发",2));
        ts1.add(new People("周星驰",3));
        ts1.add(new People("彭于晏",4));
        ts1.add(new People("陈冠希",5));
        ts1.add(new People("刘德华",6));
        System.out.println(ts1);
        //[{name='刘德华', id=1}, {name='周润发', id=2}, {name='周星驰', id=3}, {name='彭于晏', id=4}, {name='陈冠希', id=5}, {name='刘德华', id=6}]
        //遍历
        Iterator<People> it = ts1.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //{name='刘德华', id=1}
        //{name='周润发', id=2}
        //{name='周星驰', id=3}
        //{name='彭于晏', id=4}
        //{name='陈冠希', id=5}
        //{name='刘德华', id=6}
    }
}

让元素自身具备比较排序功能，具备比较排序功能的元素只需要实现Comparable 接口。覆盖接口中CompareTo方法。(People类，采用id升序）
让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。（Students类采用id降序）
两种方法都要实现Comparable接口

二、Map体系

在这里插入图片描述

Map接口

特点：Map集合是键值对形式存储值的，Map中的集合不能包含重复的键，值可以重复。每个键只能对应一个值。

常用方法
int size();
返回此映射中的键-值映射关系数。
boolean isEmpty();
如果此映射未包含键-值映射关系，则返回 true。
boolean containsKey(Object key);
如果此映射包含指定键的映射关系，则返回 true。
boolean containsValue(Object value)
如果此映射将一个或多个键映射到指定值，则返回 true。
V get(Object key);
根据key查找对应value数据，如果没有，则返回 null。
V put(K key, V value);
向集合保存数据可选操作）。
V remove(Object key);
如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
void putAll(Map<? extends K, ? extends V> m);
从指定映射中将所有映射关系复制到此映射中（可选操作）。
void clear();
从此映射中移除所有映射关系（可选操作）。
interface Entry<K, V> {
K getKey();
V getValue();
V setValue(V value);
boolean equals(Object o);
int hashCode();
}
Set KeySet();
返取出全部key。
Collection values();
返回此映射中包含的值的 Collection 视图。
Set<Map, Entry<K, V>> entrySet();
即将Map集合转化为Set集合。

以下重点掌握遍历方法

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class test8 {
    public static  void main(String[] args){
        Map<Integer,String> m1 = new HashMap<>();
        m1.put(11,"郭富城");
        m1.put(12,"黎明");
        Map<Integer,String> m = new HashMap<>();
        m.put(1,"刘德华");
        m.put(2,"彭于晏");
        m.put(3,"吴彦祖");
        m.put(4,"周星驰");
        m.put(5,"成龙");
        System.out.println(m.size());//5
        System.out.println(m);//{1=刘德华, 2=彭于晏, 3=吴彦祖, 4=周星驰, 5=成龙}
        System.out.println(m.isEmpty());//false
        System.out.println(m.containsKey(1));//true
        System.out.println(m.containsValue("刘德华"));//true
        System.out.println(m.get(1));//刘德华
        m.remove(1);
        System.out.println(m);//{2=彭于晏, 3=吴彦祖, 4=周星驰, 5=成龙}
        m.putAll(m1);
        System.out.println(m);//{2=彭于晏, 3=吴彦祖, 4=周星驰, 5=成龙, 11=工程, 12=黎明}
        //Map遍历
        //方法一
        Iterator<Map.Entry<Integer,String>> it1 = m.entrySet().iterator();
        while(it1.hasNext()){
            Map.Entry<Integer,String> a = it1.next();
            System.out.println("key="+a.getKey()+" valus="+a.getValue());
        }
        //方法二
        Iterator<Integer> i = m.keySet().iterator();
        while(i.hasNext()){
            int a = i.next();
            System.out.println("key="+a+" valus="+m.get(a));
        }
        //方法三
        for(Map.Entry<Integer,String> a : m.entrySet()){
            System.out.println("key="+a.getKey()+" valus="+a.getValue());
        }
        //方法四
        for(int a:m.keySet()){
            System.out.println("key="+a+" valus="+m.get(a));
        }
    }
}

HashMap实现类

构造方法：
HashMap()
构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。
HashMap(int initialCapacity)
构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。
HashMap(int initialCapacity, float loadFactor)
构造一个空的 HashMap具有指定的初始容量和负载因子。
HashMap(Map<? extends K,? extends V> m)
构造一个新的 HashMap与指定的相同的映射 Map 。

底层采用哈希表实现，方法使用和Map接口类似

TreeMap实现类

构造方法
TreeMap()
使用其键的自然排序构造一个新的空树状图。
TreeMap(Comparator<? super K> comparator)
构造一个新的，空的树图，按照给定的比较器排序。
TreeMap(Map<? extends K,? extends V> m)
构造一个新的树状图，其中包含与给定地图相同的映射，根据其键的自然顺序进行排序。
TreeMap(SortedMap<K,? extends V> m)
构造一个包含相同映射并使用与指定排序映射相同顺序的新树映射。

底层采用树实现，方法使用和Map接口类似

HashMap与TreeMap的比较
1、HashMap基于哈希表实现。TreeMap基于树实现。
2、HashMap可以通过调优初始容量和负载因子，优化HashMap空间的使用。
TreeMap没有调优选项，因为该树总处于平衡状态
3、HashMap性能优于TreeMap。

Java_小学徒

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java集合框架

Java集合框架文章目录前言集合的概念集合的框架Iterator迭代器一、collection体系Collection接口List接口List实现类前言集合的概念对象的容器，定义了多个对象进行操作的的常用方法。可实现数组。数组长度固定，可以存放基本类型和引用类型位置：java.util.*集合的框架1.总体分为两个体系，collection和Map。collection体系都实现了Iterator接口2.collection分别被List和Set、Queue继承，主要还是List和
复制链接

扫一扫