集合_java_绿巨人add-CSDN博客

本文链接：https://blog.csdn.net/weixin_52671417/article/details/123306671

什么是集合？？

集合就是一个容器专门来存储其他的数据类型
集合不能直接存储基本数据类型，另外集合也不能直接存储java 对象，集合当中存储的都是java对象的内存地址（或者说是集合中存储的是引用）
注意：集合在java中本身就是一个对象，只能存储引用数据类型，存储的对象的内存地址，然后去指向相应的对象

collection方法讲解

package com.bjpowernode.javase.collection;

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

/*
** * 1.collection中能存放什么元素？？
*      没有使用“泛型”之前，可以存放任何元素
*      使用了”泛型“ 之后，就只能存储某个具体的类型
*
*      2.collection中的用法？？
*        boolean add(Object e)
*
*       int size()
*  返回此集合中的元素数。
*
*       void clear()
*  从此集合中删除所有元素（可选操作）。
*
* boolean contains(Object o)
* 判断此集合中是否包含此元素
* (o==null ? e==null : o.equals(e)) 。
*
* boolean remove(Object o)
* 从该集合中删除指定元素的单个实例（如果存在）（可选操作）。 更正式地，删除元素e ，使得(o==null ? e==null : o.equals(e)) ，
* 如果该集合包含一个或多个这样的元素。 如果此集合包含指定的元素（或等效地，如果此集合由于调用而更改），则返回true 。
*    Object   toArray();  将集合转换为数组
 */
public class CollectionTest01 {
    public static void main(String[] args) {
        // 接口不能直接new 对象
        Collection c=new ArrayList();
        // 测试Collection中的方法
        c.add(1200);// 自动装箱的问题，实际上是存储的是一个对象的内存地址
        c.add(3.14);// 自动装箱
        c.add( new Object());
        c.add(new Student());
        c.add(true);


        // 获取集合中的元素的个数
        System.out.println("集合中的个数是："+c.size());
        // 清空集合中元素的个数
        c.clear();
        System.out.println("集合中的个数是：" +c.size());
        // 再向集合中添加元素
        c.add("hello");
        c.add("world");
        c.add("浩克");
        c.add("绿巨人");
        // 判断集合中是否包含“绿巨人”
        boolean flag=c.contains("绿巨人");
        System.out.println(flag);
        boolean flag2=c.contains("绿巨人2");
        System.out.println(flag2);
        // 删除集合中的元素个数
        c.remove(1);
        System.out.println(c.size());
        // 判断集合中是否为空
        System.out.println(c.isEmpty());// flase
        // 清空
        c.clear();
        System.out.println(c.isEmpty());// true
        c.add("aaa");
        c.add("nihao");
        c.add("zhangsan");
        c.add(new Student());
        Object[] obj=c.toArray();
        for(int i=0;i< obj.length;i++)
        {
            System.out.println(obj[i]);
        }
        
    }
}
class Student{

}

迭代专题（*****）

package com.bjpowernode.javase.collection;

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

/*
 * 关于集合遍历（迭代器专题）
 *  	hasNext()
 * 如果迭代具有更多元素，则返回 true 就是这个方法返回true 表示还有方法可以迭代
 *  next()  Object
 * 返回迭代中的下一个元素。 这个方法使迭代器前进一位，并返回
 *
 */
public class CollectionTest02 {
    public static void main(String[] args) {
    // 注意：以下讲解的是遍历方式是所有collection通用的一种方式
    // 在Map 集合中不能使用，在所有collection子类中使用

    //  创建集合对象
        Collection c=new HashSet();// 后面的集合无所谓，主要看Collection接口怎么遍历
        c.add("abc");
        c.add("def");
        c.add(120);
        c.add(new Object());
        // 对集合进行遍历
        // 第一步：获取集合的迭代器对象
        Iterator it=c.iterator();
        // 第二步：对迭代器进行遍历
        while(it.hasNext())
        {
            Object objs=it.next();
            System.out.println(objs);
        }


    }
}

package com.bjpowernode.javase.collection;

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

public class CollectionTest03 {
    public static void main(String[] args) {
        // 创建集合对象
        Collection c=new ArrayList();// 有序 可重复
        c.add(1);
        c.add(2);
        c.add(3);
        c.add(4);
        c.add(5);
        // 获取迭代器对象
        Iterator it=c.iterator();
        // 对迭代器进行遍历
        while (it.hasNext()){
            Object objs=it.next();
            System.out.println(objs);
        }


        Collection cc=new HashSet(); // 无序 不可重复
        cc.add(111);
        cc.add(222);
        cc.add(222);
        cc.add(333);
        cc.add(444);
        // 获取迭代器
        Iterator ite=cc.iterator();
        // 对迭代器进行遍历
        while (ite.hasNext()){
            Object objs2=ite.next();
            System.out.println(objs2);
        }
    }
}

contain详解

package com.bjpowernode.javase.collection;

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

/*
 * 深入了解一下Collection中的contain方法
 * contain方法就是来判断某个集合中是否包含指定的元素
 *  如果equals方法重写了 那么判断是内容
 *   如果没有重写 判断的是地址
 */
public class CollectionTest04 {
    public static void main(String[] args) {
        // 创建集合对象
        Collection c=new ArrayList();
        // 向集合中存储元素
        String s1=new String("abc");
        c.add(s1);
        String s2=new String("def");
        c.add(s2);
        // 集合中元素的个数
        System.out.println(c.size());
        String x=new String("abc");
        System.out.println(c.contains(x)); // true
    }
}
// 总结：重写equals方法是程序员的素养！！！！把equals重写就完事了

remove

package com.bjpowernode.javase.remove;

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

/*
 * remove的讲解
 *  从底层集合中删除此迭代器返回的最后一个元素（可选操作）
 *  注意：集合只要发生改变，迭代器必须重新获取
 * 
 * 在迭代元素的过程中 一定要使用迭代器去删除元素 不能使用集合去删除集合
 */
public class RemoveTest01 {
    public static void main(String[] args) {
        // 创建集合
        Collection collection=new ArrayList();
        // 添加元素
        collection.add(1);
        collection.add(2);
        collection.add(3);
        // 获取迭代器
        Iterator it=collection.iterator();
        // 迭代
        while(it.hasNext())
        {
            // 编写next 方法时 返回类型必须是Object 方法中规定的
            Object obj=it.next();
            // collection.remove(obj); 这个有误 直接通过集合去删除元素 没有通知迭代器（导致迭代器的快照与原集合不同）
            // java.util.ConcurrentModificationException
            it.remove();// 删除的元素一定是迭代器指向的当前元素
            // 使用迭代器去删除元素，是会自动更新集合中的元素的
            System.out.println(obj);
        }
        System.out.println(collection.size());// 计算元素个数
    }
}

list

package com.bjpowernode.javase.list;

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

/*
 * list集合存储元素有什么特点：有序 可重复
 *  有序：有下标 从0开始
 *   list中特有的方法
 *  void	add(int index, E element)
 *   将指定的元素插入此列表中的指定位置（可选操作）
 *
 *  int	indexOf(Object o)
 *   返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
 *
 *  int	lastIndexOf(Object o)
 *   返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1
 *
 *   E	remove(int index)
 *   删除该列表中指定位置的元素（可选操作）
 *   E	get(int index)
 *    返回此列表中指定位置的元素
 *   E	set(int index, E element)
 *   用指定的元素（可选操作）替换此列表中指定位置的元素。
 */
public class ListTest01 {
    public static void main(String[] args) {
        List list=new ArrayList();
        // 添加元素
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        // 在集合的指定位置将元素插进去
        // 这个方法用的不多
        list.add(1,"HJK");
        // 进行迭代
        Iterator it=list.iterator();
        // 进行迭代
        while (it.hasNext())
        {
            Object obj=it.next();
            System.out.println(obj);
        }

        // 根据下标获取元素
        Object fristobj=list.get(3);
        System.out.println(fristobj);
        // 因为有下标 所有list 有自己遍历元素的方法
        // 这个是list 特有的遍历方法
        for(int i=0;i<list.size();i++)
        {
            Object obj=list.get(i);
            System.out.println(obj);
        }

        // 获取指定对象第一次出现的索引
        int ii=list.indexOf("C");
        System.out.println(ii);
        // 获取指定对象最后出现的索引
        System.out.println(list.lastIndexOf("B"));

        // 删除指定下标的元素
        list.remove(1);
        System.out.println(list.size());
        // 修改指定位置的元素
        list.set(2,"AGUI");
        System.out.println(list.get(2));

    }
}

ArrayList

package com.bjpowernode.javase.collection;

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

/*
 * ArrayList 初始化容量是10
 *  集合底层是一个Object数组
 */
public class ArrayListTest01 {
    public static void main(String[] args) {
        // 创建ArrayList集合
        // 默认初始化容量为10
        List list1=new ArrayList();
        // 将初始化容量修改为20
        List list2=new ArrayList(20);
        // size是计算集合中的元素 不是容量 还没有往集合中放元素
        System.out.println(list2.size());
    }
}

LinkedList

package com.bjpowernode.javase.collection;

import java.util.LinkedList;
import java.util.List;

/*
 * 对于链表当中：
 *   存储着两个部分：一个属性存储着数据 一个属性存储着下一个节点的地址
 * 
 * 链表的优点：
 *   由于链表的元素在存储的过程中 内存地址是不连续的
 *    所以增删元素效率比较高
 * 在以后开发中，如果遇到随机增删元素比较多的时候，建议使用LinkedList
 * 
 * 链表的缺点：
 *     不能通过数学表达式去找到元素的内存地址，每次都必须从头节点开始寻找
 *     所以LinkedList查找效率比较低
 */
public class LinkedListTest01 {
    public static void main(String[] args) {
        // 创建集合
        List list=new LinkedList();
        list.add("abc");
        list.add("bcd");
        list.add("def");
        for(int i=0;i<list.size();i++)
        {
            Object obj=list.get(i);
            System.out.println(obj);
        }
    }



}

Vector

package com.bjpowernode.javase.collection;
/*  Vector 底层同样是数组  这个是线程安全的
 * Vector 初始化容量是10
 *   每次扩容之后 都是原来的2倍
 */
import java.util.*;

public class VectorTest01 {
    public static void main(String[] args) {
        List list=new Vector();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        Iterator it=list.iterator();

        while(it.hasNext())
        {
            Object obj=it.next();
            System.out.println(obj);
        }
        
        // 这个以后可能要用！！！
        List mylist=new ArrayList(); // 非线程安全的
        // 变成线程安全的
        Collections.synchronizedList(mylist);
        // 在这里 mylist就是线程安全的
        mylist.add("111");
        mylist.add("222");
        mylist.add("333");
    }
}

泛型

不使用泛型

package com.bjpowernode.javase.collection;

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

/*
 * JDK5.0新特性：泛型
 */
public class GenericTest01 {
    public static void main(String[] args) {
        // 不使用泛型机制 分析程序的缺点
        // 创建List集合
        List list=new ArrayList();
        // 准备对象
        Cat c=new Cat();
        Bird b=new Bird();
        // 将对象加进去
        list.add(c);
        list.add(b);
        // 遍历集合 取出Cat和Bird
        // 迭代器去迭代
        Iterator it=list.iterator();
        while(it.hasNext()){
            Object obj=it.next();
            // Object中没有move方法 需要向下转型
            if (obj instanceof Animal){
                Animal a=(Animal) obj;
                System.out.println(a);
            }
        }

    }
}
class Animal {
    public void move(){
        System.out.println("动物在移动");
    }


}
// 猫继承父类动物
class Cat extends Animal {
    public void catchMouse(){
        System.out.println("猫在抓老鼠");
    }

}
// 鸟继承父类动物
class Bird extends Animal {
public void fly(){
    System.out.println("鸟儿在飞翔");
}
}

使用泛型

package com.bjpowernode.javase.collection;

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

/*
 * JDK5.0新特性：泛型
 * 泛型这种语法机制，只在程序编译阶段起作用，只是给编译器参考的（运行阶段泛型没有用）
 * 好处：
 * 第一：集合中存储的元素类型统一
 * 第二：从集合中取出的元素类型是泛型指定的类型，不需要进行大量的“向下转型”
 * 缺点：
 * 导致集合中存储的东西缺少多样性
 * 业务中大部分都是同一种类型
 */
public class GenericTest01 {
    public static void main(String[] args) {
        // 使用泛型机制 分析程序的缺点
        // 创建List集合
        List<Animal> list=new ArrayList<Animal>();
        // 准备对象
        Cat c=new Cat();
        Bird b=new Bird();
        // 将对象加进去
        list.add(c);
        list.add(b);
        // 遍历集合 取出Cat和Bird
        // 迭代器去迭代
        Iterator<Animal> it=list.iterator();
        while(it.hasNext()){
            Animal a=it.next();
            //这里就不用进行转换了
            //a.move();
            // 如果需要使用子类中特有的方法 还是需要转型
            if(a instanceof Cat){
                Cat cc=(Cat)a;
                cc.catchMouse();
            }
            if (b instanceof Bird){
                Bird bb=(Bird) b;
                bb.fly();
            }
        }

    }
}
class Animal {
    public void move(){
        System.out.println("动物在移动");
    }


}
// 猫继承父类动物
class Cat extends Animal {
    public void catchMouse(){
        System.out.println("猫在抓老鼠");
    }

}
// 鸟继承父类动物
class Bird extends Animal {
public void fly(){
    System.out.println("鸟儿在飞翔");
}
}

package com.bjpowernode.javase.collection;

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

        // 泛型一般用T或者E来表示
        MyIterator<String> mi=new MyIterator<>();
        String s1=mi.get();
        MyIterator<Animal> aa=new MyIterator<>();
        Animal s2=aa.get();
        MyIterator mm=new MyIterator();
        Object obj=mm.get();

    }
}
class MyIterator<T> {
    public T get(){
        return null;
    }
}

增强for循环

package com.bjpowernode.javase.collection;
/*
 * JDK5.0推出的一个新特性：叫做增强for循环，或者叫做foreach
 */
public class ForEachTest01 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6};
        for(int i=0;i<arr.length;i++)
        {
            //  遍历数组(普通for循环)
            System.out.println(arr[i]);
        }
        // 曾强for循环
        // 缺点是没有下标
        // 语法：
//        for(元素类型 变量名：数组或集合){
//            System.out.println(变量名);
//        }
        System.out.println("====================");
        for(int data:arr){
            System.out.println(data);
        }

    }
}

HashSet集合

package com.bjpowernode.javase.collection;

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

/*
 * HashSet集合：
 *   无序不可重复
 */
public class HashSetTest01 {
    public static void main(String[] args) {
        // 创建set集合
        Set<String> strs=new HashSet<>();
        // 添加元素
        strs.add("123");
        strs.add("123");
        strs.add("nihao");
        strs.add("234");
        strs.add("3333");
        // 无序不可重复
        // 元素是存放在HashSet中的HashMap中
        // 使用for增强来遍历
        for (String ss:strs){
            System.out.println(ss);
        }

    }
}

TreeSet

package com.bjpowernode.javase.collection;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
/*
 * TreeSet集合元素的特点：
 *  1，无序不可重复 但是存储的元素可以自动按照大小顺序去排列
 *    称为：可排序集合
 */
public class TreeSetTest01 {
    public static void main(String[] args) {
        // 创建TreeSet集合
        Set<String> set=new TreeSet<>();
        // 添加元素
        set.add("123");
        set.add("234");
        set.add("345");
        // 自动排序
        // for循环遍历
        for (String ss:set){
            System.out.println(ss);
        }

    }
}

Map的方法

package com.bjpowernode.javase.collection;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

/*
 * java.util.Map
 *  1.Map集合和Collection没有继承关系
 *  2.Map集合以key和value的方式存储数据：键值对
 *   key和value都是引用数据类型
 *   key和value都是存储对象的内存地址
 *   key起到主导的地位，value是key的一个附属品
 * Map 接口中常用的方法
 *    V	put(K key, V value) 向Map集合中添加键值对
 *    V	get(Object key)  通过key获取value
 *    void	clear()  清空Map集合
 *    boolean	containsKey(Object key) 判断Map中是否包含某个key
 *    boolean	containsValue(Object value) 判断Map中是否包含某个value
 *    boolean	isEmpty() 判断Map集合元素中的个数是否为0
 *     Set<K>	keySet() 获取Map集合中所有的key(所有的key是一个Set集合)
 *    V	remove(Object key) 通过Map集合删除键值对
 *    int	size() 获取Map集合中的键值的个数
 *    Collection<V>	values() 获取Map集合中所有的value,返回一个Collection
 *    Set<Map.Entry<K,V>>	entrySet()  将Map集合转换为Set集合
 *
 *
 */
public class MapTest01 {
    public static void main(String[] args) {
        // 创建集合对象
        Map<Integer,String> map=new HashMap<>();
        // 向Map集合中添加元素
        map.put(1,"zhangsan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        map.put(4,"zhaoliu");
        // 通过key获取value
        String value=map.get(2);
        System.out.println(value);
        String value2=map.get(1);
        System.out.println(value2);
        // 获取键值对的数量
        System.out.println("键值对的数量："+map.size());
        // 通过key删除键值对
        map.remove(1);
        System.out.println(map.size());
        // 判断是否包含某个key
        // contains底层调用的是重写后equals方法，比较的内容
        System.out.println(map.containsKey(new Integer(1)));// false 我也不懂 其他没错
        // 判断是否包含某个value
        System.out.println(map.containsValue(new String("wangwu")));// ture
        System.out.println("=================");
        // 获取所有的value
        Collection<String> values=map.values();
        for (String s:values){
            System.out.println(s);
        }

        // 清空集合
        map.clear();
        System.out.println(map.size());
        // 判断是否为空
        System.out.println(map.isEmpty());

    }
}

对Map集合的遍历

package com.bjpowernode.javase.collection;

import com.sun.security.jgss.GSSUtil;

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

/*
 * Map集合的遍历  非常重要
 *
 */
public class MapTest02 {
    public static void main(String[] args) {
        // 创建Map集合
        Map<Integer,String> map=new HashMap<>();
        // 添加元素
        map.put(1,"zhangsan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        // 对Map集合进行遍历
        // 获取集合中所有的key（返回类型是Set集合）
        Set<Integer> keys=map.keySet();
        // 遍历key 通过迭代
        Iterator<Integer> it=keys.iterator();
        while (it.hasNext()){
            Integer integer=it.next();
            String value=map.get(integer);
            System.out.println(value);
        }

        //forench也可以
        for (Integer key:keys){
            System.out.println(key+"="+map.get(key));
        }

        // 第二种方法： Set<Map.Entry<K,V>>	entrySet()  将Map集合转换为Set集合
        // 以上方法是通过Map结合全部转换为Set集合
        Set<Map.Entry<Integer,String>> set=map.entrySet();
        // 遍历set集合
        Iterator<Map.Entry<Integer,String>> it2=set.iterator();
        while(it2.hasNext()){
            Map.Entry<Integer,String> entry=it2.next();
            Integer key=entry.getKey();
            String value=entry.getValue();
            System.out.println(key+"="+value);
        }
        // 增强foreach
        for (Map.Entry<Integer,String> node:set){
            System.out.println(node.getKey()+"="+node.getValue());
        }


    }
}

为什么哈希表的随机增删以及查询效率都高？？？

增删是在链表上，查询也不要全部查询，查询一部分就可以了
重点：通过讲解可以得出HashMap集合的key，会先调用两个方法，
一个是HashCode方法，一个是equals方法，那么这两个方法都需要重写

package com.bjpowernode.javase.collection;

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

/*
 * HashMap集合
 *   HashMap集合底层是哈希表/散列表的数据结构
 *   数组：在查询方面效率较高，随机增删方面效率较低
 *   单向链表：在查询方面较低，随机增删方面效率较高
 *   而哈希表将这两种结合起来，充分发挥着各自的优势
 *
 *   最主要掌握的是：这两个方法的实现原理
 *    map.put(k,v);
 *    v=map.get(k);
 *   一个node中的单向链表中包含：(同一个单向链表中的hash值相同)
 *     Object k;
 *     Object v;
 *     int hash;
 *     Node next;
 *
 *    map.put(k,v)的原理：
 *    第一步：会将k和v封装到Node对象中
 *    第二步：底层会通过k调用hashCode 方法 得出k对应的node数组的下标
 *          对应的下标的数组如果没有元素 就会直接放进去
 *          如果有，就会与链表中每一个Object k采用equals进行比较
 *          如果所有都是false 就会将这个元素放在链表的最后面
 *          如果为true 就会放在对应的true上 并且节点的value也会被覆盖（所有他们只是比较的是k）
 *
 *    v=map.get(k)原理：
 *     先将要寻找的元素k传入， 然后底层会通过哈希算法将k转换为对应的数组下标
 *     如果对应的下标数组上的链表的没有链表，那么get会返回一个null
 *     如果对应下标数组的链表有链表，那么k会与链表中的Object k进行equals比较
 *     如果相等 （说明找到了）返回value(这就是我们要找的value) 如果不相等 说明没有找到 返回null
 */
public class HashMapTest01 {
    public static void main(String[] args) {
        // 测试HashMap集合key部分的特点
        Map<Integer,String> map=new HashMap<>();
        // 加元素
        map.put(111,"zhangsan");
        map.put(222,"lisi");
        map.put(333,"wangwu");
        map.put(777,"zhaoliu");
        map.put(777,"king"); // key重复会将value覆盖
        System.out.println(map.size());// 4

        // 对集合进行遍历
        Set<Map.Entry<Integer,String>> entrySet=map.entrySet();
        for (Map.Entry<Integer,String> entry:entrySet){
            // 验证结果：无序不可重复
            System.out.println(entry.getKey()+"="+entry.getValue());
        }
    }
}

package com.bjpowernode.javase.collection.bean;

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

/*
 * HashMap中的key允许为null??
 * 允许 
 *  但是要注意：HashMap集合的key null值只能有一个
 */
public class HashMapTest03 {
    public static void main(String[] args) {
        Map map=new HashMap();
        // 加元素
        map.put(null,null);
        System.out.println(map.size());// 1
        map.put(null,100);
        System.out.println(map.size());// 1 key重复 将value覆盖了
        // 通过key获取value
        Object obj=map.get(null);
        System.out.println(obj);
    }
}

Properties集合

package com.bjpowernode.javase.collection;

import java.util.Properties;

/*
 * Properties是一个属性类，Properties中的key和value都是String类
 * 方法：
 * Object	setProperty(String key, String value) 存元素
 * String	getProperty(String key) 取元素
 */
public class PropertiesTest01 {
    public static void main(String[] args) {
        // 创建对象
        Properties pro=new Properties();
        // 存元素
        pro.setProperty("123","nofjfv");
        pro.setProperty("1333","noav");
        // 通过key获取value
        Object obj=pro.getProperty("123");
        System.out.println(obj);

    }
}

TreeSet集合

package com.bjpowernode.javase.collection;

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


/*
 * 1.TreeSet集合底层实际上是一个TreeMap
 * 2.TreeMap集合底层是一个二叉树
 * 3.放在TreeSet集合中的元素相当于放在TreeMap集合的key部分了
 * 4.TreeSet集合中的元素，无序不可重复，但是可以按照元素的大小顺序来排序
 */
public class TreeTest02 {
    public static void main(String[] args) {
        // 创建一个TreeSet集合
        Set<String> set=new TreeSet<>();
        // 添加元素
        set.add("zhangsan");
        set.add("wangwu");
        set.add("lisi");
        // 遍历
        for (String str:set){
            System.out.println(str);
            // 按照字典顺序排序
        }
        Set<Integer> ts1=new TreeSet<>();
        ts1.add(100);
        ts1.add(120);
        ts1.add(133);
        // 遍历
        Iterator<Integer> iterator=ts1.iterator();
        while (iterator.hasNext()){
            Integer integer=iterator.next();
            System.out.println(integer);
            // 升序排列
        }

    }
}

比较器比较的第一种方法（Comparable）

package com.bjpowernode.javase.collection;

import java.util.Set;
import java.util.TreeSet;

/*
 * 对于自定义的类型：TreeSet可以排序吗？？
 * 需要调用Comparable接口  并且要重写里面的方法CompareTo 以及equals
 */
public class TreeSetTest03 {
    public static void main(String[] args) {
        Person p1=new Person(12);
        Person p2=new Person(13);
        Person p3=new Person(45);
        Person p4=new Person(11);
        Set<Person> set=new TreeSet<>();
        set.add(p1);
        set.add(p2);
        set.add(p3);
        set.add(p4);
        // 遍历
        for (Person pp:set){
            System.out.println(pp);
        }
    }
}
// 放在TreeSet集合中的元素需要实现java.lang.Comparable接口
// 并且要重写Comparable方法 equals可以不写
class Person implements Comparable<Person>{
    int age;

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

    @Override
    // 需要在这个方法中编写比较的逻辑
    // 比较规则还是要自己决定
    // ComapreTo的返回值是非常重要的 0 负数 正数
    public int compareTo(Person o) {
        return this.age-o.age;
    }
    public String toString(){
        return "age="+age+"";
    }

}

实现比较器的接口第二种方法(Comparator接口)

package com.bjpowernode.javase.collection;

import java.util.Comparator;
import java.util.TreeSet;

/*
 * 采用比较器的方式去比较
 * 最终结论：
 *  放到TreeSet或者TreeMap集合key部分的元素要想做到排序，包括两种方式：
 *   第一种：放在集合中的元素实现java.lang.Comparable接口
 *   第二种：在构造TreeSet或者TreeMap集合时，给它传一个比较器对象
 *
 *  Comparable和Comparator怎么选择？？
 *  当比较规则不会变化时，使用Comparable接口
 *   当比较规则有多个时，使用Comparator接口
 * Comparator符合OCP原则
 */
public class TreeSetTest06 {
    public static void main(String[] args) {
        // 创建集合 需要将比较器传进去
        TreeSet<WuGui> wuGuis=new TreeSet<>(new WuGuiComparator());
        wuGuis.add(new WuGui(1000));
        wuGuis.add(new WuGui(1200));
        wuGuis.add(new WuGui(1300));
        wuGuis.add(new WuGui(111));
        // 使用foreach 进行遍历
        for (WuGui ww:wuGuis){
            System.out.println(ww);
        }

    }
}
class WuGui {
    int age;

    public WuGui(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "WuGui{" +
                "age=" + age +
                '}';
    }
}
// 单独在这里编写一个比较器
// 比较器实现java.util.Comparator接口，（Comparable是java.lang包下的，Comparator是java.util包下的）
class WuGuiComparator implements Comparator<WuGui> {

    @Override
    public int compare(WuGui o1, WuGui o2) {
        // 比较指定规则
        // 按照年龄排序
        return o1.age- o2.age;
    }
}

Collection与Collections的区别

package com.bjpowernode.javase.collection;

import java.util.*;

/*
 * Collection时集合接口
 *  Collections 是集合工具类
 */
public class CollectionsTest01 {

    public static void main(String[] args) {
        // ArrayList集合不是线程安全的
        List<String> list = new ArrayList<>();
        // 变成线程安全的
        Collections.synchronizedList(list);
        // 排序
        list.add("abc");
        list.add("abe");
        list.add("abf");
        list.add("abx");
        Collections.sort(list);
        for (String str : list) {
            System.out.println(str);

        }

        List<XiaoWu> wus=new ArrayList<>();
        wus.add(new XiaoWu(1000));
        wus.add(new XiaoWu(1200));
        wus.add(new XiaoWu(1111));
        // 对List集合中的元素排序，需要保证list集合中的元素实现了：Comparable接口
        Collections.sort(wus);
        for (XiaoWu xiaoWu:wus){
            System.out.println(xiaoWu);
        }


        // 对Set集合如何排序
        Set<String> set=new TreeSet<>();
        set.add("abc");
        set.add("abe");
        set.add("abs");
        // 将Set集合转换为List集合
        List<String> list1=new ArrayList<>(set);
        Collections.sort(list1);
        for (String ss:list1){
            System.out.println(ss);
        }

    }
}
class XiaoWu implements Comparable<XiaoWu> {
    int age;

    public XiaoWu(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(XiaoWu o) {
        return this.age-o.age;
    }

    @Override
    public String toString() {
        return "XiaoWu{" +
                "age=" + age +
                '}';
    }
}