集合2

Queue 接口 ：
队列：是访问受限的线性表。

先进先出的数据结构。

---------------------------------

PriorityQueue
按照一定的优先级排序。
默认 Comparable升序排序
也可以自己 指定 Comparator

---------------------------------------
Deque接口：
双端队列
可以 模拟 队列
栈

------------------------------------
Map接口：
双列存储，键值对。
键是唯一的。

------------------------------------
HashMap 和 Hashtable

Hashtable :线程安全的，性能低
HashMap :键唯一,可以存 null键 ，null值；

LinkedHashMap:
按照 添加的顺序 来维护;

TreeMap:
默认 自然升序排序
也可以 按照 自己指定的 方式排序。

HashMap > LinkedHashMap > TreeMap

-------------------------------------------

单列： Collection
数据重复：List
ArrayList: 查询 ，遍历
LinkedList： 插入 ，删除

数据不重复： Set
只考虑唯一：HashSet （hashCode ,equals）
顺序：
LinkedHashSet : 添加顺序
TreeSet: 自己维护顺序
队列： Queue
栈： Deque

双列： Map

----------------------------------------------
Stream

流

对流中的数据 进行 聚集 运算。

统计

一次性的运算
速度快

末端方法：
得到结果后 就释放了。

中间方法：
会得到一个“新”的流 ，可以继续其它方法。

//---------------------------------------------------------------------------------------------------------------------------------------------------

 Collections 类中的常用方法

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**示例：Collections*/
public class TestCollections {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        //
        Collections.addAll(list, "aa","cc","bb");
        System.out.println(list);
        //自然 升序
        Collections.sort(list);
        System.out.println(list);
        //指定比较器
//        Collections.sort(list, (s1,s2)->s2.compareTo(s1));
        System.out.println(list);
        //查找参数 元素 在集合中 出现的索引 ， 前提   升序 排序
//        System.out.println(Collections.binarySearch(list, "aaa"));
        //集合 中 最小 的 和 最大 
        System.out.println(Collections.min(list));
        System.out.println(Collections.max(list));
        //
        list.add("aa");
        System.out.println(list);
        //查找 参数 元素 在集合 中 出现的 次数 ，不存在  0
        System.out.println(Collections.frequency(list, "aa"));//2
        //对集合元素进行反转
        Collections.reverse(list);
        System.out.println(list);
        //集合元素的洗牌
        Collections.shuffle(list);
        System.out.println(list);
        //集合的填充 ，用 参数 来替换 集合 中的每个元素。
        Collections.fill(list, "xxx");
        System.out.println(list);
        
    }

}

//练习：Collections 找出集合中的重复元素
public class TestCollections1 {

    public static void main(String[] args) {
        // 集合
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "张三","李四","李四","李四","李四","王五","王五");
        //
        Set<String> set = new HashSet<>(); 
        set.addAll(list); //将list放在HashSet 不重复集合中
        //
        System.out.println("-- 重复名单 --");
        for(String s : set) {
            if(Collections.frequency(list, s) > 1) {
                System.out.println(s);
            }
        }

    }

}

Dequal 双端队列

（可以模拟 栈和队列）

package day15;

import java.util.ArrayDeque;
import java.util.Deque;

public class TestDeque1 {

    public static void main(String[] args) {
        // Deque 双端队列 
        //模拟 队列
/*        Deque<String> d = new ArrayDeque<>();
        d.add("aa");
        d.addLast("bb");
        d.offer("cc");
        d.offerLast("dd");
        System.out.println(d);
        //出队
        while(d.size() > 0) {
//            System.out.println(d.poll());
            System.out.println(d.pollFirst());
        }*/
        
        //----------------栈-------------------------------------
        
        Deque<String> d = new ArrayDeque<>();
        //入栈
        d.addFirst("aa");
        d.offerFirst("bb");
        d.addFirst("cc");
        d.push("dd");
        //出栈
        while(d.size() > 0) {
//            System.out.println(d.pollFirst());
            System.out.println(d.pop());
        }
        

    }

}

Map基本操作

public class TestMap1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Map<Integer,String> map = new HashMap<>();
        //存信息,添加
        map.put(1, "张三");
        map.put(2, "李四");
        map.put(3, "王五");
        System.out.println(map);
        //获得 键值对 的数量
        System.out.println(map.size());//3
        //键值对的数目 为0  true
        System.out.println(map.isEmpty());//false
        //查看 指定 的键  在 集合 中  是否 存在;
        System.out.println(map.containsKey(2));
        //查看 指定 的值在 集合 中  是否 存在;
        System.out.println(map.containsValue("李四"));
        //根据 指定的键值对删除  
        map.remove(2);
        System.out.println(map);
        //获得 键的集合 Set
        Set<Integer> set = map.keySet();
        System.out.println(set);
        //值的集合
        Collection<String> c = map.values();
        System.out.println(c);
        //
//        map.clear();
//        System.out.println(map.isEmpty());
        //---------------------------------------
        System.out.println(map);
        //HashMap支持 存储入 null键 和 null值。
        map.put(null, null);
        System.out.println(map);
        //键是唯一 的，覆盖了之前的键值对
        map.put(1, "赵六");
        System.out.println(map);
    }

}

//遍历Map键值对操作
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.function.BiConsumer;

public class TestMap2 {

    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        //存信息,添加
        map.put(1, "张三");
        map.put(2, "李四");
        map.put(3, "王五");
        //遍历
        //1.
        map.forEach(new BiConsumer<Integer, String>() {

            @Override
            public void accept(Integer t, String u) {
                System.out.println(t + "," + u);
            }
        });
        map.forEach((k,v)-> System.out.println(k+":"+v));
        //2.iterator 

//　　　　　　　　迭代器（Iterator）

//　　　　　　　　迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。

//　　　　　　　　Java中的Iterator功能比较简单，并且只能单向移动

        map.keySet().iterator().forEachRemaining(System.out::println);
        map.values().iterator().forEachRemaining(System.out::println);
        //3.获得了键值对  的集合
        Set<Entry<Integer,String>> set = map.entrySet();
        //输出键值对
        set.forEach(e->System.out.println(e));
        set.forEach(e->System.out.println(e.getKey()+","+e.getValue()));
        
        //3.
        Set<Entry<Integer,String>> set1 = map.entrySet();
        //键值对的迭代器
        Iterator<Entry<Integer,String>> i = set1.iterator();
        i.forEachRemaining(System.out::println);
        
        //-----------------------------------------------------
//        Set<String> s = new HashSet<>();
//        s.add("aa");
        
    
        
    }

}

练习Map

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

public class TestMap3 {

    public static void main(String[] args) {
        //Map
        Map<String,String> map = new HashMap<>();
        map.put("PBC", "农业银行");
        map.put("ICBC", "工商银行");
        map.put("BC", "中国银行");
        map.put("CBC", "建设银行");
        //遍历
        map.keySet().forEach(System.out::println);
        map.values().forEach(System.out::println);
        map.forEach((k,v)->System.out.println(k+"="+v));
        //根据键 获得 值
        System.out.println("BC对应的银行是：" + map.get("BC"));
        //
        System.out.println(map.size());
        //
        map.remove("BC");
        System.out.println(map.containsKey("BC"));
        //
        map.keySet().iterator().forEachRemaining(System.out::println);
        map.values().iterator().forEachRemaining(System.out::println);
        map.entrySet().iterator().forEachRemaining(System.out::println);
    }

}

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

class Dog{
    private String name;
    private String type;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Dog(String name, String type, int age) {
        super();
        this.name = name;
        this.type = type;
        this.age = age;
    }
    public Dog() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public String toString() {
        return "Dog [name=" + name + ", type=" + type + ", age=" + age + "]";
    }
    
}
public class TestMap4 {
    Map<String,Dog> dogs = new HashMap<>();
    {
        Dog d1 = new Dog("旺旺","拉布拉多",2);
        Dog d2 = new Dog("旺财","金毛",3);
        Dog d3 = new Dog("美美","吉娃娃",1);
        dogs.put(d1.getName(), d1);
        dogs.put(d2.getName(), d2);
        dogs.put(d3.getName(), d3);
        
    }
    public void queryDog(String name) {
        //1
    /*    dogs.entrySet().iterator().forEachRemaining(e->{
            if(e.getKey().equals(name)) {
                System.out.println(e.getValue());
            }
        });*/
        //2
        System.out.println(dogs.get(name));
        
    }
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("--输入查找的狗狗的昵称：");
        String name = input.next();
        new TestMap4().queryDog(name);

    }

}

Predicate

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

class Student{
    private String name;
    private int 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;
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
    
}
public class TestPredicate1 {

    public void showStu(List<Student> stus,Predicate<Student> p) {
        for(Student stu:stus) {
            if(p.test(stu)) {
                System.out.println(stu);
            }
        }
    }
    public static void main(String[] args) {
        List<Student> stus = new ArrayList<>();
        stus.add(new Student("zhangsan",44));
        stus.add(new Student("lisi",55));
        stus.add(new Student("wangwu",22));
        /*new TestPredicate1().showStu(stus, new Predicate<Student>() {
            
            @Override
            public boolean test(Student t) {
                return t.getAge() > 30 && t.getName().contains("g");
            }
        });*/
        
        new TestPredicate1().showStu(stus, t->t.getAge() > 30 && t.getName().contains("g"));
    }

}

PriorityQueue筛选器

import java.util.PriorityQueue;
import java.util.Queue;

public class TestPriorityQueue {

    public static void main(String[] args) {
        // 优先队列
        Queue<Integer> q = new PriorityQueue<>((n1,n2)->n2 - n1);
        q.add(22);
        q.add(55);
        q.add(11);
//        q.forEach(System.out::println);
        while(q.size() > 0) {
            System.out.println(q.poll());
        }
    }

}

Queue 队列

package day15;

import java.util.LinkedList;
import java.util.Queue;

public class TestQueue1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Queue<String> q = new LinkedList<>();
        //向 队尾  加（入队）
        //  成功 true,失败 异常
        q.add("aa");
        q.add("bb");
        //失败 false
        q.offer("cc");
        q.forEach(System.out::println);
        //出队---------------------------
    /*    System.out.println(q.remove());
        System.out.println(q.remove());
        //失败 返回 null
        System.out.println(q.poll());*/
        //队列 不允许  加入 null,但是 LinkedList特殊 可以加入 null,但建议不要加null
//        q.offer(null);
        //循环出队 -----------------------------------
        System.out.println("-----------------------");
        while(q.size() > 0) {
            System.out.println(q.poll());//移除
//            System.out.println(q.peek());
        }
        
    }

}

package day15;

import java.util.ArrayDeque;
import java.util.Queue;

/**练习：队列*/
class User{
    private int no;
    private String name;
    
    public void setNo(int no) {
        this.no = no;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getNo() {
        return no;
    }
    public String getName() {
        return name;
    }
    public User(String name) {
        super();
        this.name = name;
    }
    @Override
    public String toString() {
        return no + "," + name;
    }
    
}
public class TestQueue2 {

    public static void main(String[] args) {
        Queue<User> users = new ArrayDeque<>();
        User u1 = new User("张三");
        User u2 = new User("李四");
        User u3 = new User("王五");
        User u4 = new User("赵六");
        User u5 = new User("周七");
        User [] us = {u1,u2,u3,u4,u5};
        for(int i = 0; i < us.length; i++) {
            us[i].setNo(i+1);//分配递增的编号
            users.offer(us[i]);//入队
        }
        while(users.size() >0) {
            //出队
            System.out.println("* " + users.poll() + "办理完了业务");
            if(users.size() >0) {
                System.out.println("剩余：");
                users.forEach(System.out::println);
            }else {
                System.out.println("后边没有队伍了");
                System.out.println("全部办理完成");
            }
        }

    }

}

Stream 流

import java.util.function.IntPredicate;
import java.util.stream.IntStream;

public class TestStream {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        IntStream is = IntStream.builder().add(11).add(22).add(33).add(55).build();
        //末端方法-------------------------------------------
//        System.out.println(is.max().getAsInt());
//        System.out.println(is.min().getAsInt());
//        System.out.println(is.sum());
//        System.out.println(is.average().getAsDouble());
//        System.out.println(is.count());
        //all 所有 的 数据 都满足条件 返回 true
    /*    System.out.println(is.allMatch(new IntPredicate() {
            
            @Override
            public boolean test(int value) {
                
                return value > 20;
            }
        }));*/
//        System.out.println(is.allMatch(v->v > 10));
        //any 流中 只要 有 一个 元素 满足 条件 就 返回 true
//        System.out.println(is.anyMatch(v-> v > 20));
        //------------------中间方法--------------------------------
        is.filter(v-> v > 20).forEach(System.out::println);
        
        
    }

}

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

public class TestStream2 {

    public static void main(String[] args) {
        // 
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list, 11,454,44,6878,23);
        list.stream().filter(v-> v < 55).forEach(System.out::println);
        System.out.println(list.stream().filter(v->v<55).count());
        //
        list.stream().forEach(System.out::println);

        
    }

}

import java.util.List;
import java.util.function.Predicate;

class Book{
    private String name;
    private double price;
    private String author;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public String getAuthor() {
        return author;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
    public Book(String name, double price, String author) {
        super();
        this.name = name;
        this.price = price;
        this.author = author;
    }
    public Book() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public String toString() {
        return "Book [name=" + name + ", price=" + price + ", author=" + author + "]";
    }
    
}
public class TestStream3 {
    
    public void bookInfo(List<Book> books , Predicate<Book> p) {
        /*books.forEach(e->{
            if(p.test(e)) {
                System.out.println(e);
            }
        });*/
        for(Book book : books) {
            if(p.test(book)) {
                System.out.println(book);
            }
        }
    }
    public int bookCount(List<Book> books , Predicate<Book> p) {
        int count = 0;
        for(Book book : books) {
            if(p.test(book)) {
                count++;
            }
        }
        return count;
    }
    
    public static void main(String[] args) {
        

    }

}