A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 沃土乐也强了 初级黑马   /  2018-12-2 16:27  /  705 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

day11
网络编程基础
C/S结构:
        全称为Client/Server结构, 是指 客户端 和 服务器 结构
        常见程序有QQ, 迅雷等软件
B/S结构:
        全称为Browser/Server结构, 是指 浏览器 和 服务器 结构
        常见浏览器有IE, 谷歌, 火狐等
网络通信协议
网络通信协议:
        通信协议是计算机必须遵守的规则, 只有遵守这些规则, 计算机之间才能进行通信.
        协议中对数据的传输格式, 传输速率, 传输步骤等做了统一规定, 通信双方必须同时遵守, 最终完成数据交换
UDP: User Datagram Protocol, 用户数据报协议
        特点:
                1. 无连接的不可靠协议
                2. 数据按包发送, 64K一个包
                3. 速度快效率高, 容易丢包
        用于视频直播, 网络电话

TCP: Transmission Control Protocol, 传输控制协议
        特点:
                1. 需要建立连接的可靠协议  电话
                2. 数据传输无大小限制
                3. 速度慢效率低   重发机制
        用于文件下载, 浏览网页

网络编程三要素: IP地址
网络编程三要素:
        1. 通信协议  TCP
        2. IP地址
        3. 端口号
网络三要素: 端口号
端口号: 计算机中进程的唯一标识
        端口号的取值范围: 0~65535的整数, 其中0~1024不建议使用
TCP通信
java.net.ServerSocket类: TCP服务端
        // 构造方法
        ServerSocket(int port): 创建一个TCP服务端, 并监听指定端口
        // 成员方法
        Socket accept(): 监听数据, 会阻塞. 收到数据后返回Socket对象
        void close(): 关闭服务端ServerSocket
java.net.Socket类: TCP客户端
        // 构造方法
        Socket(String ip, int port): 创建TCP客户端对象
        // 成员方法
        OutputStream getOutputStream(): 获取输出流对象, 用于发送数据
        InputStream getInputStream(): 获取输入流, 用于接收数据
        void shutdownOutput(): 关闭输出流, 发送结束标记
        void close(): 关闭客户端Socket
TCP程序: 客户端代码实现
java.net.Socket类: TCP客户端
        // 构造方法
        Socket(String 服务端ip, int 服务端port): 创建TCP客户端对象, 同时尝试连接到指定的服务端
                (客户端也会获取系统随机分配的一个端口号)
        // 成员方法
        OutputStream getOutputStream(): 获取输出流对象, 用于发送数据
        InputStream getInputStream(): 获取输入流, 用于接收数据
        void shutdownOutput(): 关闭输出流, 告知服务端数据发送完毕, 结束标记-1
        void close(): 关闭客户端Socket, 告知服务端数据发送完毕
实现步骤:
        1.创建一个客户端对象 Socket, 构造方法传入服务器的IP地址和端口号
        2.使用Socket对象中的方法 getOutputStream() 获取网络字节输出流OutputStream对象
        3.使用网络字节输出流OutputStream对象中的方法 write(), 给服务器发送数据
        4.使用Socket对象中的方法 getInputStream() 获取网络字节输入流InputStream对象
        5.使用网络字节输入流InputStream对象中的方法 read(), 读取服务器回写的数据
        6.释放资源(Socket)
注意:
        1.客户端和服务器端进行交互, 必须使用Socket中提供的网络流, 不能使用自己创建的流对象
        2.当我们创建客户端对象Socket的时候, 就会去请求服务器和服务器经过3次握手建立连接通路
                这时如果服务器没有启动, 那么就会抛出异常ConnectException: Connection refused: connect
                如果服务器已经启动, 那么就可以进行交互了
        // 创建客户端Socket对象, 指定要连接的服务端的IP和端口号
        Socket socket = new Socket("127.0.0.1", 8888);
        // 向服务端发送数据
        OutputStream os = socket.getOutputStream();
        os.write("你好服务器".getBytes());
        // 释放资源
        socket.close();
TCP程序: 服务器端代码实现
java.net.ServerSocket类: TCP服务端
        // 构造方法
        ServerSocket(int 服务端自己用的port): 创建一个TCP服务端, 并监听指定端口
        // 成员方法
        Socket accept(): 等待客户端连接, 会阻塞. 客户端连接后返回客户端的Socket对象
        void close(): 关闭服务端ServerSocket, 断开所有流
服务器的实现步骤:
        1.创建服务器ServerSocket对象并指定服务器占用的端口号
        2.使用ServerSocket对象中的方法 accept(), 获取到请求的客户端对象Socket
        3.使用Socket对象中的方法 getInputStream() 获取网络字节输入流InputStream对象
        4.使用网络字节输入流InputStream对象中的方法 read(), 读取客户端发送的数据
        5.使用Socket对象中的方法 getOutputStream() 获取网络字节输出流OutputStream对象
        6.使用网络字节输出流OutputStream对象中的方法 write(), 给客户端回写数据
        7.释放资源(Socket,ServerSocket)
        // 创建服务端ServerSocket对象, 并指定自己监听的端口
        ServerSocket server = new ServerSocket(8888);
        // 调用accept方法等待客户端连接
        Socket socket = server.accept();
        // 通过客户端获取输入流, 读取客户端发来的数据
        InputStream is = socket.getInputStream();
        byte[] bytes = new byte[1024];
        int len = is.read(bytes);
        System.out.println(new String(bytes, 0, len));
        // 通过客户端获取输出流, 向客户端回写数据
        OutputStream os = socket.getOutputStream();
        os.write("收到谢谢".getBytes());
        // 释放资源
        socket.close();
        // server.close();  // 客户端一般不关闭
day12


函数式接口:是JDK1.8之后的新特性。特点是有且仅有一个抽象方法的接口。
在接口上使用@FunctionlInterface可以检查接口是不是函数式接口。
// 示例
@FunctionalInterface
public interface MyFunctionalInterface {
    void method();
}
函数式接口的使用
函数式接口有三种使用方式:
   作为方法的参数类型, 传递Lambda表达式, 代替匿名内部类方式
使用Lambda延迟执行可以优化代码:
     传递Lambda对象, 只有当符合执行条件时, 才会执行代码
常用函数式接口
Supplier生产型函数式接口

java.util.function.Supplier<T>函数式接口: 生产型函数式接口
        // 抽象方法
         T get(): 用于获取一个对象或值.
Consumer消费型函数式接口
java.util.function.Consumer<T>函数式接口: 消费型函数式接口
        // 默认方法
        default Consumer<T> andThen(Consumer<? super T> after): 拼接两个Consumer接口的Lambda对象实现连续操作. 谁写前面, 谁先消费

Predicate条件判断函数式接口
java.util.function.Predicate<T>函数式接口: 条件接口, 用于判断
        // 抽象方法
        boolean test(T t): 判断参数传递的对象. 至于怎么判断, 判断什么, 需要我们编写Lambda表达式实现
        // 默认方法 (用于连接多个判断条件)
        default Predicate<T> and(Predicate<? super T> other): 与 &&
        default Predicate<T> or(Predicate<? super T> other): 或  ||
        default Predicate<T> negate(): 非, 取相反结果   !

Function转换型函数式接口: 使用Function连续转换
[Java] 纯文本查看 复制代码
public class Test {[/b]
    // 方法作用: 按照步骤将字符串转换
    // 参数: 被转换的字符串, 转换方式1, 转换方式2, 转换方式3
    public static int change(String s, Function<String, String> fun1, Function<String, Integer> fun2, Function<Integer, Integer> fun3) {
        return fun1.andThen(fun2).andThen(fun3).apply(s);
    }

    public static void main(String[] args) {
        String str = "赵丽颖,20";

        // 匿名内部类方式
        int num1 = change(
                str,
                new Function<String, String>() {  // 将字符串截取数字年龄部分, 得到字符串
                    @Override
                    public String apply(String s) {
                        return s.split(",")[1];
                    }
                },
                new Function<String, Integer>() {  // 将上一步的字符串转换成为int类型的数字
                    @Override
                    public Integer apply(String s) {
                        return Integer.parseInt(s);
                    }
                },
                new Function<Integer, Integer>() { // 将上一步的int数字累加100, 得到结果int数字
                    @Override
                    public Integer apply(Integer integer) {
                        return integer + 100;
                    }
                }
        );
        System.out.println(num1);

        // Lambda方式
        int num2 = change(
                str,
                s -> s.split(",")[1],
                s -> Integer.parseInt(s),
                i -> i + 100
        );
        System.out.println(num2);
    }
}


Day13


Stream流
传统的过滤集合中的元素,很麻烦需要写很多的重复代码。在JDK8中出现了函数式变成思想。关注的是应该做什么,而不是怎样做。
流相比于集合的2个优点:
        1. Pipelining(管道特性): "可以链式调用"
                Stream流对象的 延迟方法 调用后, 会返回新的Stream流对象, 可以链式调用
                每个方法类似于一条一条的管道, 衔接了不同的处理方案
        2. 内部迭代特性: "不用写for循环"
                集合遍历通过 Iterator 或者 增强for, 显式的在集合外部进行迭代, 这叫做外部迭代
                Stream提供了内部迭代的方法 forEach(Consumer c), 可以直接调用遍历方法
使用Stream流的3个步骤:
        1. 获取数据源 (从"集合"或"数组"转换为"Stream"对象)
        2. 数据处理 (调用延迟方法, 编写处理方案)
        3. 获得结果 (调用终结方法, 启动开关)
有两种获取Stream流的方式:
获取Stream流对象的2种方式:
        1. 利用"Collection接口"中的默认方法 default Stream<E> stream() 方法: 集合转Stream对象
        2. 利用"Stream接口"中的静态方法 static <T> Stream<T> of(T... values): 数组转Stream对象

Stream API: 方法分类, forEach()遍历
Filter:
[Java] 纯文本查看 复制代码
package StreamFilterTest;
[/color]
import java.util.stream.Stream;

public class StreamFilter {
    public static void main(String[] args) {
        String[] str= {"张三丰","张翠山","张无忌","赵敏","铁蛋"};
        Stream<String> str1 = Stream.of(str);
        Stream<String> str2 = str1.filter((String name) -> {
            return name.startsWith("张");
        });
        str2.forEach((String name)->{
            System.out.println(name);
        });
        Stream.of("张三丰","张翠山","张无忌","赵敏","铁蛋")
                .filter( name-> name.startsWith("张"))
                .forEach(name->System.out.println(name));
    }
}

map:
[Java] 纯文本查看 复制代码
package StreamMap;

import java.util.stream.Stream;

public class Test {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("1", "2", "3", "4", "5");
        Stream<Integer> stream1 = stream.map( i-> Integer.parseInt(i));
        stream1.forEach(integer->System.out.println(integer));
        Stream.of("1", "2", "3", "4", "5")
                .map(string->Integer.parseInt(string))
                .forEach(i-> System.out.println(i));
    }

}

limit:
[Java] 纯文本查看 复制代码
package StreamLimit;

import java.util.stream.Stream;

public class Test {
    public static void main(String[] args) {
        String[] str= {"铁锤","铁柱","铁球","铁饼","铁蛋"};
        Stream<String> str1 = Stream.of(str);
        Stream<String> limit = str1.limit(2);
        limit.forEach((String name)->{
            System.out.println(name);
        });

        System.out.println("*********");
        Stream.of("铁锤","铁蛋","铁柱")
                .limit(5)//limit(-1)   IllegalArgumentException: -1
                .forEach(name-> System.out.println(name));
        System.out.println("********");
        Stream.of("铁棒","铁球","铁柱")
                .limit(2)
                .skip(1)
                .forEach(name-> System.out.println(name));
    }
}


skip:
[Java] 纯文本查看 复制代码
package StreamSkip;

import java.util.stream.Stream;

public class Test {
    public static void main(String[] args) {
        String[] str= {"琦玉","银时","犬夜叉","三上悠雅","迪迦"};
        Stream<String> stream = Stream.of(str);
        Stream<String> stream1 = stream.skip(3);
        stream1.forEach(name-> System.out.println(name));
        System.out.println("*****************");
        Stream.of(str)
                .skip(4)
                .skip(-1)//返回 IllegalArgumentException: -1
                .skip(9)//返回一个空的流

                .forEach(name-> System.out.println(name));
    }
}







0 个回复

您需要登录后才可以回帖 登录 | 加入黑马