Collection集合(下) -- set，queue，stream

 Set：

　　不能存储重复元素

　　实现类HashSet，LinkedHashSet，TreeSet

HashSet：

　　HashSet底层基于HashMap进行处理

　　HashMap底层基于数组+链表

 

HashMap的存储模式（桶中有栈）

　　HashMap基于数组+链式栈结构，不能存储重复元素，不能保证存放顺序，是一个线程不安全的集合

 

HashMap存储规则

　　底层会先默认创建一个长度为16的数组，每个数组元素的空间叫桶（bucket）

　　会先计算出要进行存储对象的哈希码值，接着对哈希码值进行二次运算，保证落在某个桶中

　　如果要存储的对象的那个桶之前已经存储元素，就要拿这个存储的对象，依次和桶中所有元素进行比较，如果相等，就抛弃这个对象，如果不想等，就放在最前面形成了链式栈的结构

　　已经存储的桶数/总桶数（加载因子，默认0.75f），如果大于加载因子，就会进行默认的扩容，默认扩容一倍

　　在每次进行扩容操作之后，都要对所有的对象重新计算哈希码值（rehash进行二次预算）

　　如果加载因子越小-–-–-–--—桶中还没存满，就要频繁的进行扩容，需要频繁的进行rehash操作，大量的桶没有存储，浪费内存空间，降低内存使用率。

　　如果加载因子越大-–-–-–-–-–大量的数据存放在没有扩容的桶中，就会让我们的链式栈结构长度越长，操作数据的效率降低。

　　如果链式栈结构的长度很长，从jdk1.8开始规定，如果长度大于8个，就会把这个链式栈结构扭转成二叉树进行存储，提高内存利用率

 

 

TreeSet

　　对放在数据进行排序-----升序，降序，自然排序会放在TreeSet对象里面，重写compareTo进行排序

import java.util.TreeSet;
​
public class TreeSetDemo {
    public static void main(String[] args) {
        //创建TreeSet集合对象
        TreeSet<String> t = new TreeSet<String>();
        
        //添加元素
        t.add("D");
        t.add("F");
        t.add("j");
        t.add("f");
        t.add("b");
        t.add("k");
        System.out.println(t);      //会对放入的数据进行自动排序---升序---自然排序
        
        TreeSet<Person> t1 = new TreeSet<>();
        //添加元素，把Person元素放入
        t1.add(new Person("liu", 40, 67));
        t1.add(new Person("ZHAO", 35,80));
        t1.add(new Person("zhang", 30, 19));
        
        //输出
        for (Person p : t1) {
            System.out.println(p);
            
        }
    }
}
​
class Person implements Comparable<Person>{
    //属性
    String name;
    int age;
    int score;
    
    //有参构造赋值
    public Person(String name,int age,int score){
        this.name=name;
        this.age=age;
        this.score=score;
    }
​
    //重写toStting
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", score=" + score
                + "]";
    }
​
    //用于指定排序规则
    @Override
    public int compareTo(Person o) {
        // TODO Auto-generated method stub
        return this.score-o.score;
    }
    
    
}

 

 

Queue：队列，先进先出原则（FIFO）

import java.util.LinkedList;
import java.util.Queue;
​
​
public class QueueDemo {
    public static void main(String[] args) {
        
        //创建对象
        Queue<String> q = new LinkedList<>();
        //获取元素不能删除
        //如果元素没有元素，报错
//      System.out.println(q.element());
        
        //获取元素不删除
        //如果队列没有元素，返回：null
        System.out.println(q.peek());
        
    }
}

 

 

Stream（操作集合的流式结构）

　　提供了大量的操作集合的功能（函数式接口）

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;
​
​
public class StreamDemo {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<>();
        
        list.add("c");
        list.add("java");
        list.add("python");
        list.add("c#");
        
​
        Stream<String> s = list.stream();
//      //方法一：
//      s.filter(new Predicate<String>() {
//
//          //把过滤规则写入
//          @Override
//          public boolean test(String t) {
//              
//              return t.startsWith("c");
//          }
//      }).forEach(new Consumer<String>() {
//
//          @Override
//          public void accept(String t) {
//              // TODO Auto-generated method stub
//              System.out.println(t);
//          }
//      });
        
        //方法二：
        //可以进行排序，小写，等功能
        s.filter(str->str.startsWith("c")).map(str->str.toUpperCase()).
        forEach(str->System.out.println(str));
        
    }                                                                                                                                                 
}

 

泛型：参数化泛型

　　jdk1.5出现： List list = new ArrayList();

　　jdk1.8开始，规定如下格式： List<String> list1 = new ArrayList<>();

　　泛型类型的不确定，到泛型的确定叫做泛型的擦除（编译时期）