day16_Collections,Queue，Map，Stream流，过滤接口

Collections

collection

Queue

| 实现类PriorityQueue

Deque 接口：双端队列

实现类 ArrayDeque，LinkedList

package day23;

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

/** Collections */
public class TestCollections {

    public static void main(String[] args) {
        List <Integer> list = new ArrayList<>();
        //向集合中加多个元素
        Collections.addAll(list, 11,22,33,44,35,77,99,23);
        System.out.println(list);

        //自然排序
        Collections.sort(list);
        System.out.println(list);

        //指定排序方式
//      Collections.sort(list,(n1,n2) -> n2 - n1);
//      System.out.println(list);

        //查找指定元素在集合中出现的位置索引
        System.out.println(Collections.binarySearch(list,33));//3
        //寻找集合中的最大最小元素
        System.out.println(Collections.max(list));//99
        System.out.println(Collections.min(list));//11

        //查找指定元素在集合中出现的次数
        Collections.addAll(list, 33,33,33,33,33);
        System.out.println(list);
        System.out.println(Collections.frequency(list, 33));//6
        System.out.println(Collections.frequency(list, 8888));//0

        //反转集合元素
        Collections.reverse(list);
        System.out.println(list);

        //对集合元素进行填充，全部替换
        Collections.fill(list, 111);
        System.out.println(list);
    }

}

Queue

数据结构：队列
队列：是一组操作受限的线性表。只能在队尾增加，队头删除。先进先出

添加	删除	获取列表头元素	操作失败时
add	remove	element	会产生异常
offer	poll	peek	不会产生异常，而是返回特定的值

package day23;

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

public class TestQueue {

    public static void main(String[] args) {
        Queue<Integer> q = new LinkedList<>();

        //入队
        q.add(22);
        q.offer(11);
        q.offer(33);
        System.out.println(q);
        q.forEach(System.out :: println);
        System.out.println("---------------------");
        //出队
//      System.out.println(q.remove());
//      System.out.println(q.poll());//null
        while(q.size() > 0){
            System.out.println(q.poll());
            //只会获得队头元素，不会移除
//          System.out.println(q.element());
        }
        System.out.println(q);
    }

}

Deque

添加	删除	获取列表头元素	操作失败时
addFirst,addLast	remove	element	会产生异常
offer	poll	peek	不会产生异常，而是返回特定的值

package day23;

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

public class TestDeque {

    public static void main(String[] args) {
        Deque <String> d = new ArrayDeque<>();
/*      //入队
        d.addLast("aa");
        d.addLast("bb");
        d.addLast("cc");

        //出队
        while(d.size() >0){
            System.out.println(d.pollFirst());
        }*/

        //入队
        d.add("aa");
        d.offer("bb");
        d.offer("cc");

        //出队
        while(d.size() >0 ){
            System.out.println(d.poll());
        }
        //----------------栈:后进先出----------------------
        //用队列的方法模拟栈
/*      d.addFirst("aa");
        d.offerFirst("bb");
        d.offerFirst("cc");

        //出栈
        while(d.size() >0){
            System.out.println(d.pollFirst());
        }*/


        //----------------直接栈操作-------------------
        d.push("aa");
        d.push("bb");
        d.push("cc");

    }

}

Map接口：存储键值对（映射）

Map 接口

| 实现类 HashMap ——子类LinkedHashMap；HashTable —— Propeties类

接口SortedMap

扫描二维码关注公众号，回复： 1447903 查看本文章

package day23;

import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public class TestMap {

    public static void main(String[] args) {
        //Map<Integer,String> map = new HashMap<>();  
        Map<Integer,String> map = new LinkedHashMap<>();
        //添加
        map.put(11, "aa");
        map.put(22, "bb");
        map.put(33, "cc");
        map.put(null, null);//可包含null

        //查看集合中键值对的数量
        System.out.println(map.size());
        System.out.println(map);
        System.out.println(map.keySet());//键是唯一的
        System.out.println(map.values());

        Set <Integer> set = new HashSet<>();
        map.put(33, "xyz");
        System.out.println(map);

        //判断键值对的数量是否为0，为0返回ture
        System.out.println(map.isEmpty());
        //判断是否包含指定参数的key键，包含返回ture
        System.out.println(map.containsKey(33));
        //判断是否包含指定参数的值，包含返回ture
        System.out.println(map.containsValue("cc"));
        //删除指定键对应的集合中的键值对信息
        map.remove(33);
        //清空
        map.clear();
    }

}

package day23;
    // 遍历
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

public class TestMapIterator {

    public static void main(String[] args) {

        Map<Integer,String> map = new HashMap<>();
        map.put(11, "aa");
        map.put(22, "bb");
        map.put(33, "cc");
        System.out.println(map);

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

        //3.整体作为一个键值对遍历
        Iterator <Entry<Integer,String>>i = map.entrySet().iterator();
        while(i.hasNext()){
            Entry<Integer, String> e = i.next();//键值对
            System.out.println(e);
            System.out.println(e.getKey());
            System.out.println(e.getValue());
        }
        map.entrySet().iterator().forEachRemaining(e -> System.out.println(e+ ","+e.getKey()+","+e.getValue()));
    }

}

HashMap,LinkedHashMap,TreeMap,Hashtable的区别

无序

HashMap：线程非安全。可以存储空键和空值

Hashtable：线程安全的，性能低
有序

LinkedHashedMap：按照添加的顺序

TreeMap：key，自然升序排序，自己指定顺序

Stream流操作

聚集运算。

聚集：统计运算。

特点：临时性的，一次性操作，效率高

方法

末端方法：一次性消耗掉这个流
中间方法：会创建出一个新的流

package day23;

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

public class TestStream {

    public static void main(String[] args) {
        IntStream i = IntStream.builder().add(11).add(22).add(33).build();  
        //---------------------末端方法------------------
//      System.out.println(i.max().getAsInt());//33
//      
//      //最小值
//      IntStream i1 = IntStream.builder().add(11).add(22).add(33).build();
//      System.out.println(i1.min().getAsInt());
//      
//      //和
//      IntStream i2 = IntStream.builder().add(11).add(22).add(33).build();
//      System.out.println(i2.sum());
//      
//      //平均
//      IntStream i3 = IntStream.builder().add(11).add(22).add(33).build();
//      System.out.println(i3.average().getAsDouble());
//      
//      //个数
//      IntStream i4 = IntStream.builder().add(11).add(22).add(33).build();
//      System.out.println(i4.count());

        //判断流中的所有数据是否满足条件
//      System.out.println(i.allMatch(new IntPredicate() {
//          
//          @Override
//          public boolean test(int value) {
//  
//              return value > 20;
//          }
//      }));
//      System.out.println(i11.allMatch(v -> v>10));

        //只要有一个满足条件就返回ture
//      System.out.println(i.anyMatch(v -> v>20));

        //---------------------中间方法------------------
        //会返回一个新的流
        //i.filter( v -> v > 20).forEach(System.out::println);
        //---------------------Stream流对集合进行聚合运算------------------
        List <Integer> list = new ArrayList<>();
        list.add(222);
        list.add(333);
        list.add(444);
        list.stream().forEach(System.out::println);
        System.out.println("-----------------------------------");
        list.stream().filter( v -> v >200).forEach(System.out::println);
        System.out.println(list.stream().filter( v -> v >200).count());

    }

}

过滤接口

package day23;

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

/** 过滤器接口 */

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

}

public class TestPredicate {
    public void check(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<>();
    Student zhangsan = new Student("zhangsan",31);
    Student lisi= new Student("lisi",34);
    Student wangwu = new Student("wangwu",20);
    Collections.addAll(stus, zhangsan,lisi,wangwu);

    new TestPredicate().check(stus,new Predicate <Student>(){

        @Override
        public boolean test(Student t) {
            return t.getAge() > 30 && t.getName().contains("g");
        }

    });

    new TestPredicate().check(stus, t -> t.getAge() > 30 && t.getName().contains("g"));
    }

}

day16_Collections,Queue，Map，Stream流，过滤接口

Collections

Queue

Deque

Map接口：存储键值对（映射）

HashMap,LinkedHashMap,TreeMap,Hashtable的区别

Stream流操作

特点：临时性的，一次性操作，效率高

方法

过滤接口

猜你喜欢