JavaDay17
创建不可变集合
import java.util.Iterator;
import java.util.List;
public class Test {
public static void main(String[] args) {
/*创建不可变的List集合
* "张三" "李四" "王五" "赵六*/
//一旦创建之后 是无法进行修改的 在下面的代码中 只能进行查询操作
List list = List.of("张三", "李四", "王五", "赵六");
System.out.println(list.get(0));
System.out.println(list.get(1));
System.out.println(list.get(2));
System.out.println(list.get(3));
System.out.println("-----------------------");
for (String s : list) {
System.out.println(s);
}
System.out.println("-----------------------");
Iterator it = list.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
System.out.println("------------------------");
for(int i=0;i import java.util.Iterator;
import java.util.Set;
public class Test {
public static void main(String[] args) {
/*创建不可变的Set集合
* "张三","李四","王五","赵六"
* 细节:set ->元素唯一
* 当我们要获得一个不可变的Set集合时 元素不可以重复
*
* */
Set set = Set.of("张三", "李四", "王五", "赵六");
for (String s : set) {
System.out.println(s);
}
System.out.println("-----------------");
Iterator it = set.iterator();
while(it.hasNext()){
String s =it.next();
System.out.println(s);
}
System.out.println("-----------------");
//set.remove("王五");
}
}
import java.util.Map;
import java.util.Set;
public class Test {
public static void main(String[] args) {
/*创建Map的不可变集合
* "张三","南京","李四","北京,"王五","上海","赵六","广州","赵六"
*
*"广州","孙七","深圳","周八","杭州"
*细节:键是不能重复的
*细节:Map里面的of方法,参数是有上限的,最多只能传递20个参数,10个键值对
*细节:如果我们要传递多个键值对对象 数量大于10个 在Map接口中还有一个方法
*ofEntries
*
* */
Mapmap=Map.of("张三","南京","广州","赵六");
//一旦穿件完毕不可修改 只能进行查询操作
Setkeys=map.keySet();
for(String key:keys){
String value = map.get(key);
System.out.println(key+"="+value);
}
System.out.println("------------------------------");
Set> entries = map.entrySet();
for (Map.Entry entry : entries) {
String key= entry.getKey();
String value = entry.getValue();
System.out.println(key+"="+value);
}
System.out.println("------------------------------");
}
//如果我想让这个方法能够接受多个键和值
//解决方案:
//键 可变参数 值:可变参数
//类型不确定:泛型方法
//一个形参里面的可变参数要写在后面 而且参数里面最多只有一个可变参数
// public static void of(K...keys,V...values){
// //不能这样设置
// }
}
import java.util.HashMap;
import java.util.Map;
public class Demo1 {
public static void main(String[] args) {
//创建Map的不可变集合 键值对的数量超过10个
//1创建一个Map集合
HashMaphm = new HashMap<>();
hm.put("张三","南京");
hm.put("李四","北京");
hm.put("王五","上海");
hm.put("赵六","湖北");
hm.put("1","11");
hm.put("2","22");
hm.put("3","33");
hm.put("4","44");
hm.put("5","55");
hm.put("6","66");
//2.利用上面的数据来获取一个不可变的集合
// //获取到所有的键值对对象(Entry对象)
// Set> entries = hm.entrySet();
// //把entries变成一个数组
// //Map.Entry[] arr = entries.toArray(new Map.Entry[0]);
//
// Object[] objects = entries.toArray();
//
for (Object object : objects) {
System.out.println(object);
}//但是类型是object
//
// //数组指定类型
// Map.Entry[] arr1 = new Map.Entry[0];//
// //toArray方法在底层会比较集合的长度跟数组的长度两者大小
// //如果集合的长度>数组的长度:数据在数组中放不下,此时会根据实际数据的个数,重新创建数组
// //如果集合的长度<=数组的长度:数据在数组中放的下 不会创建新的数组 直接用
//
// Map.Entry[] arr2 = entries.toArray(arr1);
// //不可变的map集合
// Map map = Map.ofEntries(arr2);
//简化代码
// Map map = Map.ofEntries(hm.entrySet().toArray(new Map.Entry[0]));
// map.put("bbb","222");
//copyOf - JDK10
Map map = Map.copyOf(hm);
}
} 
Stream流
public class Test {
public static void main(String[] args) {
ArrayList list1 = new ArrayList<>();
list1.add("张无忌");
list1.add("周芷若");
list1.add("赵敏");
list1.add("张强");
list1.add("张三丰");
list1.stream().filter(name->name.startsWith("张")).filter(name->name.length()==3).forEach(name-> System.out.println(name));
// //把所有以张开头的放到新的集合
// ArrayList list2 = new ArrayList<>();
//
// for (String name : list1) {
// if (name.startsWith("张")) {
// list2.add(name);
// }
// }
// //System.out.println(list2);
//
// //把"张"开头的,长度为3的元素再存储到新集合中
// ArrayList list3 = new ArrayList<>();
// for (String name : list2) {
// if (name.length() == 3) {
// list3.add(name);
// }
// }
// //3.遍历打印最终的结果
// for (String name : list3) {
// System.out.println(name);
// }
//
}
}
单列集合
import java.util.ArrayList;
import java.util.Collections;
public class Test {
public static void main(String[] args) {
//1.单列集合获取Stream流
ArrayListlist =new ArrayList<>();
Collections.addAll(list,"a","b","c","d","e");
//获取一条流水线 并把集合中的数据放到流水线上
// Stream stream1 = list.stream();
// //使用终结方法打印一下流水线上面的数据
// stream1.forEach(new Consumer() {
// @Override
// public void accept(String s) {
// //s:依次表示流水线上的每一个数据
// System.out.println(s);
// }
// });
list.stream().forEach(s-> System.out.println(s));
}
}
双列集合
import java.util.HashMap;
public class Test {
public static void main(String[] args) {
//双列集合
//1.创建双列集合
HashMaphm = new HashMap<>();
//2.添加数据
hm.put("aaa",111);
hm.put("bbb",222);
hm.put("ccc",333);
hm.put("ddd",444);
//3.第一种获取stream流
hm.keySet().stream().forEach(s-> System.out.println(s));
//4.第二种获取
hm.entrySet().stream().forEach(s-> System.out.println(s));
}
} 数组
public class Test {
public static void main(String[] args) {
//1.创建数组
int[] arr ={1,2,3,4,5,6,7,8,9,10};
//2.获取stream流
Arrays.stream(arr).forEach(s-> System.out.println(s));
String[] arr2 ={"a","b","c"};
Arrays.stream(arr2).forEach(s-> System.out.println(s));
}
}一堆零散数据
import java.util.stream.Stream;
public class Test {
public static void main(String[] args) {
//一堆零散数据
Stream.of(1,2,3,4,5).forEach(s-> System.out.println(s));
Stream.of("a","b","c","d","e").forEach(s-> System.out.println(s));
//注意:
//stream接口中静态方法of的细节
//方法的形参是一个可变参数 可以传递一堆零散的数据 也可以传递数组
//但是数组必须是引用数据类型的 如果传递基本数据类型 是把整个数组当做
//一个元素 放到stream流
}
}
import java.util.ArrayList;
import java.util.Collections;
public class Test {
public static void main(String[] args) {
ArrayListlist = new ArrayList<>();
Collections.addAll(list,"111","222","333","444","555","666");
//filter 过滤
// list.stream().filter(new Predicate() {
// @Override
// public boolean test(String s) {
// //如果返回值为true 表示当前数据留下
// //如果返回值为false 表示当前数据舍弃不要
//
// return s.startsWith("6");
// }
// }).forEach(s -> System.out.println(s));//666
// list.stream().filter(s->s.startsWith("6")).forEach(s-> System.out.println(s));
// System.out.println(list);
// list.stream().limit(3).forEach(s-> System.out.println(s));
// list.stream().skip(4).forEach(s-> System.out.println(s));
//获取444 555 666
list.stream().limit(6).skip(3).forEach(s-> System.out.println(s));
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;
public class Test {
public static void main(String[] args) {
ArrayListlist1 = new ArrayList<>();
Collections.addAll(list1,"111","111","222","333","444","555","666");
ArrayListlist2=new ArrayList<>();
Collections.addAll(list2,"999","888");
list1.stream().distinct().forEach(s-> System.out.println(s));
//元素去重 一来(HashCode和equals方法)
Stream.concat(list1.stream(),list2.stream()).forEach(s-> System.out.println(s));
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;
public class Test {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
Collections.addAll(list, "张-11", "杨-19", "李-29", "咩-23");
//只获取里面的年龄并且打印
//String->int
//第一个数据类型:流中原本的数据类型
//第二个数据类型:要转成的类型
//apply的形参s:依次表示流里面的每一个数据
//返回值:表示转换之后的数据
//当map方法执行完毕后 流上的数据变成了整数
//所以当下面的forEach当中 s依次表示流里的每一个数据,这个数据现在就是整数了
list.stream().map(new Function() {
@Override
public Integer apply(String s) {
String[] arr = s.split("-");
String ageString = arr[1];
int age =Integer.parseInt(ageString);
return age;
}
}).forEach(s-> System.out.println(s));
list.stream()
.map(s->Integer.parseInt(s.split("-")[1]))
.forEach(s-> System.out.println(s));
}
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
public class Test {
public static void main(String[] args) {
ArrayListlist=new ArrayList<>();
Collections.addAll(list,"111","222","333","444","555");
//遍历 -底层是函数式接口 -要改成Lambda表达式
//Consumer的泛型:表示流中数据的类型
//accept方法的形参s:依次表示流里面的每一个数据
//方法体:对每一天数据的处理操作(打印)
// list.stream().forEach(new Consumer() {
// @Override
// public void accept(String s) {
// System.out.println(s);
// }
// });
//list.stream().forEach(s-> System.out.println(s));
//count
// long count = list.stream().count();
// System.out.println(count);
//toArray 手机流中的数据 放到数组中
// Object[] arr1 = list.stream().toArray();
// System.out.println(Arrays.toString(arr1));
//InFunction的泛型:具体类型的数组
//apply的形参:流中数据的个数,要跟数组的长度保持一致
//apply的返回值:具体类型的数组
//方法体:创建数组
//toArray方法的参数的作用,负责创建一个指定类型的数组
//toArray方法的底层,会依次得到流里面的每一个数据 并把数据放到数组当中
//toArray方法的返回值:是一个装着流里面所有数据的数组
// String[] arr = list.stream().toArray(new IntFunction() {
// @Override
// public String[] apply(int value) {
// return new String[value];
// }
// });
// System.out.println(Arrays.toString(arr));
String[] arr2 = list.stream().toArray(value -> new String[value]);
System.out.println(Arrays.toString(arr2));
}
} 
import java.util.*;
import java.util.stream.Collectors;
public class Test {
public static void main(String[] args) {
ArrayListlist=new ArrayList<>();
Collections.addAll(list,"111-男-yjy","222-男-yyy","333-女-sss","444-男-ppp","555-男-nnn");
//收集List当中 所有的男性
//s:依次表示流水线上面的数据
List newList = list.stream().filter(s -> "男".equals(s.split("-")[1])).collect(Collectors.toList());
//System.out.println(newList);
//收集到set集合当中
Set newList2 = list.stream().filter(s -> "男"
.equals(s.split("-")[1])).collect(Collectors.toSet());
//System.out.println(newList2);
//搜集到List和set有什么区别?set->去重
//收集到Map当中
//谁作为键,谁作为值.
//把所有男性手机起来
//键:姓名 值:年龄
/*
* toMap:参数一:键的生成规则
* 参数二:表示值的生成规则
* 参数一:Function泛型一:表示流中每一个数据的类型
* 泛型二:表示Map集合中键的数据类型
* 方法:apply形参:依次表示流里面的每一个数据
*
* //方法体:生成键的代码'
* 返回值:已经生成的键
*
* 参数二:
* Function泛型一:表示流中每一个数据的类型
* 泛型二:表示Map集合中值的数据类型
*
*
* 方法:apply形参:依次表示流里面的每一个数据
*
* //方法体:生成值的代码'
* 返回值:已经生成的值
*
*
* */
// Map map = list.stream().filter(s -> "男".equals(s.split("-")[1]))
// .collect(Collectors.toMap(new Function() {
// @Override
// public String apply(String s) {
// return s.split("-")[0];
//
// }
// },
// new Function() {
// @Override
// public Integer apply(String s) {
// return Integer.parseInt(s.split("-")[2]);
//
// }
// }));
//
//
// System.out.println(map);
Map map = list.stream()
.filter(s->"男".equals(s.split("-")[1]))
.collect(Collectors.toMap(
s->s.split("-")[0],
s->Integer.parseInt(s.split("-")[2])));
System.out.println(map);
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class Test {
public static void main(String[] args) {
ArrayListlist=new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
list.add(8);
list.add(9);
list.add(10);
//Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);
List newList = list.stream().filter(n -> n % 2 == 0).collect(Collectors.toList());
System.out.println(newList);
}
}
import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;
public class Test {
public static void main(String[] args) {
ArrayListlist=new ArrayList<>();
list.add("zhangsan,23") ;
list.add("lisi,24");
list.add("wangwu,25");
//System.out.println(list);
// list.stream().filter(s->Integer.parseInt(s.split(",")[1])>=24)
// .collect(Collectors.toMap(new Function() {
// @Override
// public String apply(String s) {
// return s.split(",")[0];
// }
// }, new Function() {
// @Override
// public Integer apply(String s) {
// return Integer.parseInt(s.split(",")[1]);
// }
// }));
Map map = list.stream().filter(s -> Integer.parseInt(s.split(",")[1]) >= 24)
.collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));
System.out.println(map);
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Test {
public static void main(String[] args) {
//1.创建两个集合
ArrayListmanList=new ArrayList<>();
ArrayListwomenList=new ArrayList<>();
//添加数据
Collections.addAll(manList,"言热额,12","叶的的,22","李人,44","得到,14","隐覆盖,99");
Collections.addAll(womenList,"赵,35","杨1,37","高,54","张,84","杨2,90");
//男演员只要名字为三个字的前两个
Stream stream1 = manList.stream().filter(s -> s.split(",")[0].length() == 3).limit(2);
//女演员只要姓杨的 且不要第一个
Stream stream2 = womenList.stream().filter(s -> s.split(",")[0].startsWith("杨")).skip(1);
//把过滤后的两个流和在一起
//演员信息封装成为actor对象(类型转换)
//Actor里面有姓名和年龄
// Stream.concat(stream1,stream2).map(new Function() {
// @Override
// public Actor apply(String s) {
// String name = s.split(",")[0];
// int age = Integer.parseInt(s.split(",")[1]);
// return new Actor(name,age);
//
// }
// }).forEach(s-> System.out.println(s));
List LIST = Stream.concat(stream1, stream2)
.map(s -> new Actor(s.split(",")[0], Integer.parseInt(s.split(",")[1])))
.collect(Collectors.toList());
System.out.println(LIST);
}
}
方法引用
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
//需求:创建一个数组,进行倒序排列
Integer[] arr ={3,5,4,1,6,2};
//匿名内部类
// Arrays.sort(arr, new Comparator() {
// @Override
// public int compare(Integer o1, Integer o2) {
// return o2-o1;
// }
// });
//System.out.println(Arrays.toString(arr));
//Lambda表达式
//因为第二个参数的类型是Comparator是一个函数式接口
// Arrays.sort(arr,(Integer o1, Integer o2)->{
// return o2-o1;
// });
//Lambda表达式简化格式
Arrays.sort(arr,(o1,o2)->o2-o1);
//方法引用
//1.引用处必须是函数式接口
//2.被引用的方法需要已经存在
//3.被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致
//4.被引用的方法的功能需要满足当前的要求
//表示引用Test类里面Substraction方法
//把这个方法当做抽象方法的方法体
Arrays.sort(arr,Test::Substraction);
System.out.println(Arrays.toString(arr));
}//静态方法要用类名调用
//可以是Java已经写好的 也可以是一些第三方的工具类
public static int Substraction(int num1,int num2){
return num2-num1;
}
} 
import java.util.ArrayList;
import java.util.Collections;
public class Test {
public static void main(String[] args) {
//创建集合并添加元素
ArrayListlist=new ArrayList<>();
Collections.addAll(list,"1","2","3","4","5");
//常规方法
// ArrayListlist2=new ArrayList<>();
// for (String s : list) {
// int i=Integer.parseInt(s);
// list2.add(i);
// }
// list.stream().map(new Function() {
// @Override
// public Integer apply(String s) {
// int i = Integer.parseInt(s);
// return i;
// }
// }).forEach(s-> System.out.println(s));
list.stream().map(Integer::parseInt).forEach(s-> System.out.println(s));
}
} 
import java.util.ArrayList;
import java.util.Collections;
public class Test {
public static void main(String[] args) {
//1.创建集合
ArrayListlist = new ArrayList<>();
//2.添加数据
Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰");
//3.过滤数据("张"开头 而且名字是3个字的)
//list.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(s-> System.out.println(s));
// list.stream().filter(new Predicate() {
// @Override
// public boolean test(String s) {
// return s.startsWith("张")&&s.length()==3;
// }
// }).forEach(s-> System.out.println(s));
// list.stream().filter(new StringOperation()::StringJudge).forEach(s-> System.out.println(s));
//静态方法中是没有this的 所以这里不能写this
list.stream().filter(new Test()::stringJudge).forEach(s-> System.out.println(s));
}
public boolean stringJudge(String s){
return s.startsWith("张")&&s.length()==3;
}
} 
package Day17;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
public class Test {
public static void main(String[] args) {
//引用构造方法
//1.创建集合对象
ArrayList list = new ArrayList<>();
//添加对象
Collections.addAll(list, "张无忌,15", "周芷若,14", "赵敏,13");
// //封装成Student对象并收集到List集合当中
// List newList = list.stream().map(new Function() {
// @Override
// public Student apply(String s) {
// String[] arr = s.split(",");
// String name = arr[0];
// int age = Integer.parseInt (arr[1]);
// return new Student(name, age);
// }
// }).collect(Collectors.toList());
//
// System.out.println(newList);
// }
List newList2 = list.stream().map(Student::new).collect(Collectors.toList());
System.out.println(newList2);
}
} 
import java.util.ArrayList;
import java.util.Collections;
public class Test {
public static void main(String[] args) {
/*方法引用的规则:
* 1.需要有函数式接口
* 2.被引用的方法必须已经存在
* 3.被引用方法的形参,需要跟抽象方法的第二个形参保持一致,返回值需要保持一致.
* 4.被引用方法的功能需要满足当前的需求
*
* 抽象方法形参的详解:
* 第一个参数:表示引用方法的调用者,决定了可以引用哪些类中的方法
* 在Stream流当中 第一个参数一般都表示流里面的每一个数据
* 假设流里面的数据都是字符串,那么使用这种方式进行方法引用,只能引用String这个类中的方法
*
* 第二个参数到最后一个参数,跟被引用方法的形参保持一致,如果没有第二个参数 说明被应用的方法需要无参的成员方法
*
* 局限性:
* 不能引用所有类中的成员方法
* 是跟抽象方法的第一个参数有关 这个参数是什么类型的 那么就只能引用这个类中的方法
* */
//类名引用成员方法
//1.创建集合对象
ArrayListlist = new ArrayList<>();
Collections.addAll(list,"aaa","bbb","ccc","ddd");
// list.stream().map(new Function() {
@Override
public String apply(String s) {
return s.toUpperCase();
}
}).forEach(s-> System.out.println(s));
//方法引用
list.stream().map(String::toUpperCase).forEach(s-> System.out.println(s));
}
}
