目录
1.可变参数：
2.Collections:
3.不可变集合：
4.Stream流:
1、什么是流
2、如何生成流
1.单列集合获取Stream流
2.双列集合获取Stream流
3.数组获取Stream流：
4.一堆零散数据： Stream接口中的静态方法
3.Stream流的中间方法
1.过滤：把“张”开头的留下，其余数据过滤不要
2.limit获取前几个元素
3.skip跳过前几个元素
4.元素去重distinct
5.concat合并a和b两个流为一个流
6.map转换流中的数据类型
4.Stream流的终结操作
1.void forEach(Consumer action)遍历
2.long count统计（个数）
3.toArry()收集流中数据放入数组
5.收集方法collect超详解
6.练习
List系列集合:添加的元素是有序（存取）、可重复、有索引
Set系列集合:添加的元素是无序（没顺序是说没有存取顺序，不是说没有真实存在的顺序）、不重复、无索引
1.可变参数：
1.可变参数本质上就是一个数组
2.作用:在形参中接收多个数据
3.格式:数据类型...参数名称
eg：int...a
4.注意事项
形参列表中可变参数只能有一个（int...a）
可变参数(int...a)必须放在形参(int b)列表的最后面
public class Main {
public static void main(String[] args) {
int sum=getSum(1,2,3,4,5,6,7,8,9,10);
System.out.println(sum);
}
public static int getSum(int...args){
int sum=0;
for (int i : args) {//是值
sum+=i;
}
return sum;
}
}2.Collections:
java.util.collections:是集合工具类
作用:Collections不是集合，而是集合的工具类。
练习：
ArrayList<String> list=new ArrayList<>();
Collections.addAll(list,"ad","df","ty","kdh","fjd");
System.out.println(list);
Collections.shuffle(list);
System.out.println(list);3.不可变集合：
eg：
List<String> list = List.of("aaa", "bbb", "ccc");总结：
4.Stream流:
1、什么是流
流是从支持数据处理操作的源生成的元素序列，源可以是数组、文件、集合、函数。流不是集合元素，它不是数据结构并不保存数据，它的主要目的在于计算。
2、如何生成流
生成流的方式主要有五种
通过集合生成，应用中最常用的一种
1.单列集合获取Stream流
ArrayList<String> list=new ArrayList<>();
Collections.addAll(list,"ad","df","ty","kdh","fjd");
list.stream().forEach(s->System.out.println(s));
2.双列集合获取Stream流
，要先转化为单列集合
eg1：hm.keySet().forEach(s->..............
eg2:hm.entrySet(.............
3.数组获取Stream流：
int[] arr={1,2,3,4,5,6,7};
Arrays.stream(arr).forEach(s->System.out.println(s));
4.一堆零散数据： Stream接口中的静态方法
Stream.of(1,2,3,4).forEach(s->System.out.println(s));注意4：可以放数组，但是要是引用数据类型的，如果是基本数据类型则会把整个数组当做一个元素放入Stream流
3.Stream流的中间方法
1.过滤：把“张”开头的留下，其余数据过滤不要
ArrayList<String> list=new ArrayList<>();
Collections.addAll(list,"张ad","刘df","张ty","周kdh","fjd");
//filter 过滤 把张开头的过滤留下，其余数据过滤不要
list.stream().filter(new Predicate<String>() {
@Override
public boolean test(String s) {
//如果返回值为true，表示当前值留下
//如果返回值为false，表示当前数据舍弃不要
return s.startsWith("张");
}
}).forEach(s->System.out.println(s));改成lambda表达式：
list.stream().filter(s->s.startsWith("张")).forEach(s->System.out.println(s));
注意：1.中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
2.修改Stream流中的数据，不影响原来集合或者数组中的数据
2.limit获取前几个元素
list.stream().limit(3).forEach(s->System.out.println(s));
3.skip跳过前几个元素
list.stream().skip(3).forEach(s -> System.out.println(s));
4.元素去重distinct
(依赖hashcode和equals方法)
跟前面的方法一样，String引用数据类型java已经给你写好了，直接用就行，但如果你是Student类型需要自己重写
5.concat合并a和b两个流为一个流
（尽可能让两个数据类型一致，否则就是a和b狗共同的父类了，这样相当于做了数据类型的提升，提升之后是无法使用子类里面特有的功能的）
ArrayList<String> list=new ArrayList<>();
Collections.addAll(list,"张ad","刘df","张ty","周kdh","fjd");
ArrayList<String> list2=new ArrayList<>();
Collections.addAll(list,"a","b","c","d","e");
Stream.concat(list.stream(),list2.stream()).forEach(s->System.out.print(s+" "));
//结果：张ad 刘df 张ty 周kdh fjd a b c d e 6.map转换流中的数据类型
需求：只获取里面的年龄并进行打印
String->int
第一个类型：流中原本的数据类型
第二个类型：要转成之后的类型
apply的形参s：依次表示流里面的每一个数据
返回值：表示转换过后的数据
小细节：当map方法执行完毕后，流上的数据就变成了整数，所以在下面forEach当中，s依次表示流里面的每一个数据，这个数据现在就是整数了
ArrayList<String> list3=new ArrayList<>();
Collections.addAll(list3,"张ad-23","刘df-19","张ty-33","周kdh-17","fjd-34");
//转换流中的数据类型
list3.stream().map(new Function<String, Integer>() {
@Override
public Integer apply(String s) {
String[] arr = s.split("-");//这个函数表示
String ageString=arr[1];
int age=Integer.parseInt(ageString);
return age;
}
//小细节：当map方法执行完毕后，流上的数据就变成了整数
//所以在下面forEach当中，s依次表示流里面的每一个数据，这个数据现在就是整数了
}).forEach(s->System.out.println(s));
写成lambda表达式：**********************
//第一个s表示list3里面的每个数据，如“张ad-23”
list3.stream()
//[1]表示的事split分割函数从“-”分割后面一部分
.map(s ->Integer.parseInt(s.split("-")[1]))
.forEach(s->System.out.println(s));4.Stream流的终结操作
1.void forEach(Consumer action)遍历
list.stream().forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
//lambda表达
list.stream().forEach(s -> System.out.println(s));2.long count统计（个数）
//统计（个数）
long count = list.stream().count();
System.out.println(count);3.toArry()收集流中数据放入数组
法一：
Object[] arr1 = list.stream().toArray();
System.out.println(Arrays.toString(arr1));法二：
//IntFunction的泛型:具体类型的数组
//apply的形参:流中数据的个数，要跟数组的长度保持一致
//apply的返回值:具体类型的数组//方法体:就是创建数组
//toArray方法的参数的作用:负责创建一个指定类型的数组
//toArray方法的底层，会依次得到流里面的每一个数据，并把数据放到数组当中
//toArray方法的返回值:是一个装着流里面所有数据的数组
String[] arr=list.stream().toArray(new IntFunction<String[]>() {
@Override
public String[] apply(int value) {
return new String[value];//数组的长度是value
}
});
System.out.println(Arrays.toString(arr));
//改成lambda表达式
String[] arr2 = list.stream().toArray(value -> new String[value]);
System.out.println(Arrays.toString(arr2));
5.收集方法collect超详解
eg：把所有的男性收集List集合当中
//收集方法collect(Collector collector)
ArrayList<String> list4=new ArrayList<>();
Collections.addAll(list4,"张ad-男-23","刘df-女-19","张ty-男-33","周kdh-女-17","fjd-男-34");
List<String> newList = list4.stream().filter(s -> "男"
.equals(s.split("-")[1]))
.collect(Collectors.toList());
System.out.println(newList);eg：把所有的女性收集Set集合当中
Set<String> newList2 = list4.stream().filter(s -> "女"
.equals(s.split("-")[1]))
.collect(Collectors.toSet());
System.out.println(newList2);难点：将男性数据收集到双列集合map中
打印名字和年龄
ArrayList<String> list4=new ArrayList<>();
Collections.addAll(list4,"张ad-男-23","刘df-女-19","张ty-男-33","周kdh-女-17","fjd-男-34");
Map<String, Integer> newmap1 = list4.stream().filter(s -> "男"
.equals(s.split("-")[1]))
.collect(Collectors.toMap(new Function<String, String>() {
@Override
public String apply(String s) {
return s.split("-")[0];
}
}, new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return Integer.parseInt(s.split("-")[2]);
}
}));
System.out.println(newmap1);
//写成lambda
Map<String, Integer> newmap2 = list4.stream().filter(s -> "男"
.equals(s.split("-")[1]))
.collect(Collectors.toMap(s -> s.split("-")[0],
s -> Integer.parseInt(s.split("-")[2])));
System.out.println(newmap2);
6.练习
一.
ArrayList<Integer> list=new ArrayList<>();
Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);
//用lambda
List<Integer> newlist2 = list.stream()
.filter(s -> s % 2 == 0)
.collect(Collectors.toList());
System.out.println(newlist2);二.
ArrayList<String> list5=new ArrayList<>();
Collections.addAll(list5,"zhangsan,23","lisi,24","wangwu,25");
Map<String, Integer> newmap3 = list5.stream()
.filter(s -> 24 <= Integer.parseInt(s.split(",")[1]))
.collect(Collectors.toMap(s -> s.split(",")[0],
s -> Integer.parseInt(s.split(",")[1])));
System.out.println(newmap3);
注意：封装成Actor对象要用map转换，新建一个Actor的类包含name，age
//另外写了一个类Actor
ArrayList<String> manlist = new ArrayList<>();
ArrayList<String> womenlist = new ArrayList<>();
Collections.addAll(manlist, "刘大壮，37", "刘小壮，27", "李大壮，35", "李壮，32", "张王，23", "徐树，12");
Collections.addAll(womenlist, "杨芳，14", "秦可卿，25", "，35", "杨奈，42", "杨云朵，21", "宋馨，12");
Stream<String> newman = manlist.stream()
.filter(s -> s.split("，")[0].length() == 3)
.limit(2);
Stream<String> newwomen = womenlist.stream()
.filter(s -> s.startsWith("杨"))
.skip(1);
//String->Actor对象 （类型转换map）
List<Actor> mwlist = Stream.concat(newman, newwomen).map(new Function<String, Actor>() {
@Override
public Actor apply(String s) {
String name = s.split("，")[0];
int age = Integer.parseInt(s.split("，")[1]);
return new Actor(name, age);
}
}).collect(Collectors.toList());
System.out.println(mwlist);用lambda：
// 用lambda表达式
List<Actor> mwlist = Stream.concat(newman, newwomen)
.map(s -> new Actor(s.split("，")[0]
, Integer.parseInt(s.split("，")[1])))
.collect(Collectors.toList());
System.out.println(mwlist);
对前面集合还有遍历知识复习的题目：
题目：斗地主中的存牌，打乱牌，分发牌，排序
import java.util.*;
public class PokerGame {
static HashMap<Integer, String> hm = new HashMap<>();
static ArrayList<Integer> list = new ArrayList<>();
//准备牌
static {
String[] color = {"♦", "♣", "♥", "♠"};
String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
int serialNumber = 1;
for (String n : number) {
for (String c : color) {
list.add(serialNumber);
hm.put(serialNumber++, c + n);
}
}
list.add(serialNumber);
hm.put(serialNumber++, "小王");
list.add(serialNumber);
hm.put(serialNumber, "大王");
}
public PokerGame() {
//洗牌
Collections.shuffle(list);
//发牌+排序
TreeSet<Integer> lord = new TreeSet<>();
TreeSet<Integer> player1 = new TreeSet<>();
TreeSet<Integer> player2 = new TreeSet<>();
TreeSet<Integer> player3 = new TreeSet<>();
for (int i = 0; i < list.size(); i++) {
if (i <= 2) {
lord.add(list.get(i));
continue;
}
if (i % 3 == 0) {
player1.add(list.get(i));
} else if (i % 3 == 1) {
player2.add(list.get(i));
} else {
player3.add(list.get(i));
}
}
//查看牌
lookPoker("地主",lord);
lookPoker("钟英",player1);
lookPoker("周雨雨",player2);
lookPoker("王二",player3);
}
public void lookPoker(String name,TreeSet<Integer> player){
System.out.print(name+": ");
for (Integer serialNumber : player) {
String poker=hm.get(serialNumber);
System.out.print(poker+" ");
}
System.out.println();
}
}
