> 科技资讯 > Collection集合

Collection集合

科技资讯 投稿 6500℃ 0 评论

Collection集合

Collection集合（单列集合）

ArrayList：线程不安全，底层使用数组实现，查询快，增删慢，效率高。
LinkedList ： 线程不安全，底层使用链表实现，查询慢，增删快，效率高。
Vector ：线程安全，底层使用数组实现，查询快，增删慢，效率低。每次容量不足时，默认自增长度的一倍（如果不指定增量的话）

HashSet :底层是由HashMap实现的，通过对象的hashCode方法与equals方法来保证插入元素的唯一性，无序(存储顺序和取出顺序不一致，。
LinkedHashSet: 底层数据结构由哈希表和链表组成。哈希表保证元素的唯一性，链表保证元素有序。(存储和取出是一致
TreeSet :基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。 元素唯一。

Collection接口的常用方法：

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

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 + '\'' +
                '}';
    }
}
  1. foreach(增强for循环）
for (Book book : a1 {
System.out.println("book=" + book
}

List

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

继承关系：

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

写一个比较器类，实现接口Comparator，重写compare(Object o1,Object o2方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示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;
        }


    }
}

输出结果：

通过实体类自身实现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;
        }


    }
}

结果：

遍历方式：

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去重

方式一：（有序）

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;
        }


    }


}

方式二：(无序

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;

    }

方式三：(无序

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好一点，在多线程环境中需要自己管理线程同步问题。

构造方法：

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

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

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

ArrayLsit底层代码：

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

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

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

遍历方式：

去重方式：

    使用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;
        }

    }
    
}
  1. 使用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;
        }

    }

}

结果：

  1. 使用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;
        }
    }

}
  1. 使用Comparator排序,和List中的相同
  2. 使用Comparable排序,同List中的

合并ArrayList并去重:

    removeAll(参数:移除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;
        }

    }

}

结果:

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

LinkedList

构造方法:

创建一个空链表

常用方法:

  1. add(int index, E element：在此列表中指定的位置插入指定的元素。

  3. addAll(int index, Collection<? extends E> c：将指定 collection 中的所有元素从指定位置开始插入此列表。

  5. addLast(E e: 将指定元素添加到此列表的结尾。

  7. poll( :检索并删除此链表的一个头部

  9. pollLast( :检索并删除此列表的最后一个元素,为空返回null

  11. peekFirst( :检索不删除此列表的第一个元素,如果此列表为空则返回null

  13. remove(：获取并移除此列表的头（第一个元素）。

  15. remove(Objec o：从此列表中移除首次出现的指定元素（如果存在）。

  17. removeFirstOccurrence(Object o：从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。

  19. removeLastOccurrence(Object o：从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。

  21. getFirst(：返回此列表的第一个元素。

  23. indexOf(Object o：返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。

遍历方式:

  1. 使用增强for循环(推荐

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

  1. 使用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;
        }



    }

}

  1. 使用pollLast(遍历,和上一个基本相同

  3. 用removeLast(遍历

排序:

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

Set

常用方法:

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

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

所有元素。

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

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

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

遍历方式:

    for增强循环
  1. 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还实现了Serializable和Cloneable接口,因此其可被序列化

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

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

构造函数:

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

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

遍历方式:

    Iterator迭代器
  1. for增强循环

TreeSet

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

构造方法:

TreeSet<E> ts=new TreeSet<E>(Collection<E> col; //构建一个包含Collection集合的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;
        }

    }
}

运行结果:

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

比较器:

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;
        }

    }
}

运行结果:

编程笔记 » Collection集合

赞同 (23) or 分享 (0)
游客 发表我的评论   换个身份
取消评论

表情
(0)个小伙伴在吐槽