集合中的Stream+Collections+Iterator学习

• 泛型
  作用是建立数据类型安全的集合，把类型当做一种参数一样传递，只能是引用数据类型，Object可以代表是任意类型，但是也会出现类型转换错误ClassCastException异常，

• 泛型类
  把泛型定义在类上就是泛型类，用户在使用类时才能明确类型，

• 泛型接口
  泛型接口的具体类型需要在实现类中声明，

• Collection集合
  单例集合：数据是一个一个进行存储，
  双例集合：基于key-value的结构存储数据，

• Collection接口
  collection是单例集合的根接口，他有两个子接口list和set,
  collection接口中的方法：add(),remove(),contains()：是否包含该元素，size()集合中的元素个数，clear()清空，iterator()迭代器，containsAll(collection):是否包含该集合，toArray():转化成数组，
  jdk中的新方法：removeIf() 删除容器中所有满足指定条件的元素，
  stream():将要处理的元素看做一种流，流在管道中传输，并且可以在管道的节点上处理，包括过滤筛选、去重、排序、聚合等。元素流在管道中经过中间操作的处理，最后由最终操作得到前面处理的结果。流就是对数据进行加工处理一个过程，

集合中有两种方式生成流：stream()- 创建串行流，parallelStream()-创建并行流，Collection接口中加入了default方法stream(),

public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<>();
        Stream<Object> stream = list.stream();//list变成流对象
        String[] str = {"1","2","3","4"};
        Stream<String> str1 = Stream.of(str);//数组变成流对象 流只能是引用类型啊
        str1.forEach(System.out::println);
    }

• Stream常用方法介绍
  Stream流的操作很丰富，方法分为两种：
  1count ， 统计个数， 返回值类型是long，种类：终结
  2 forEach，遍历 ，void， 终结，
  3 fifilter ，过滤 ， Stream ，函数拼接，
  4 limit ，取前几个，Stream，函数拼接，
  5 concat，组合，Stream，函数拼接，
  6 skip ，跳过前几个，Stream，函数拼接，
  7 map，映射，Stream，函数拼接，
  注意Stream流只能操作一次，该方法返回的新的流，Stream不调用终结方法中间操作是不会执行的，

//forEach是用来遍历流中的数据的，
        TreeSet<String> str = new TreeSet<>();
        str.add("1");
        str.add("2");
        str.add("3");
        str.add("4");
        str.add("5");
        str.add("6");
        Stream<String> stream = str.stream();
        stream.forEach(System.out::println);

		//从流中获取元素个数
        long count = stream.count();
        System.out.println(count);

		 /**filter方法是用来过滤数据的，返回符合条件的数据，
        查看Stream.filter(Predicate<? super T> predicate
        查看predicate 是一个functionalInterface函数式接口有一个需要实现的方法是
         isEqual，所有我要实现这个方法
         */
        stream.filter((s)->s.contains("6")).forEach(System.out::println);
        //参数是分页的个数 从前到后哈，
		stream.limit(4).forEach(System.out::println);
		//跳过前几个元素
  		stream.skip(1).forEach(System.out::println);
		//去掉重复的数据 基本类型直接去重，引用类型需要重写hashCode和equals方法
		 stream.distinct().forEach(System.out::println);
		 

		//合并两个流
		package com.example.ajaxdemo.springmvc;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.TreeSet;
import java.util.stream.Stream;

public class CollectionTest {
    public static void main(String[] args) {
        //forEach是用来遍历流中的数据的，
        TreeSet<String> str = new TreeSet<>();
        str.add("1");
        str.add("2");
        str.add("3");
        str.add("3");
        str.add("4");
        str.add("5");
        str.add("5");
        str.add("6");
        str.add("6");
        Stream<String> stream = str.stream();
        ArrayList<String> strings = new ArrayList<>();
        strings.add("张");
        strings.add("Rudy");
        strings.add("java");
        Stream<String> stream1 = strings.stream();
        //合并两个流的方法
        Stream.concat(stream,stream1).forEach(System.out::println);
    }
}

• Collections工具类
  他提供了对set,list,map,进行排序，填充，查找元素的方法，该类中所有的方法都是静态方法，

    ArrayList<String> list = new ArrayList<>();
        list.add("c");
        list.add("b");
        list.add("a");
        list.add("e");
        list.add("h");
        Collections.sort(list);//进行排序
        for (String temp:list){
            System.out.print(temp);
        }
        System.out.println("洗牌开始+++++++++++");
        Collections.shuffle(list);
        for (String temp: list) { //进行洗牌
            System.out.print(temp);
        }

        System.out.println("在原来的基础上倒序");
        Collections.reverse(list);//倒序
        for(String li :list){
            System.out.print(li);
        }

		Collections.sort(list);//进行排序
		for (String str:list){
		    System.out.print(str);
		}
		System.out.println("");
		int i = Collections.binarySearch(list, "c");//查询出目标的下标
		System.out.println(i);
		System.out.println(list.get(i));

		ArrayList<String> list1 = new ArrayList<>();//默认是0 开始扩容
        Collections.addAll(list1,new String[list.size()]);//添加一个数组大小是上一个数组的大小
        Collections.copy(list1,list);
        for(String str:list1) {
            System.out.print(str);
        }


		Collections.fill(list,"张");//指定元素代替所有元素
        for(String str:list){
            System.out.println(str);
        }

• Iterator迭代器
  Colllection接口继承了Iterable接口，所有有了iterator方法，该方法会返回一个迭代器对象，该对象中包含了三个方法，用于迭代，
  1 hasNext(); 判断当前游标位置是否有元素，有返回true,没有返回false,
  2 next(); 获取到当前游标位置上的元素，并移动到下一个位置，
  3 remove(); 删除当前位置上的元素，

 ArrayList<String> list = new ArrayList<>();
        list.add("c");
        list.add("b");
        list.add("a");
        list.add("e");
        list.add("h");
        Iterator<String> iterator = list.iterator(); //这是遍历
        while(iterator.hasNext()){//判断
            String next = iterator.next();//获取
            System.out.print(next);
        }
		//删除指定元素
		 Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            String next = iterator.next();
            if("a".equals(next)){
                iterator.remove();
            }
        }
        for(String str:list){
            System.out.print(str);
        }

• 流

package com.zixue.springbootmybatis.test;

import java.sql.SQLOutput;
import java.util.Arrays;
import java.util.OptionalInt;
import java.util.stream.IntStream;

/** 流的操作类型分为两种
 * 1 中间操作
 * 一个流可以进行多个中间操作 如：filter map 等
 * 2 终端操作
 *  一个流只有一个终端操作,当这个操作执行后,流就关闭了 count collect
 *
 * */
public class Testdemo {
    public static void main(String[] args) {
        //中间操作 filter 筛选 filter方法参数为一个条件
        int[] a = {1,2,3,4,5,6,6};
        IntStream stream = Arrays.stream(a);
        IntStream intStream = stream.filter(s -> s > 3);
        intStream.forEach(System.out::print);//4566
        System.out.println();
        //distinct 去重复元素
        IntStream stream0 = Arrays.stream(a);
        IntStream distinct0 = stream0.distinct();
        distinct0.forEach(System.out::print);//123456
        System.out.println();
        //limit对流进行分页显示
        IntStream stream1 = Arrays.stream(a);
        IntStream limit = stream1.limit(2);
        limit.forEach(System.out::print);//12
        System.out.println();
        //跳过流中的元素的个数 skip()
        IntStream stream2 = Arrays.stream(a);
        IntStream skip = stream2.skip(2);
        skip.forEach(System.out::print);
        System.out.println();
        //元素匹配
        IntStream stream3 = Arrays.stream(a);
        if(stream3.allMatch(s->s>3)){
            System.out.println("值都大于3");
        }else{
            System.out.println("不是都大于3");
        }
        //匹配元素有没有满足条件的
        IntStream stream4 = Arrays.stream(a);
        if(stream4.anyMatch(s->s>5)){
            System.out.println("有大于5的数");
        }else{
            System.out.println("都没有大于5的数");
        }
        //全部不匹配
        IntStream stream5 = Arrays.stream(a);
        if(stream5.noneMatch(s->s>1)){
            System.out.println("值都大于1");
        }else{
            System.out.println("不是都大于1");
        }
        /** 终端操作
         * */
        //查找 findFirst 查找第一个 findAny 随机找一个
        IntStream stream6 = Arrays.stream(a);
        OptionalInt first1 = stream6.filter(s -> s > 3).findFirst();
        System.out.println(first1.toString());



    }
}