集合2

Posted 2020-12-30 fax1996

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了集合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

流

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

统计

一次性的运算
速度快

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

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

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

Collection

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

}

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.
        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) {
        

    }

}

以上是关于集合2的主要内容，如果未能解决你的问题，请参考以下文章

代码片段 - Golang 实现集合操作

laravel特殊功能代码片段集合

比较 C# 中的字符串片段并从集合中删除项目

带有红宝石集合/可枚举的酷技巧和富有表现力的片段[关闭]

[ jquery 文档处理 insertBefore(content) before(content|fn) ] 此方法用于把所有匹配的元素插入到另一个指定的元素元素集合的前面,实现外部插入(代码片段

前端开发常用js代码片段