unit4 网络协议
1.协议：
软件结构：C/S（Client、Service，客户端访问） B/S（Browser、Service，浏览器访问）
网络通信协议：
TCP/IP协议：传输控制协议/因特网互联协议（transmission control protocol / Internet protocol），内部处理通信协议，采用4层分层结构
客户端向服务器发出连接请求，每次连接都要经过三次握手：
UDP协议：用户数据报协议（User Datagram Protocol），无连接通信协议，不建立通信连接
2.IP地址：电脑的唯一标识，互联网协议地址，IPv4，IPv6，查看本机地址（ipconfig），检查是否可以互联（ping 对方IP地址）
端口号：打开一个软件，OS会给此网络分配一个随机的或者特定的端口号，由2个字节组成的
80端口：网络端口 mysql：3306 oracle：1521 Tomcat：8080
4.TCP通信：
Socket类：java.net.Socket 包含了IP地址和端口号的网络单位
构造方法：Socket（String host，int port）
成员方法：OutputStream getOutputStream（）返回套接字输出流
InputStream getInputStream（）返回套接字输入流
void close（）关闭套接字
ServerSocket类：java.net.ServerSocket
构造方法：ServerSocket（int port）
成员方法：Socket accept（）侦听并接受此套接字的连接
实现步骤类似上面~~~~
TCPClient：
public static void main(String[] args) throws IOException {
//创建客户端对象Socket
Socket socket = new Socket("192.168.1.101",8888);
//获取字节输出流对象
OutputStream os = socket.getOutputStream();
//使用write方法给服务器发送数据
os.write("你好服务器".getBytes());
InputStream is = socket.getInputStream();
byte[] bytes = new byte[1024];
int len = is.read(bytes);
System.out.println(new String(bytes,0,len));
socket.close();
//error:java.net.ConnectException: Connection refused: connect
}
TCPServer：
public static void main(String[] args) throws IOException {
//创建服务器ServerSocket对象和系统要指定的端口号
ServerSocket server = new ServerSocket(8888);
//accept方法，获取socket对象
Socket socket = server.accept();
//getInputStream方法获取网络字节输入流InputStream对象
InputStream is = socket.getInputStream();
//read读取数据
byte[] bytes = new byte[1024];
int len = is.read(bytes);
System.out.println(new String(bytes,0,len));
//getOutputStream获取网络字节输出流对象
OutputStream os = socket.getOutputStream();
//write给客户端回写数据
os.write("收到谢谢".getBytes());
socket.close();
server.close();
}
ps:先运行Server端，再运行Client端，在Client显示“收到谢谢”，在Server显示“你好服务器”
例子，本地文件上传：
5.BS服务器：
客户端IE浏览器（socket）-----访问服务器（Serversocket）------读取客户端请求的内容：
访问服务器的代码：
public static void main(String[] args) throws IOException {
ServerSocket server = new ServerSocket(8080);
Socket socket = server.accept();
InputStream is = socket.getInputStream();
byte[] bytes = new byte[1024];
int len = 0;
while ((len = is.read(bytes)) != -1){
System.out.println(new String(bytes,0,len));
}
}
客户端IE浏览器：
http://192.168.1.101:8080/demo22/web/index.html
读取客户端请求的内容：在控制台显示
GET /demo22/web/index.html HTTP/1.1
Host: 192.168.1.101:8080
Connection: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.81 Safari/537.36 SE 2.X MetaSr 1.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
6.函数式接口：有且只有一个抽象方法的接口
LambdaInterface：
@FunctionalInterface
//检测接口是否是函数接口，有且只有一个
LambdaImplement：
LambdaImpl implements LambdaInterface
LambdaTest：
//定义一个方法，参数使用函数式接口
public static void show(LambdaInterface li ){
li.method();
}
psvm{
//Lambda表达式，调用show方法
show(()->{
System.out.println("匿名内部类重写方法接口");
});
}
函数式接口作为方法参数：函数式接口（Runnable run）
package demo23;
public abstract class RunnableTest {
//定义一个方法startThread，参数使用函数式接口Runnable
public static void startThread(Runnable run){
//开启多线程
new Thread((java.lang.Runnable) run).start();
}
public static void main(String[] args) {
//调用方法，参数是一个接口，我们可以传递此接口的匿名内部类
startThread(new Runnable(){
@Override
public void run(){
System.out.println(Thread.currentThread().getName()
+"-->"+"线程启动了");
}
});
//调用方法，参数是一个函数式接口，我们可以传递Lambda表达式，
// 节省了匿名内部类的书写
startThread(()->{
System.out.println(Thread.currentThread().getName()
+"-->"+"线程启动了");
});
}
}
函数式接口作为方法返回值：
//排序器
public class ComparatorTest {
public static Comparator<String> getComparator(){
//方法返回值类型是一个接口(函数式接口)的时候
// 可以返回此接口的匿名内部类
return new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
//按照字符串降序排序
return o2.length()-o1.length();
}
};
//也可以是：当方法返回值类型是一个函数式接口的时候，
// 我们可以返回一个Lambda表达式
// return (String o1,String o2)->{
// return o2.length()-o1.length();
// };
}
}
7.常用的函数式接口：
Supplier<T>接口：生产型接口 T get（）
//方法参数传递Supplier接口，泛型使用Integer
public static int getMax(Supplier<Integer> sup){
return sup.get();
}
Consumer<T>接口：消费型接口 T accept（） andThen（），组合两个接口
public static void method(String name, Consumer<String> con){
con.accept(name);
}
---------------------------------------------------------------
//定义一个方法，参数传递一个字符串和两个Consumer接口，接口泛型是字符串
public static void method
(String s, Consumer<String> con1,Consumer<String> con2){
con1.accept(s);
con2.accept(s);
//con1连接con2,先后消费执行
con1.andThen(con2).accept(s);
}
public static void main(String[] args) {
//调用method方法，传递一个字符串，两个Lambda表达式
method("hello",
(t)->{//转换成大写
System.out.println(t.toUpperCase()); },
(t)->{//转换成小写
System.out.println(t.toLowerCase()); });
}
Predicate<T>接口：判断数据类型接口 boolean test ( T t )
public static boolean checkString
(String s, Predicate<String> pre){
return pre.test(s);
}
---------------------------------------------------
String s = "sjw";
boolean b = checkString(s, (String str) -> {
return str.length() > 5;//长度是否大于5
});
System.out.println(b);
Function<T,R>接口：转换型接口
R reply（T t ）,T转换为R
andThen() ，类似于Consumer里面的，先做什么后做什么，进行组合操作
public static void change(String s, Function<String ,Integer> fun){
Integer in = fun.apply(s);
//Integer改成为int时候，是自动拆箱过程
System.out.println(in);
}
------------------------------------------------
String s = "124";
change(s,(String str)->{
//把String类型转换成Integer类型
return Integer.parseInt(str);
});
unit5 Stream流
1.定义：I/O流用于读写，Stream流用于集合和数组的转化型读写
例子：集合遍历
list.stream().filter(name->name.startsWith("s"))
.filter(name->name.length()==3)
.forEach(name-> System.out.println(name));
2. 流式思想：过滤---》映射---》跳过---》计数，只有在计数count时候，模型才开始操作
元素是特定类型对象，按需计算，所以不会存储所有ALL
3.获取流：java.util.stream.Stream<T>
Map<String,String> map = new HashMap<>();
Set<String> keySet = map.keySet();//获取键
Stream<String> s3 = keySet.stream();
Collection<String> valueSet = map.values();//获取值
Stream<String> s4 = valueSet.stream();
Set<Map.Entry<String, String>> entries = map.entrySet();//获取键值对映射关系
Stream<Map.Entry<String, String>> s5 = entries.stream();
//数组转换成stream流
Stream<Integer> s6 = Stream.of(1,2,3);
//可变参数传递数组
Integer[] arr1 = {1,2,3};
Stream<Integer> s7 = Stream.of(arr1);
String[] arr2 = {"a","bb"};
Stream<String> s8 = Stream.of(arr2);
4.流的常用方法：
//forEach方法，遍历流的数据，是终结方法，遍历后不能调用其他的方法了
Stream<String> stream = Stream.of("sjw", "only");//获取流
stream.forEach((String name)->{
System.out.println(name);
});//foeEach方法进行遍历
//stream.forEach((name)->{sout(name)}); 同理的
-----------------------------------------------------
//filter方法过滤
Stream<String> stream1 = Stream.of("林子", "爽");//获取流
stream1.filter((String name)->{
return name.startsWith("林");
});//filter元素过滤
stream1.forEach((name)->{
System.out.println(name);});
//error:stream has already been operated upon or closed
//stream是管道流，只可以被消费一次
映射方法map：转换数据类型，类似于apply()
Stream<String> stream = Stream.of("11", "22");//获取流
Stream<Integer> stream1 = stream.map((String s) -> {
return Integer.parseInt(s);
});//map方法，将string转换成integer
stream1.forEach(i-> System.out.println(i));//遍历
统计个数方法count：返回long类型，终结方法
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
Stream<Integer> stream2 = list.stream();//数组转换成stream流
System.out.println(stream2.count());
取用前n个方法limit：截取方法，long类型整数，延迟方法可以调用其他方法
Stream<String> stream3 = Stream.of("11", "22");//获取流
Stream<String> stream4 = stream3.limit(2);
stream4.forEach(name-> System.out.println(name));
跳过前几个方法skip：
tream<String> stream5 = Stream.of("11", "22");//获取流
Stream<String> stream6 = stream5.skip(1);//跳过
stream6.forEach(name-> System.out.println(name));
组合方法concat：参数传递两个流合并成为一个流，静态方法
Stream<String> stream1 = Stream.of("11", "22","33");//获取流
Stream<String> stream2 = Stream.of("sjw", "linzi","shuang");//获取流
Stream<String> stream3 = Stream.concat(stream1,stream2);//合并
stream3.forEach(name-> System.out.println(name));