目录
一.创建不可变集合: 不可以被修改的集合
1.List接口创建不可变集合
2.Set接口创建不可变集合
3.Map接口创建不可变集合
二.Stream流
1.如何获取Stream流?
2.Stream流的中间方法
3.Stream流终结方法
三.方法引用
1.引用静态方法
2.引用成员方法
3.引用结构方法
4.使用类名引用成员方法
5.引用数组的构造方法
一.创建不可变集合: 不可以被修改的集合
作用: 不让别人修改集合中的内容
1.List接口创建不可变集合
格式: List.of(数据);
可以进行查询和遍历但是不能修改内容
代码示范:
package Demo; import java.util.List; import java.util.Locale; import java.util.function.Consumer; public class Test1 { public static void main(String[] args) { List<String> list = List.of("张三", "李四", "王五"); System.out.println(list.get(0)); System.out.println(list.get(1)); System.out.println(list.get(2)); System.out.println("-----------------------"); //遍历 for (String s : list) { System.out.println(s); } System.out.println("------------------------"); list.forEach(s-> System.out.println(s)); list.add("maliu"); } }
(未对集合内容进行更改)
(想修改集合内容就会报错)
2.Set接口创建不可变集合
格式: Set.of(数据);
可以进行查询和遍历但是不能修改内容(元素不能出现重复)
3.Map接口创建不可变集合
可以进行查询和遍历但是不能修改内容(元素不能出现重复)
格式: Map.of(数据); (键值对数量最多是10个)
Map.copyOf(Map集合); (没有键值对数量限制, 在JDK10开始出现)
(Map.of()添加10个键值对,没有报错)
(Map.of()添加11个键值对,直接报错)
Map.copyOf(Map集合); 的代码示范:
import java.util.HashMap; import java.util.Map; import java.util.function.BiConsumer; public class Test3 { public static void main(String[] args) { Map<String,String> map1 = new HashMap(); map1.put("1","a"); map1.put("2","a"); map1.put("3","a"); map1.put("4","a"); map1.put("5","a"); map1.put("6","a"); map1.put("7","a"); map1.put("8","a"); map1.put("9","a"); map1.put("10","a"); map1.put("11","a"); map1.put("12","a"); Map<String,String> map2 = Map.copyOf(map1); map2.forEach((s, s2)-> System.out.println(s+"="+s2)); //map2.put("13","a"); } }结果展示:
二.Stream流
作用: 结合了lambda表达式,简化集合,数组的操作
步骤:
(1)先得到一条Stream流,并把数据放上去
(2)利用Stream流中的API进行各种操作(过滤,转换(中间方法: 方法调用后还可以调用其他方法), 统计, 打印(终结方法: 最后一步, 调用完毕之后, 不能调用其他方法))
1.如何获取Stream流?
获取方式 方法名 说明
单列集合 default Stream<E> stream0 Collection中的默认方法
双列集合 无 无法直接使用stream流
数组 public static <T> Stream<T> stream(T[ ] array) Arrays工具类中的静态方法
一堆零散数据 public static<T> Stream<T> of(T... values) stream接口中的静态方法单列集合获取Stream流代码示范:
import java.util.ArrayList; import java.util.Collections; public class StreamDemo1 { public static void main(String[] args) { ArrayList<String> arr = new ArrayList<>(); Collections.addAll(arr,"b","c","a"); arr.stream().forEach(s -> System.out.println(s));//遍历集合 } }结果展示:
双列集合获取Stream流代码示范:
import java.util.HashMap; public class StreamDemo2 { public static void main(String[] args) { HashMap<String,Integer> map = new HashMap<>(); map.put("a",1); map.put("b",2); map.put("c",3); //第一种方式 map.keySet().forEach(s -> System.out.println(s)); System.out.println("---------------------------"); //第二种方式 map.entrySet().forEach(a-> System.out.println(a)); } }结果展示:
数组获取Stream流代码示范:
import java.util.Arrays; public class StreamDemo3 { public static void main(String[] args) { int[] arr = {1,2,3,4,5,6,7}; Arrays.stream(arr).forEach(i-> System.out.println(i)); } }结果展示:
一堆零散数据获取Stream流代码示范:
import java.util.stream.Stream; public class StreamDemo4 { public static void main(String[] args) { Stream.of(1,2,3,4,5).forEach(i-> System.out.print(i+" ")); System.out.println(); System.out.println("-----------------"); Stream.of("a","b","c").forEach(s-> System.out.print(s+" ")); String[] s = {"a","b","c","d"}; Stream.of(s).forEach(a-> System.out.print(a+" ")); System.out.println(); int[] arr1 = {1,2,3,4,5,6}; Stream.of(arr1).forEach(i-> System.out.print(i+" ")); } }结果展示:
注意: Stream.of() ()中添加元素是类型要相同, 添加数组时只能添加引用数据类型,如果添加基本数据类型打印的是地址
2.Stream流的中间方法
名称 说明
Stream<T> filter(Predicate<? super T> predicate) 过滤
Stream<T> limit(long maxSize) 获取前几个元素
Stream<T> skip(long n) 跳过前几个元素
Stream<T> distinct() 元素去重，依赖(hashCode和equals方法)
static <T> Stream<T> concat(Stream a, Stream b) 合并a和b两个流为一个流Stream<R> map(Function<T,R> mapper) 转换流中的数据类型
注意1:中间方法，返回新的Stream流，原来的Stream流只能使用一次，所以没有必要创建一个新的变量来存储, 建议使用链式编程注意2:修改Stream流中的数据，不会影响原来集合或者数组中的数据
代码示范:
import java.util.ArrayList; import java.util.Collections; import java.util.function.Function; import java.util.function.Predicate; import java.util.stream.Stream; public class StreamDemo5 { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); Collections.addAll(list,"小明","小红","小李飞刀","小张","刘备","马超","黄忠"); //1.filter list.stream(). /*filter(new Predicate<String>() { @Override public boolean test(String s) { return s.startsWith("小"); } })*/ filter(s-> s.startsWith("小"))//true表示留下, false表示舍弃 .forEach(s-> System.out.println(s)); System.out.println("======================"); //2.limit list.stream() .limit(3) .forEach(s-> System.out.println(s)); System.out.println("======================"); //3.skip list.stream() .skip(2) .forEach(s -> System.out.println(s)); System.out.println("======================"); //4.distinct ArrayList<String> list2 = new ArrayList<>(); Collections.addAll(list2,"李华","王五"); Stream.concat(list.stream(),list2.stream()).forEach(s-> System.out.println(s)); System.out.println("======================"); //5.map ArrayList<String> list3 = new ArrayList<>(); Collections.addAll(list3,"小华-12","小五-13","马六-14"); //第一个是原本的数据类型, //第二个要转化成的数据类型 list3.stream() /* .map(new Function<String, Integer>() { @Override public Integer apply(String s) { String[] str = s.split("-"); String ageString = str[1]; int age = Integer.parseInt(ageString); return age; } })*/ .map(s->Integer.parseInt(s.split("-")[1])) .forEach(s-> System.out.println(s)); } }3.Stream流终结方法
名称 说明
void forEach(Consumer action) 遍历
long count() 统计
toArray() 收集流中的数据，放到数组中
collect(Collector collector) 收集流中的数据，放到集合中前三个方法的代码示范:
import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.function.IntFunction; public class Test1 { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); Collections.addAll(list,"asd","zxc","qwe"); //1.forEach(Consumer action) list.stream().forEach(s -> System.out.println(s)); //2.count() long count1 = list.stream().count(); System.out.println(count1); //3.toArray() //转化成什么类型的数组 String[] str = list.stream().toArray(new IntFunction<String[]>() { @Override public String[] apply(int value) { return new String[value]; } }); System.out.println(Arrays.toString(str)); //简化写法 String[] str1 = list.stream().toArray(value -> new String[value]); System.out.println(Arrays.toString(str)); } }结果展示:
三.方法引用
1.引用方法必须是函数式接口
2.被引用的方法必须已经存在
3.被引用方法的形参和返回值需要和抽象方法保持一致
4.被引用的方法的功能要满足当前需求
5. :: 是方法引用符
代码示范:
import java.util.ArrayList; import java.util.Arrays; import java.util.Comparator; public class Test1 { public static void main(String[] args) { Integer[] arr = {1,4,7,2,6,3,5}; //将数组从大到小排序 //1.匿名内部类 /* Arrays.sort(arr, new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return o2-o1; } });*/ //2.lambda表达式 /*Arrays.sort(arr,(o1, o2)-> o2-o1);*/ //3.方法引用 //::方法引用符 Arrays.sort(arr,Test1::subtraction); System.out.println(Arrays.toString(arr)); } public static int subtraction(int num1,int num2){ return num2-num1; } }结果展示:
1.引用静态方法
格式: 类名::静态方法
例如: Integer::parseInt
代码示范:
import java.util.ArrayList; import java.util.Collections; import java.util.function.Function; public class Test2 { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); Collections.addAll(list,"1","2","3","4","5"); /*list.stream().map(new Function<String, Integer>() { @Override public Integer apply(String s) { Integer i = Integer.parseInt(s); return i; } }).forEach(s-> System.out.println(s));*/ list.stream() .map(Integer::parseInt) .forEach(s-> System.out.println(s)); } }结果展示:
2.引用成员方法
格式: 对象::成员方法
(1)其他类: 其他类对象::方法名
(2)本类: this::方法名 (引用处不能是静态方法)
(3)父类: super::方法名 (引用处不能是静态方法)
代码示范: 第一个是类的代码,第二个是测试代码
public class Demo1 { public static boolean stringJudge(String s){ return s.startsWith("小")&&s.length()==2; } }import java.util.ArrayList; import java.util.Collections; import java.util.function.Predicate; public class Test3 { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); Collections.addAll(list,"小明","小红","小张","小李飞刀","张三","李四"); //普通 list.stream().filter(new Predicate<String>() { @Override public boolean test(String s) { return s.startsWith("小")&&s.length()==2; } }).forEach(s-> System.out.println(s)); System.out.println("========================="); //简化 list.stream() .filter(s->s.startsWith("小")&&s.length()==2) .forEach(s-> System.out.println(s)); System.out.println("========================="); //方法引用 list.stream() .filter(Demo1::stringJudge) .forEach(s-> System.out.println(s)); } }结果展示:
3.引用结构方法
格式: 类名::new
例如: Student::new
代码示范: 第一个是Student类的代码,第二个是测试类的代码
public class Student { private String name; private int age; public Student() { } //str是stream流中的数据 public Student(String str) { String[] arr = str.split(","); this.name = arr[0]; this.age = Integer.parseInt(arr[1]); } public Student(String name, int aeg) { this.name = name; this.age = aeg; } /** * 获取 * @return name */ public String getName() { return name; } /** * 设置 * @param name */ public void setName(String name) { this.name = name; } /** * 获取 * @return aeg */ public int getAge() { return age; } /** * 设置 * @param age */ public void setAge(int age) { this.age = age; } public String toString() { return "Student{name = " + name + ", aeg = " + age + "}"; } }import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.function.Function; import java.util.stream.Collectors; public class Test4 { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); Collections.addAll(list,"小明,18","小红,19","小张,20","小李飞刀,21","张三,22","李四,23"); //封装成Student对象并收集到List集合中 //普通方法 List<Student> newList = list.stream().map(new Function<String, Student>() { @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); System.out.println("=========================="); //引用构造方法 List<Student> newList2 = list.stream() .map(Student::new) .collect(Collectors.toList()); System.out.println(newList2); } }结果展示:
4.使用类名引用成员方法
格式: 类名::成员方法
例如: String::substring
注意: 被引用的方法形参是跟抽象方法第二个参数后面的保持一致
代码示范:
import java.util.ArrayList; import java.util.Collections; import java.util.function.Function; public class Test5 { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); Collections.addAll(list,"aaa","bbb","ccc"); //把数据变成大写然后遍历 //普通 list.stream().map(new Function<String, String>() { @Override public String apply(String s) { return s.toUpperCase(); } }).forEach(s-> System.out.println(s)); System.out.println("=========================="); //引用方法 list.stream() .map(String::toUpperCase) .forEach(s-> System.out.println(s)); } }结果展示:
5.引用数组的构造方法
格式: 数据类型[ ]::new
例如: Integer::new
注意: 数组的类型,需要跟流中数组的类型保持一致
代码示范:
import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.function.IntFunction; public class Test6 { public static void main(String[] args) { ArrayList<Integer> list = new ArrayList<>(); Collections.addAll(list,1,2,3,4,5,6); //普通写法 Integer[] arr1 = list.stream().toArray(new IntFunction<Integer[]>() { @Override public Integer[] apply(int value) { return new Integer[value]; } }); //引用方法 Integer[] arr2 = list.stream().toArray(Integer[]::new); System.out.println(Arrays.toString(arr1)); System.out.println("==================="); System.out.println(Arrays.toString(arr2)); } }结果示范:
![[附源码]JAVA毕业设计健身房管理系统（系统+LW）](https://img-blog.csdnimg.cn/72ae97653c3b415eb583fdb573396e84.png)
