Collection集合

Collection集合（单列集合）

是一个单列集合，有以下关系。

List ：有序(存储顺序和取出顺序一致)，可重复
ArrayList：线程不安全，底层使用数组实现，查询快，增删慢，效率高。
LinkedList ：线程不安全，底层使用链表实现，查询慢，增删快，效率高。
Vector ：线程安全，底层使用数组实现，查询快，增删慢，效率低。每次容量不足时，默认自增长度的一倍（如果不指定增量的话）

Set :元素唯一一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。
HashSet :底层是由HashMap实现的，通过对象的hashCode方法与equals方法来保证插入元素的唯一性，无序(存储顺序和取出顺序不一致)，。
LinkedHashSet: 底层数据结构由哈希表和链表组成。哈希表保证元素的唯一性，链表保证元素有序。(存储和取出是一致)
TreeSet :基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。元素唯一。

Collection接口的常用方法：

1)add:添加单个元素
2) remove:删除指定元素
3)contains:查找元素是否存在
4)size:获取元素个数
5)isEmpty:判断是否为空
6) clear:清空
7)addAll:添加多个元素
8)containsAll:查找多个元素是否都存在
9)removeAll:删除多个元素

package com.test;

import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.Collection;

public class MyTest {

    @Test
    public void test1(){

        Collection col= new ArrayList();
        col.add("hello");
        col.add(2);
        col.add(2);
        col.remove(2);
        col.addAll(col);//添加多个的参数为Collection类型的值，自身也可以
        System.out.println("大小: "+col.size());
        if (col.contains(2)){
            System.out.println("含有2");
        }

        if (col.containsAll(col)){//参数为Collection类型的值，自身也可以
            System.out.println("含有col");
        }

        if (!col.isEmpty()){
            for (Object o1:col) {
            System.out.println(o1);
            }
        }
        
        col.removeAll(col);//删除多个
        col.clear();//清空
        
    }


}

遍历方式：

迭代器Interator


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

public class Mitrator {
    public static void main(String[] args) {
        //使用Iterator迭代器对Collection下的类内容进行遍历
        //快捷键: itit
        Collection al=new ArrayList();
        al.add(new Book("三国",22,"罗贯中"));
        al.add(new Book("水浒",23,"施耐庵"));
        al.add(new Book("红楼梦",24,"曹雪芹"));

        //1.获取对象的Iterator迭代器
        Iterator iterator= al.iterator();
        //2.遍历内容
        while (iterator.hasNext()) {
            Object obj =  iterator.next();
            System.out.println("内容"+obj.toString());
        }


    }
}

//book实体类
class Book{
    String name;
    int price;
    String author;
    Book(){}
    Book(String name,int price,String author){
        this.author=author;
        this.name=name;
        this.price=price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                ", author='" + author + '\'' +
                '}';
    }
}

foreach(增强for循环）

for (Book book : a1) {
System.out.println("book=" + book)
}

List

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。List中可以有相同的元素，可以有null值。

继承关系：

List:元素是有序的(怎么存的就怎么取出来，顺序不会乱)，元素可以重复（角标1上有个3，角标2上也可以有个3）因为该集合体系有索引，
ArrayList：底层的数据结构使用的是数组结构（数组长度是可变的百分之五十延长）（特点是查询很快，但增删较慢）线程不同步
LinkedList：底层的数据结构是链表结构（特点是查询较慢，增删较快）
Vector：底层是数组数据结构线程同步（数组长度是可变的百分之百延长）（无论查询还是增删都很慢，被ArrayList替代了）

常用方法（除去从Collection继承的）：

list.addAll(2,list);//添加一个集合到指定位置后面的元素后移
list.indexOf("lwx");//获取第一次出现该值的索引
list.lastIndexOf("lwx");//获取最后一个该值的索引
list.remove(1);//移除指定位置元素
list.get(2);//根据索引得到值
list.set(0, "lx");//替换指定位置的元素的值
list=list.subList(0,2);//获取指定片段，前闭后开路径
list.toArray();//集合转为数组，顺序不变
list.clear();//清空集合

处理方式：

排序，使用java.util.Collections.sort

sort(list,new Comparator);//第二个参数为比较器，需要自己写

写一个比较器类，实现接口Comparator，重写compare(Object o1,Object o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。（按这种为正序，从小到大）

若比较o1,o2,和上面的写法相反，可以实现倒序排序。

eg:

//实体
package com.cn.pojo;

public class Student {
    private int id;
    private  String name;
    private  int score;

    public Student() {
    }

    public Student(int id, String name, int score) {
        this.id = id;
        this.name = name;
        this.score = score;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

//比较器：
package com.cn.compare;

import com.cn.pojo.Student;
import java.util.Comparator;

public class Stu_Compare implements Comparator<Student>{


    @Override
    public int compare(Student s1, Student s2) {
        if (s1.getScore()>s2.getScore()){
            return 1;
        }else if (s1.getScore()== s2.getScore()){
          if (s1.getId()>s2.getId()){
              return 1;
          }else if (s1.getId()==s2.getId()){return 0;}
          else {return -1;}
        }else{
            return -1;
        }

    }
}

//调用测试
package com.cn.test;

import com.cn.compare.Stu_Compare;
import com.cn.pojo.Student;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class MyTest {
    public static void main(String[] args) {

        List<Student> list=new ArrayList<>();
        list.add(new Student(1,"张三",77));
        list.add(new Student(2,"李四",50));
        list.add(new Student(3,"王五",99));
        list.add(new Student(4,"赵六",22));
        list.add(new Student(5,"田七",100));

        Collections.sort(list,new Stu_Compare());
        for (Student s:list) {
            System.out.println(s);
        }


    }
}

输出结果：

2.排序方式二

通过实体类自身实现Comparable接口，重写compareTo方法，然后调用Collections的sort方法。

package com.cn.pojo;

public class Student implements Comparable<Student>{//实现接口，指定类型
    private int id;
    private  String name;
    private  int score;

    public Student() {
    }

    public Student(int id, String name, int score) {
        this.id = id;
        this.name = name;
        this.score = score;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }



    @Override
    public int compareTo(Student s1) {//排序方式,返回大于0则this对应大于s1，小于零则this对应的小于s1对应的，等于零则相等
        return s1.getScore()-this.getScore();
    }
}

调用：

package com.cn.test;

import com.cn.compare.Stu_Compare;
import com.cn.pojo.Student;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class MyTest {
    public static void main(String[] args) {

        List<Student> list=new ArrayList<>();
        list.add(new Student(1,"张三",77));
        list.add(new Student(2,"李四",50));
        list.add(new Student(3,"王五",99));
        list.add(new Student(4,"赵六",22));
        list.add(new Student(5,"田七",100));

        Collections.sort(list);//调用
        
        for (Student s:list) {
            System.out.println(s);
        }


    }
}

结果：

遍历方式：

相比Collection，List可以使用普通的for循环进行便利，使用get( i )方法获取值。

List转数组（强制转换）

package com.cn.test;

import java.util.ArrayList;
import java.util.List;

public class MyTest2 {
    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        list.add("111");
        list.add("222");
        final int size=list.size();
        String[] strings=(String[]) list.toArray(new String[size]);
        for (int i = 0; i < size; i++) {
            System.out.println(strings[i]);
        }
    }
}

List去重

方式一：（有序）

新建一个List,遍历原list，使用contains()方法判断新List是否有原list的当前get()的值，如果有则跳过，如果没有则将当前值放入我们的新list中进行保存。

package com.cn.test;

import java.util.ArrayList;
import java.util.List;

public class MyTest3 {
    public static void main(String[] args) {
        List<Integer>  list=new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(5);
        list.add(5);

        List<Integer> list2=new ArrayList<Integer>();
        for (int i = 0; i <list.size() ; i++) {
            if (!list2.contains(list.get(i))){
                list2.add(list.get(i));//不含有则加入新的list中，含有跳过
            }
        }

        for (Object o : list2) { //输出检验
            System.out.println(o);
        }


    }


}

方式二：(无序)

使用Iterator迭代器和indexOf()lastIndexOf()获取前后的下标值，比较前后的下标值

package com.cn.test;

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

public class Test4 {
    public static void main(String[] args) {

        List<Integer> list=new ArrayList<Integer>();

        list.add(1);
        list.add(2);
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(5);
        list.add(5);
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            // 获取循环的值
            Object item = iterator.next();
            // 如果存在两个相同的值,则从前后获取的前后下标不同
            if (list.indexOf(item) != list.lastIndexOf(item)) {
                // 移除最后那个相同的值
                iterator.remove();
            }
        }
        System.out.println("去重集合:" + list);

    }

方式三：(无序)

list转set去重。

package com.cn.test;

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

public class Test4 {
    public static void main(String[] args) {

        List<Integer> list=new ArrayList<Integer>();

        list.add(1);
        list.add(2);
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(5);
        list.add(5);
Test4.method_3(list);

    }

    public static void method_3(List<Integer> list){
        HashSet<Integer> set=new HashSet<>(list);
        System.out.println("去重set："+set);
    }

}

方式四： LinkedHashSet转换（有序）

package com.cn.test;

import java.util.*;

public class Test4 {
    public static void main(String[] args) {

        List<Integer> list=new ArrayList<Integer>();

        list.add(1);
        list.add(2);
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(5);
        list.add(5);
	Test4.method_4(list);

    }


    public static void method_4(List<Integer> list){
        LinkedHashSet<Integer> set = new LinkedHashSet<>(list);
        System.out.println("去重集合:" + set);
    }
}

方式五：TreeSet去重（无序）

package com.cn.test;

import java.util.*;

public class Test4 {
    public static void main(String[] args) {

        List<Integer> list=new ArrayList<Integer>();

        list.add(1);
        list.add(2);
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(5);
        list.add(5);
Test4.method_5(list);

    }

    public static void method_5(List<Integer> list){
        TreeSet<Integer> set = new TreeSet<>(list);
        System.out.println("去重集合:" + set);
    }

}

方式六：Stream去重(有序)

package com.cn.test;

import java.util.*;
import java.util.stream.Collectors;

public class Test4 {
    public static void main(String[] args) {

        List<Integer> list = new ArrayList<Integer>();

        list.add(1);
        list.add(2);
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(5);
        list.add(5);
        Test4.method_6(list);

    }

    public static void method_6(List<Integer> list) {
        list = list.stream().distinct().collect(Collectors.toList());
        System.out.println("去重集合:" + list);
    }

}

ArrayList

ArrayList底层是一个Object数组，对所有的底层操作就是基于数组实现的。且ArrayList是不同步的，性能上比Vector好一点，在多线程环境中需要自己管理线程同步问题。

构造方法：

ArrayList()
// 构造一个初始容量为 10 的空列表（每次递增容量为原来的1.5倍）
ArrayList(Collection<? extends E> c)
// 构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的
ArrayList(int initialCapacity)
//构造一个具有指定初始容量的空列表

常用方法：（除去List中的方法）

void ensureCapacity(int minCapacity)
//如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
void removeRange(int fromIndex, int toIndex)
//移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。

List中方法：链接(List)

ArrayLsit底层代码：

ArrayList中维护了一个Object类型的数组

transient Object[] elementData;

transeent 表示瞬息的，短暂的，表示该属性不会被序列号

每创建ArrayList对象时，如果使用的事无参构造，则对应的elementData容量为0，第一次添加，则扩容为10，如果需要再次扩容，则扩容为原来的1.5倍大小
如果使用的是指定大小的构造器进行创建的ArrayList对象，则enementData为指定的大小，扩容时为原来的1.5倍

遍历方式：

Iterator迭代器遍历，for增强。

去重方式：

使用HashSet去重

package com.cn.test;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

public class MyTest3 { //新建List去重
    public static void main(String[] args) {
       ArrayList<Integer>  list=new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(5);
        list.add(5);

        HashSet<Integer>  hashSet=new HashSet<Integer>(list);
        ArrayList<Integer> arrayList=new ArrayList<Integer>(hashSet);
        
        for (Object o : arrayList) {
            System.out.println(o);
        }

    }
    
}

使用LinkedHashSet删除ArrayList中重复元素，

LinkedHashSet<Integer> linkedHashSet=new LinkedHashSet<Integer>(list);
ArrayList<Integer> arrayList=new ArrayList<Integer>(linkedHashSet);

删除特定不同元素：

remove删除特定元素

package com.cn.test;

import java.util.ArrayList;
public class MyTest3 { //新建List去重
    public static void main(String[] args) {
        ArrayList<Integer>  list=new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(5);
        list.add(5);

        for (int i = 0; i < list.size(); i++) {
            if (list.get(i)==5)
            {
                list.remove(i);
                i--;
            }
        }

        for (Object o : list) {
            System.out.println(o);
        }

    }

}

结果：

使用Iterator迭代器和equals()比较删除

Iterator<String> sListIterator = list.iterator();  
while(sListIterator.hasNext()){  
    String e = sListIterator.next();  
    if(e.equals("3")){  
    sListIterator.remove();  
    }  
}

排序:

使用Collections.sort()对字符串类型排序

package com.cn.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;

public class MyTest3 { //新建List去重
    public static void main(String[] args) {
        ArrayList<String>  list=new ArrayList<String>();
        list.add("apple");
        list.add("banana");
        list.add("orange");
        list.add("watermelon");


        System.out.println("正序:");
        Collections.sort(list);//字母正序
        Iterator<String> iterator= list.iterator();
        while (iterator.hasNext()) {
            String next =  iterator.next();
            System.out.println(next);
        }

        System.out.println("逆序:");
        Collections.sort(list,Collections.reverseOrder());//字母逆序
        Iterator iterator2= list.iterator();

        while (iterator2.hasNext()) {
            Object next =  iterator2.next();
            System.out.println(next);
        }
    }

}

使用Comparator排序,和List中的相同
使用Comparable排序,同List中的

合并ArrayList并去重:

使用remainAll(参数):保留参数和this调用的交集到调用this之中

removeAll(参数):移除this和参数的交集

addAll():添加参数内容到this里

package com.cn.test;

import java.lang.reflect.Array;
import java.util.ArrayList;


public class MyTest3 { //新建List去重
    public static void main(String[] args) {
        ArrayList<String>  list=new ArrayList<String>();
        ArrayList<String>  list2=new ArrayList<String>();
        list.add("apple");
        list.add("banana");
        list.add("orange");
        list.add("watermelon");
        list2.add("apple");
        list2.add("peach");

        ArrayList<String> temp=new ArrayList<String>(list);
        temp.retainAll(list2);//仅仅保留list和list2的交集到temp
        list.removeAll(temp);//去重
        ArrayList<String> sumList=new ArrayList<String>();
        sumList.addAll(list);
        sumList.addAll(list2);

        for (Object o:sumList) {
            System.out.println(o);
        }

    }

}

结果:

使用set去重两个ArrayList的合集
遍历列表对比数据,去除一个list的数据在进行合并

LinkedList

LinkedList类是双向列表,列表中的每个节点都包含了前一个和后一个元素的引用,基于链表实现的.因此访问数据的效率不如ArrayList.LinkedList是双向链表每个结点包含前后结点的位置信息.头结点中不存放数据.

构造方法:

LinedList<类型> list=new LinkedList<类型>();

创建一个空链表

LinkedList<类型> list = new LinkedList(Collection<? extends E> c); 使用一个集合创建一个新的linkedList。

常用方法:

add(E e): 将指定元素添加到此列表的结尾。
add(int index, E element)：在此列表中指定的位置插入指定的元素。
addAll(Collection<? extends E> c)：添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
addAll(int index, Collection<? extends E> c)：将指定 collection 中的所有元素从指定位置开始插入此列表。
AddFirst(E e): 将指定元素插入此列表的开头。
addLast(E e): 将指定元素添加到此列表的结尾。
clear()：从此列表中移除所有元素。
poll() :检索并删除此链表的一个头部
pollFirst() :检索并删除此列表的第一个元素,如果为空则返回null
pollLast() :检索并删除此列表的最后一个元素,为空返回null
peek() :检索不删除此列表的头部
peekFirst() :检索不删除此列表的第一个元素,如果此列表为空则返回null
peekLast() :检索但不删除此列表的最后一个元素,如果此列表为空则返回null
remove()：获取并移除此列表的头（第一个元素）。
remove(int index)：移除此列表中指定位置处的元素。
remove(Objec o)：从此列表中移除首次出现的指定元素（如果存在）。
removeFirst()：移除并返回此列表的第一个元素。
removeFirstOccurrence(Object o)：从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。
removeLast()：移除并返回此列表的最后一个元素。
removeLastOccurrence(Object o)：从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。
get(int index)：返回此列表中指定位置处的元素。
getFirst()：返回此列表的第一个元素。
getLast()：返回此列表的最后一个元素。
indexOf(Object o)：返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
lastIndexOf(Object o)：返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。

遍历方式:

普通for循环+get(index)方法(不推荐)
使用增强for循环(推荐)
使用Iterator迭代器(推荐)

前面三种的使用和List中一样,可以参考List中的遍历方式

使用pollFirst()遍历,遍历完后列表中数据也被清空了

package com.cn.test;

import java.util.LinkedList;


public class MyTest3 { //新建List去重
    public static void main(String[] args) {
        LinkedList<String> list=new LinkedList<String>();
        list.add("apple");
        list.add("banana");
        list.add("orange");
        list.add("watermelon");
        String next=null;
        while((next=list.pollFirst())!=null){
            System.out.println(next);
        }



    }

}

使用pollLast()遍历,和上一个基本相同
用removeFirst()遍历
用removeLast()遍历

排序:

使用java.util.Collections.sort,和List中的排序类似需要自己写比较器类然后调用.

具体可以参考List文章中的使用方法

Set

set集合也是单列集合,但是不能存放重复的元素,即使是null.且里面元素的存放顺序是无序的

常用方法:

boolean add(Object o)：该方法用于向集合里添加一个元素,返回值为操作是否成功.

boolean addAll(Collection c)：该方法把集合c里的所有元素添加到指定集合里。返回值为操作是否成功.

void clear()：清除集合里的所有元素，将集合长度变为0。

boolean contains(Object o)：返回集合里是否包含指定元素。

boolean containsAll(Collection c)：返回集合里是否包含集合c里的所有元素。

boolean isEmpty()：返回集合是否为空。当集合长度为0时返回true，否则返回false。

Iterator iterator()：返回一个Iterator对象，用于遍历集合里的元素。

boolean remove(Object obj)：删除集合中的指定元素obj，当集合中包含了一个或多个元素obj时，这些元素将被删除，该方法将返回true。

boolean removeAll(Collection c)：将集合中删除集合c里包含的所有元素（相当于用调用该方法的集合减集合c），如果删除了一个或一个以上的元素，则该方法返回true。

boolean retainAll(Collection c)：将集合中删除集合c里不包含的元素（相当于把调用该方法的集合变成该集合的集合c的交集），如果该操作改变了调用该方法的集合，则该方法返回true。

int size()：该方法返回集合里元素的个数。

Object[] toArray()：该方法把集合转换成一个数组，所有的集合元素变成对应的数组元素。

遍历方式:

for增强循环
iterator迭代器

排序方式:

Set转ArrayList然后调用Collections.sort(ArrayList list)进行排序

package com.cn.test;

import java.util.*;
public class MyTest3 { //新建List去重
    public static void main(String[] args) {
        Set<Integer>  set=new HashSet<Integer>();
        set.add(123);
        set.add(234);
        set.add(444);
        set.add(156);
        ArrayList<Integer> list=new ArrayList<Integer>(set);
        Collections.sort(list,Collections.reverseOrder());
        System.out.println(list);

    }

}

HashSet

Hashset实现了Set接口,其背后是一个哈希表,实际是一个HashMap实例(存储在HashMap中:实际上，我们在HashSet中插入的值充当映射对象的键，java使用常量变量来表示它的值。因此，在键值对中，所有值都是相同的。HashMap中的键才是我们在HashSet中的存储值).

在HashSet中插入的对象不能保证其插入顺序,因为其根据哈希函数散列分布的.

HashSet还实现了Serializable和Cloneable接口,因此其可被序列化

负载因子:是指当前容量的大小乘于负载因子等于容量增长的极限值.例如:如果当前容量为16,负载因子为0.75,当存入数据量达到12时就是自动增加容量的大小.

在存储Object之前，HashSet会使用hashCode()和equals()方法检查是否存在现有的条目。如果两个列表具有相同顺序的相同元素，则认为它们是相等的。当你在两个列表上调用hashCode()方法时，它们都将给出相同的散列，因为它们是相等的。

HashSet不仅存储唯一的对象，而且还存储唯一的对象集合，如ArrayList， LinkedList， Vector等(其中的元素值和顺序均一致的算作为相同的集合).

构造函数:

HashSet<E> hs=new HashSet<E>();

HashSet<E> hs = new HashSet<E>(int initialCapacity);//指定初始空间大小的

HashSet<E> hs = new HashSet<E>(int initialCapacity, float loadFactor);//指定初始大小和负载因子

HashSet<E> hs = new HashSet<E>(Collection C); //指定集合内容放入HashSet之中

遍历方式:

Iterator迭代器
for增强循环

TreeSet

无序不可重复,但是根据元素的大小顺序自动排序.实现自定义类型的排序需要进行定义.

TreeSet集合底层实际上是一个TreeMap，而TreeMap集合底层是一个二叉树，也将TreeSet集合中的元素称为可排序组合

基于TreeMap实现的SortedSet , 基本数据类型的排序后按升序排列元素 ,非线程安全

构造方法:

TreeSet<E> ts=new TreeSet<E>();//构建一个空的set

TreeSet<E> ts=new TreeSet<E>(Collection<E> col); //构建一个包含Collection集合的TreeSet,按照自然顺序进行排序

TreeSet<E> ts=new TreeSet<E>(Comparator<E> com); //构建一个指定排序方式的TreeSet

TreeSet<E> ts=new TreeSet<E>(); //构建一个指定有序set具有相同映射关系和相同排序的TreeSet

常用方法:

	E ceiling(E e) 
 // 返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。 
	E lower(E e) 
  //返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。
    E higher(E e) 
 // 返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。 
    
    Comparator<? super E> comparator() 
  //返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。 
NavigableSet<E> descendingSet() 
  //返回此 set 中所包含元素的逆序视图。 
E first() 
  //返回此 set 中当前第一个（最低）元素。 
E last() 
  //返回此 set 中当前最后一个（最高）元素。 
E floor(E e) 
 // 返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。 
SortedSet<E> headSet(E toElement) 
  //返回此 set 的部分视图，其元素严格小于 toElement。 
NavigableSet<E> headSet(E toElement, boolean inclusive) 
 // 返回此 set 的部分视图，其元素小于（或等于，如果 inclusive 为 true）toElement。 
Iterator<E> iterator() 
 // 返回在此 set 中的元素上按升序进行迭代的迭代器。 
Iterator<E> descendingIterator() 
  //返回在此 set 元素上按降序进行迭代的迭代器。  
 E pollFirst() 
  //获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。 
 E pollLast() 
  //获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。 
NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) 
  //返回此 set 的部分视图，其元素范围从 fromElement 到 toElement。 
SortedSet<E> subSet(E fromElement, E toElement) 
  //返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。 
SortedSet<E> tailSet(E fromElement) 
  //返回此 set 的部分视图，其元素大于等于 fromElement。 
NavigableSet<E> tailSet(E fromElement, boolean inclusive) 
 // 返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement。

TreeSet保存自定义类型,需要传入比较器或者实体类实现Comaprable的CompareTo()方法,不然会报java.lang.ClassCastException异常.

在TreeSet中实现自定义类型的排序有两种方法:

自定义的类实现Comparable接口的compareTo()方法重写

//自定义类,通过age比较排序
package com.cn.pojo;

public class Person implements Comparable<Person>{
    String name;
    int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Person o) {
        return this.age-o.age; //传递比较结果正/负/零
        //this值减参数值为升序,反之为降序
    }
}

调用测试:

package com.cn.test;

import com.cn.pojo.Person;

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

public class Test5 {
    public static void main(String[] args) {
        Person p1=new Person("张三",22);
        Person p2=new Person("张4",21);
        Person p3=new Person("张5",25);
        Person p4=new Person("张6",24);
        TreeSet<Person>  ts=new TreeSet<Person>();
        ts.add(p1);
        ts.add(p2);
        ts.add(p3);
        ts.add(p4);
        Iterator<Person> iterator= ts.iterator();
        while (iterator.hasNext()) {
            Person next =  iterator.next();
            System.out.println(next);
        }

    }
}

运行结果:

自定义比较器,在创建TreeSet时传入比较器

实体类依旧使用我们上面的Person类.

比较器:

package com.cn.compare;

import com.cn.pojo.Person;

import java.util.Comparator;

public class P_Compare implements Comparator<Person> {

    @Override
    public  int compare(Person o1, Person o2) {
        return o2.getAge()-o1.getAge();
        //第一个参数减第二个为升序,反之为降序
    }
}

调用测试:

package com.cn.test;

import com.cn.compare.P_Compare;
import com.cn.pojo.Person;

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

public class Test5 {
    public static void main(String[] args) {
        Person p1=new Person("张三",22);
        Person p2=new Person("张4",21);
        Person p3=new Person("张5",25);
        Person p4=new Person("张6",24);
        TreeSet<Person>  ts=new TreeSet<Person>(new P_Compare());
        ts.add(p1);
        ts.add(p2);
        ts.add(p3);
        ts.add(p4);
        Iterator<Person> iterator= ts.iterator();
        while (iterator.hasNext()) {
            Person next =  iterator.next();
            System.out.println(next);
        }

    }
}

运行结果:

posted @ 2023-04-13 15:15 赤叶秋枫阅读(57) 评论(0) 编辑收藏举报

刷新页面返回顶部

赤叶秋枫

Collection集合

Collection集合（单列集合）

List

ArrayList

LinkedList

Set

HashSet

TreeSet

公告