模块23回顾:
1.网编:
a.概述:在网络通信协议下,不同计算机上运行的程序
b.软件架构: cs bs(java主要从事bs开发)
c.服务器:安装了服务器软件的计算机
d.通信三要素: IP地址 协议 端口号
e.协议:
UDP:面向无连接协议
TCP:面向连接协议 -> 三次握手 四次挥手
f.UDP: DatagramSocket DatagramPacket
send(dp) receive(dp)
TCP: Socket ServerSocket
getInputStream getOutputStream accept
2.正则表达式:是一个具有特殊规则的字符串,用于校验
a.boolean matches(正则)
b.字符类:[abc] [0-9]
c.逻辑运算符: && |
d.预定义字符: . \\d \\w
e.数量词: x* x+ x? x{n} x{n,} x{n,m}
f.分组括号: ()
3.设计模式
a.模版方法:在一个通用的骨架中,一部分功能确定,一部分功能不确定(延伸到子类中实现)
b.单例模式:目的:让一个类只产生一个对象
饿汉式
懒汉式
4.Lombok:简化javabean
@Data
模块24重点:
Lambda表达式
Stream流
第一章.Lambda表达式
1.函数式编程思想和Lambda表达式定义格式
1.面向对象思想:是Java的核心编程思想
强调的是找对象,帮我们做事儿
比如:去北京 -> 强调的是怎么去,火车,高铁,飞机,汽车,自行车,腿儿
2.jdk8开始又了个新的思想:函数式编程思想:
强调的是结果,不强调过程
比如:去北京 -> 只强调去了还是没去
3.Lambda表达式:
a.定义格式:
()->{}
b.各部分解释:
() : 重写方法的参数位置
-> : 将参数传递到方法体中
{} : 重写方法的方法体
public class Demo01Lambda {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("我执行了");
}
}).start();
System.out.println("============");
new Thread(()-> System.out.println("我执行了")).start();
ArrayList<String> list = new ArrayList<>();
}
}
2.Lambda表达式使用前提
1.必须是函数式接口做方法参数传递
2.啥叫函数式接口:
有且只有一个抽象方法的接口,用@FunctionalInterface去检测
@FunctionalInterface
public interface USB {
void open();
}
3.Lambda表达式省略规则
1.Lambda表达式怎么写(涛哥给的新手秘籍)
a.观察是否是函数式接口做方法参数传递
b.如果是,考虑使用Lambda表达式
c.调用方法,以匿名内部类的形式传递实参
d.从new接口开始到重写方法的方法名结束,选中,删除,别忘记再删除一个右半个大括号
e.在重写方法的参数后面,方法体的大括号前面加上 ->
2.省略规则:
a.重写方法的参数类型可以干掉
b.如果重写方法只有一个参数,所在的小括号可以干掉
c.如果方法体中只有一句话,那么所在的大括号以及分号可以干掉
d.如果方法体中只有一句话并且带return的,那么所在的大括号,分号以及return 可以干掉
public class Person {
private String name;
private Integer age;
public Person() {
}
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class Demo03Lambda {
public static void main(String[] args) {
ArrayList<Person> list = new ArrayList<>();
list.add(new Person("张三",10));
list.add(new Person("李四",8));
list.add(new Person("王五",9));
/* Collections.sort(list, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o1.getAge()-o2.getAge();
}
});
*/
System.out.println("=============Lambda==========");
/* Collections.sort(list,(Person o1, Person o2)-> {
return o1.getAge()-o2.getAge();
});*/
System.out.println("===========Lambda表达式简化形式==========");
Collections.sort(list,(o1, o2)-> o1.getAge()-o2.getAge());
System.out.println(list);
}
}
第二章.函数式接口
1.函数式接口:
有且只有一个抽象方法的接口
2.检测:
@FunctionalInterface
@FunctionalInterface
public interface USB {
void open(String s);
//void close();
}
public class Test01 {
public static void main(String[] args) {
method(new USB() {
@Override
public void open(String s) {
System.out.println(s+"开启了");
}
});
System.out.println("=====Lambda====");
method((String s)->{
System.out.println(s+"开启了");
});
System.out.println("=====Lambda简化版====");
method(s-> System.out.println(s+"开启了"));
}
public static void method(USB usb){
usb.open("鼠标");
}
}
1.Supplier
1.Supplier接口
java.util.function.Supplier<T>接口,它意味着"供给"->我们想要什么就给什么
2.方法:
T get() -> 我们想要什么,get方法就可以返回什么
3.需求:
使用Supplier接口作为方法的参数
用Lambda表达式求出int数组中的最大值
4.泛型:
<引用数据类型>-> 规定了我们操作的数据是什么类型
<>中只能写引用数据类型,不能写基本数据类型
基本类型 | 包装类 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
public class Demo01Supplier {
public static void main(String[] args) {
method(new Supplier<Integer>() {
@Override
public Integer get() {
int[] arr = {4,3,4,6,7};
Arrays.sort(arr);
return arr[arr.length-1];
}
});
System.out.println("==================");
method(()-> {
int[] arr = {4,3,4,6,7};
Arrays.sort(arr);
return arr[arr.length-1];
});
}
public static void method(Supplier<Integer> supplier){
Integer max = supplier.get();//让get方法返回一个数组最大值
System.out.println("max = " + max);
}
}
2.Consumer
java.util.function.Consumer<T>->消费型接口->操作
方法:
void accept(T t),意为消费一个指定泛型的数据
"消费"就是"操作",至于怎么操作,就看重写accept方法之后,方法体怎么写了
public class Demo02Consumer {
public static void main(String[] args) {
method(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s.length());
}
},"abcdefg");
System.out.println("==================");
method(s-> System.out.println(s.length()),"abcdefg");
}
public static void method(Consumer<String> consumer,String s){
consumer.accept(s);
}
3.Function
java.util.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据
方法:
R apply(T t)根据类型T参数获取类型R的结果
public class Demo03Function {
public static void main(String[] args) {
method(new Function<Integer, String>() {
@Override
public String apply(Integer integer) {
return integer+"";
}
},100);
System.out.println("===================");
method(integer -> integer+"",200);
}
public static void method(Function<Integer,String> function,Integer number){
String s = function.apply(number);
System.out.println("s = " + (s+1));
}
}
4.Predicate
java.util.function.Predicate<T>接口。->判断型接口
boolean test(T t)->用于判断的方法,返回值为boolean型
public class Demo04Predicate {
public static void main(String[] args) {