函数式接口
有且仅有一个抽象方法的接口叫函数式接口。
@FunctionInterface注解可以检查该接口是否为函数式接口。
Myinterface in=() -> sout("函数式接口");
函数式接口作为方法的参数
startThread(Runnable r);
public class RunnableDemo {
public static void main(String[] args) {
startThread(()->{
System.out.println(Thread.currentThread().getName());
});
}
public static void startThread(Runnable r){
new Thread(r).start();
}
}
函数式接口作为返回值
public class ComparatorDemo {
public static void main(String[] args) {
ArrayList<String> array=new ArrayList<>();
array.add("aa");
array.add("bbb");
array.add("cccc");
array.add("d");
Collections.sort(array,getComparator());
System.out.println(array);
}
private static Comparator<String> getComparator(){
// return new Comparator<String>() {
// @Override
// public int compare(String s1, String s2) {
// return s1.length()-s2.length();
// }
// };
return (s1,s2)->s1.length()-s2.length();
}
}
Supplier
T get():获取结果
该方法不需要参数,他会按照某种实现逻辑(lambda表达式实现)返回一个数据。
生产型接口,如果指定了接口的泛型是什么数据,接口中的get方法就会生产什么类型的数据。
public class SupplierDemo {
public static void main(String[] args) {
String s = useSupplier(()->"hello");
System.out.println(s);
}
private static String useSupplier(Supplier<String> sup){
return sup.get();
}
}
Consumer
消费型接口,不返回值。
void accept(T t);对给定的参数执行此操作
default Consumer andThen(Consumer after):返回一个组合的Consumer,依次执行此操作,然后执行after操作.
public class ConsumerDemo {
public static void main(String[] args) {
useConsumer("林青霞",s-> System.out.println(s));
}
private static void useConsumer(String s, Consumer<String> c){
c.accept(s);
}
}
--------------------------------
public class ConsumerDemo {
public static void main(String[] args) {
String[] str={"林青霞,30","刘艳,22","张曼玉,20","刘亦菲,23"};
useConsumer(str,s ->{
System.out.print("姓名:"+ s.split(",")[0]);
},(s->{
System.out.println(",年龄:"+s.split(",")[1]);
}));
}
private static void useConsumer(String[] str, Consumer<String> c1,Consumer<String> c2){
for (String s:str) {
c1.andThen(c2).accept(s);
}
}
}
Predicate
boolean test(T t):对给定的参数进行判断,返回一个布尔值
default Predicate nagate():返回一个逻辑否
default Predicate and(Predicate other):返回一个组合判断,与
default Predicate or(Predicate other):返回一个组合判断,非
public class PredicateDemo {
public static void main(String[] args) {
System.out.println(checkString("hello",s->{
return s.length()>9;
}));
}
private static boolean checkString(String s,Predicate<String> p){
return p.test(s);
// return p.negate().test(s);
}
}
-----------------------------------------------
public class PredicateDemo {
public static void main(String[] args) {
String[] str={"张曼玉,35","王祖贤,44","胡歌,35","刘亦菲,24","林青霞,30"};
ArrayList<String> arrayList=uesPredicate(str,s->{
return s.split(",")[0].length()>2;
},s->{
return Integer.parseInt(s.split(",")[1])>34;
});
System.out.println(arrayList);
}
private static ArrayList<String> uesPredicate(String[] str,Predicate<String> p1,Predicate<String> p2){
ArrayList<String> arrayList=new ArrayList<>();
for(String s:str){
if(p1.and(p2).test(s))arrayList.add(s);
}
return arrayList;
}
}
Function
Interface Function
接受一个T类型的参数,得到一个R类型的返回值。
R apply(T t):将此函数应用于给定的参数
default Function addThen(Function after):返回一个组合函数,首先将该函数应用于输入,然后将after函数应用于结果
Function<T,R>接口通常用于对参数进行处理,转换,然后返回新值
public class FunctionTest {
public static void main(String[] args) {
String str="林青霞,30";
useFunction(str,s->{
return Integer.parseInt(s.split(",")[1]);
});
}
private static void useFunction(String s,Function<String,Integer> f1){
System.out.println(f1.apply(s));
}
}
----------------------------------------
public class FunctionTest {
public static void main(String[] args) {
String str="林青霞,30";
useFunction(str,s->{
return Integer.parseInt(s.split(",")[1]);
},i->{
return i+70;
});
}
private static void useFunction(String s,Function<String,Integer> f1,Function<Integer,Integer> f2){
System.out.println(f1.andThen(f2).apply(s));
}
}
Stream流
将字符串进行多个判断时,单个写代码很繁琐,所以出现了Stream流。
生成流->中间操作->终结操作
Collection集合可以使用Stream()生成流:default Stream stream()
Map体系的集合间接生成流
数组可以通过of(T… values)生成流。
public class Streamliu {
public static void main(String[] args) {
ArrayList<String> arrayList=new ArrayList<>();
arrayList.add("张曼玉");
arrayList.add("张敏");
arrayList.add("张全蛋");
arrayList.add("刘亦菲");
//创建Stream流,filter传入Pridicate接口进行判断,forEach传入Consumer接口进行输出
arrayList.stream().filter(s->s.startsWith("张")).filter(s->s.length()>2).forEach(System.out::println);
}
}
list集合生成流
//list集合生成流
List<String> list=new ArrayList<String>();
Stream<String> liststream=list.stream();
set集合生成流
//set集合生成流
Set<String> ss=new HashSet<String>();
Stream<String> ssStream=ss.stream();
map生成流
//map生成流
Map<String,Integer> msi=new HashMap<String,Integer>();
Stream<String> ssmsi=msi.keySet().stream();
Stream<Integer> vmsi=msi.values().stream();
Stream<Map.Entry<String,Integer>> entryStream=msi.entrySet().stream();
string生成流
//string生成流
String[] str={"hello","world","java"};
Stream<String> strStream=Stream.of(str);
Stream<String> str1=Stream.of("hello","world");
Stream<Integer> str2=Stream.of(10,20,30);
Stream流的操作方法
Stream filter(Predicate predicate):用于对流中的数据进行过滤
ArrayList<String> arrayList=new ArrayList<>();
arrayList.add("张曼玉");
arrayList.add("张敏");
arrayList.add("张全蛋");
arrayList.add("刘亦菲");
arrayList.stream().filter(s->{
return s.startsWith("张");
}).forEach(System.out::println);
Stream limit(long maxSize):返回此流中的元素组成的流,截取前指定参数个数的数据
ArrayList<String> arrayList=new ArrayList<>();
arrayList.add("张曼玉");
arrayList.add("张敏");
arrayList.add("张全蛋");
arrayList.add("刘亦菲");
arrayList.stream().limit(3).forEach(System.out::println);
Stream skip(long n);跳过指定参数个数的数据,返回由该流的剩余元素组成的流
ArrayList<String> arrayList=new ArrayList<>();
arrayList.add("张曼玉");
arrayList.add("张敏");
arrayList.add("张全蛋");
arrayList.add("刘亦菲");
arrayList.stream().skip(3).forEach(System.out::println);
Stream sorted();返回排序后的流
Stream sorted(Comparator comparator):根据排序器排序
ArrayList<String> arrayList=new ArrayList<>();
arrayList.add("张曼玉");
arrayList.add("张敏");
arrayList.add("张全蛋");
arrayList.add("刘亦菲");
arrayList.stream().sorted().forEach(System.out::println);
arrayList.stream().sorted((s1,s2)->s1.length()-s2.length()).forEach(System.out::println);
arrayList.stream().sorted((s1,s2)->{
int num=s1.length()-s2.length();
int num2=num==0?s1.compareTo(s2):num;
return num2;
}).forEach(System.out::println);
Stream map(Function mapper):返回由给定函数应用于此流的元素的结果组成的流
ArrayList<String> arrayList=new ArrayList<>();
arrayList.add("40");
arrayList.add("20");
arrayList.add("60");
arrayList.add("10");
arrayList.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);
IntStream mapToInt(ToIntFunction mapper):返回一个IntStream其中包含将给定函数应用于此流的结果
arrayList.stream().mapToInt(s->Integer.parseInt(s)).forEach(System.out::println);
int result = arrayList.stream().mapToInt(Integer::parseInt).sum();
System.out.println(result);
void foreach(Consumer action):对六种的每个元素执行操作
long count():返回此流中的元素数
ArrayList<String> arrayList=new ArrayList<>();
arrayList.add("40");
arrayList.add("20");
arrayList.add("60");
arrayList.add("10");
arrayList.stream().forEach(System.out::println);
例子
ArrayList<String> arrayList1=new ArrayList<>();
ArrayList<String> arrayList2=new ArrayList<>();
arrayList1.add("胡歌");
arrayList1.add("张张张");
arrayList1.add("李纯钢");
arrayList1.add("宋小宝");
arrayList1.add("沙溢");
arrayList1.add("马儿扎哈");
arrayList2.add("迪丽热巴");
arrayList2.add("古力娜扎");
arrayList2.add("柳岩");
arrayList2.add("林小小");
arrayList2.add("王祖贤");
arrayList2.add("林青霞");
Stream<String> str1=arrayList1.stream().filter(s->s.length()==3).limit(3);
Stream<String> str2=arrayList2.stream().filter(s->s.startsWith("林")).skip(1);
Stream<String> concat = Stream.concat(str1, str2);
concat.map(Actor::new).forEach(p->System.out.println(p.getName()));
Stream的收集操作
对数据使用Stream流的方式操作完毕后,收集到集合中
Stream流的收集方法
Rcollect(Collector collector):参数是一个Collector接口
工具类Collectors提供了具体的收集方式
public static Collector toList():把元素收集到List集合中
public static Collector toSet():把元素收集到Set集合中
public static Collector toMap(Function keyMapper,Function valueMapper):把元素收集到Map集合中
List集合
List<String> List1=new ArrayList<>();
List<String> List2=new ArrayList<>();
List1.add("林青霞");
List1.add("张曼玉");
List1.add("刘艳");
List1.add("王祖贤");
Stream<String> str=List1.stream().filter(s->s.length()>2);
List<String> collect = str.collect(Collectors.toList());
for(String s:collect){
System.out.println(s);
}
set集合
Set<String> collect = str.collect(Collectors.toSet());
for(String s:collect){
System.out.println(s);
}
map集合
String[] str={"周慧敏,20","张曼玉,25","林青霞,30","王祖贤,33"};
Stream<String> strStream=Stream.of(str).filter(s->Integer.parseInt(s.split(",")[1])>29);
Map<String,Integer> str1Stream=strStream.collect(Collectors.toMap((s->s.split(",")[0]), s->Integer.parseInt(s.split(",")[1])));
Set<String> keyset=str1Stream.keySet();
for(String s:keyset){
int valule=str1Stream.get(s);
System.out.println(s+","+valule);
}