[网络协议]网络编程、正则表达式

网络编程、正则表达式

1. 网络编程

1.1 概述

?Java是 Internet 上的语言，它从语言级上提供了对网络应用程 序的支持，程序员能够很容易开发常见的网络应用程序。
Java提供的网络类库，可以实现无痛的网络连接，联网的底层 细节被隐藏在 Java 的本机安装系统里，由 JVM 进行控制。并 且 Java 实现了一个跨平台的网络库，程序员面对的是一个统一 的网络编程环境。

1.2 网络通信

1.2.1 通信之IP地址

通信双方地址
a)IP
b)端口号
一定的规则（即：网络通信协议。有两套参考模型）
c)OSI参考模型：模型过于理想化，未能在因特网上进行广泛推广
d)TCP/IP参考模型(或TCP/IP协议)：事实上的国际标准。
2.1.通信要素1：IP地址
?IP 地址：InetAddress
?唯一的标识 Internet 上的计算机（通信实体）
?本地回环地址(hostAddress)：127.0.0.1 主机名(hostName)：localhost
?IP地址分类方式1：IPV4 和 IPV6
?IPV4：4个字节组成，4个0-255。大概42亿，30亿都在北美，亚洲4亿。2011年初已经用尽。以点分十进制表示，如192.168.0.1
?IPV6：128位（16个字节），写成8个无符号整数，每个整数用四个十六进制位表示， 数之间用冒号（：）分开，如：3ffe:3201:1401:1280:c8ff:fe4d:db39:1984
?IP地址分类方式2：公网地址(万维网使用)和私有地址(局域网使用)。192.168. 开头的就是私有址址，范围即为192.168.0.0–192.168.255.255，专门为组织机 构内部使用
?特点：不易记忆

1.2.2 通信之端口号

1.3 网络协议

1.3.1 TCP

1.3.1.1 概述

1.3.1.2 Scoket

?利用套接字(Socket)开发网络应用程序早已被广泛的采用，以至于成为事实 上的标准。
?网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标 识符套接字。
?通信的两端都要有Socket，是两台机器间通信的端点。
?网络通信其实就是Socket间的通信。
?Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。
?一般主动发起通信的应用程序属客户端，等待通信请求的为服务端。
?Socket分类：
?流套接字（stream socket）：使用TCP提供可依赖的字节流服务数据报套接字（datagram socket）：使用UDP提供“尽力而为”的数据报服务

1.3.1.3 常用方法

?Socket类的常用构造器：
?public Socket(InetAddress address,int port)创建一个流套接字并将其连接到指定IP 地址的指定端口号。
?public Socket(String host,int port)创建一个流套接字并将其连接到指定主机上的指定端口号。
?Socket类的常用方法：
?public InputStream getInputStream()返回此套接字的输入流。可以用于接收网络消息
?public OutputStream getOutputStream()返回此套接字的输出流。可以用于发送网络消息
?public InetAddress getInetAddress()此套接字连接到的远程 IP 地址；如果套接字是未连接的，则返回 null。
?public InetAddress getLocalAddress()获取套接字绑定的本地地址。 即本端的IP地址
?public int getPort()此套接字连接到的远程端口号；如果尚未连接套接字，则返回 0。
?public int getLocalPort()返回此套接字绑定到的本地端口。 如果尚未绑定套接字，则返回 -1。即本端的 端口号。
?public void close()关闭此套接字。套接字被关闭后，便不可在以后的网络连接中使用（即无法重新连接 或重新绑定）。需要创建新的套接字对象。 关闭此套接字也将会关闭该套接字的 InputStream 和 OutputStream。
?public void shutdownInput()如果在套接字上调用 shutdownInput() 后从套接字输入流读取内容，则流将 返回EOF（文件结束符）。 即不能在从此套接字的输入流中接收任何数据。
?public void shutdownOutput()禁用此套接字的输出流。对于 TCP 套接字，任何以前写入的数据都将被发 送，并且后跟 TCP 的正常连接终止序列。 如果在套接字上调用 shutdownOutput() 后写入套接字输出流， 则该流将抛出 IOException。 即不能通过此套接字的输出流发送任何数据。

1.3.1.4 服务端

public class TCPServer {
    public static void main(String[] args) throws IOException {
        // testOne();
        testMany();
    }

    public static void testOne() throws IOException {
        // 1 开启服务端端口
        ServerSocket ss = new ServerSocket(10000);
        System.out.println("服务端已启动，等待连接...");
        // 2 接收客户端链接
        // 当程序执行到这里的时候就会进入等待状态，一直到有客户端连接为止
        Socket skt = ss.accept();
        System.out.println("客户端已连接");
        // 3 给客户端发送数据
        // 流通过客户端获取，获取输出流
        OutputStream os = skt.getOutputStream();
        // 转换为打印流
        PrintStream out = new PrintStream(os);
        out.println("Hello world");
        // 4 关闭流,先打开的后关闭
        out.close();
        os.close();
        skt.close();
        ss.close();
        System.out.println("连接已关闭");
    }

    public static void testMany() throws IOException {
        // 1 开启服务端端口
        ServerSocket ss = new ServerSocket(9999);
        System.out.println("服务器已启动，正在等待连接....");
        // 2 接收客户端连接
        // 当程序执行到这里就会进入等待状态，一直到有客户连接为止
        Socket skt = ss.accept();
        System.out.println("客户端已连接");
        // 3 给客户端发送数据
        // 获取输出流
        OutputStream os = skt.getOutputStream();
        // 转换为字符打印流
        PrintWriter out = new PrintWriter(new OutputStreamWriter(os, "utf-8"));
        // 获取输入流
        InputStream is = skt.getInputStream();
        // 转换为字符缓冲流
        BufferedReader br = new BufferedReader(new InputStreamReader(is, "utf-8"));
        // 接收控制台输入
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("小红：" + br.readLine());
            out.println(scanner.nextLine());
            out.flush();
        }
    }
}

1.3.1.5 客户端

public class TCPClient {
    public static void main(String[] args) throws Exception {
        // 创建对象，指定服务端IP和端口
        Socket skt = new Socket("127.0.0.1", 9999);
        // 获取输出流
        OutputStream os = skt.getOutputStream();
        // 转换为字符打印流
        PrintWriter out = new PrintWriter(new OutputStreamWriter(os, "utf-8"));
        // 获取输入流
        InputStream is = skt.getInputStream();
        // 转换为字符缓存流
        BufferedReader br = new BufferedReader(new InputStreamReader(is, "utf-8"));
        // 接收控制台输入
        Scanner scanner = new Scanner(System.in);
        while (true) {
            out.println(scanner.nextLine());
            out.flush();
            System.out.println("小明：" + br.readLine());
        }
    }
}

1.3.2 UDP

1.3.2.1 概述

1.3.2.2 常用方法

1.3.2.3 服务端

public class UDPSevrver {
    public static void main(String[] args) throws Exception {
        // 打开DUP对象，并监听某个端口
        DatagramSocket ds = new DatagramSocket(9999);
        // 包接收器接收
        byte[] buf = new byte[1024];
        // 通过包接收器把数据保存到数组中
        DatagramPacket dp = new DatagramPacket(buf, buf.length);
        // 阻塞式接收
        while (true) {
            // 通过端口接收数据
            ds.receive(dp);
            // 把数组中的数据转化为流
            ByteArrayInputStream bais = new ByteArrayInputStream(buf);
            // 转换为数据流
            DataInputStream dis = new DataInputStream(bais);
            // 读取数据
            System.out.println(dis.readUTF());
        }
    }
}

1.3.2.4 客户端

public class UDPClient {
    public static void main(String[] args) throws Exception {
        String string = "你好吗";
        // 字节数组流
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        // 封装为数据流
        DataOutputStream dos = new DataOutputStream(baos);
        dos.writeUTF(string);
        // 转换为字节数组
        byte[] buf = baos.toByteArray();
        // byte[] buf = string.getBytes();
        // for (byte b : buf) {
        // System.out.println(b);
        // }

        // System.out.println(new String(buf));

        // 把转换之后的这个字节数组发送出去
        // 创建数据包
        DatagramPacket dp = new DatagramPacket(buf, buf.length, new InetSocketAddress("127.0.0.1", 9999));

        // 发送,通过当前电脑的 指定端口把数据包发送出去
        DatagramSocket ds = new DatagramSocket(9998);
        ds.send(dp);

        // UDP发送数据快，不保证数据可靠
    }
}

1.3.3 UDP和TCP区别

2. 网络编程

2.1 概述

• 正则表达式：定义了字符串的匹配模式
• 可以用来搜索，编辑或处理文本，并不仅限于某一种语言，但是每种语言中有细微的差别
• JDK1.4推出的正则表达式类 java.util.regex 包，很好的支持了正则表达式
• 常用语法：
• \ 转义符 ，把有意义字符转换为无意义字符
• 但是java中\也是转义符，所以在java中编写正则表达式的时候，需要\
• 字符取值范围相关 [abc]:表示可能是a，b，c [^abc]:表示不是abc中的任何一个
• [a-zA-Z]:表示是大小写字母，[a-z]小写 [A-Z]大写[0-9] 0-9 [a-zA-Z0-9]:表示是数字或字母
• 简洁表示 . :匹配任意字符 \d:表示数字 \D表示非数字等同于[^0-9]
• \s:表示由空字符组成，[\t\n\r\x\f] \S:表示非空字符组成
• \w:表示由字母数字下划线组成[a-zA-Z0-9] \W:表示非字母数字下划线[^a-zA-Z0-9]
• 表示数量的 ？：表示出现0次或1次 +：表示1次或多次 *：任意次数（0~n） {n}：表示出现n次
• {n,m}：表示出现n次到m次 {2，5}2到5次 {n，}：表示出现n次及以上
• ():把他们看作一个整体 | 或，
• ^:以什么打头 ，但是用在[]中就表示取反[^xxxx] ^a[a-z]
• $:以什么什么结尾
• 校验 非 汉字[^\u4e00-\u9fa5]

2.2 语法

见菜鸟教程

2.3 练习

1 匹配整数和小数
(-)?\d+(\.\d+)?

2 电话校验
\d{11}
1[345789]\d{9}

2.4 Pattern

2.4.1 概述

• Pattern:创建正则表达式对象，能做一些基本的简单操作
• 三个功能：
• 1 验证：boolean matchers(String regex);
• 2 拆分String[] split(String regex);
• 3 替换String replaceAll(String regex,String replacement);
• 实际操作中，有时候我们嫌麻烦，也可以直接使用String里面的一些方法，比如 替换，拆分，验证String类中也有的

2.4.2 使用

public class _01_Pattern {
    public static void main(String[] args) {
        // test_01();
        test_02();
    }

    // String[] split(String regex);
    public static void test_01() {
        String str = "1,2,3,4";
        // 创建正则表达式
        Pattern pattern = Pattern.compile(",");
        String[] strArray = pattern.split(str);
        for (String string : strArray) {
            System.out.println(string);
        }

        String[] strArray1 = str.split("[^0-9]");
        for (String string : strArray1) {
            System.out.println(string);
        }
    }

    public static void test_02() {
        String regex = "(-)?\\d+(\\.\\d+)?";
        String str = "2.63";
        // 全词匹配
        boolean flag = Pattern.matches(regex, str);
        System.out.println(flag);

        // String类中的用法
        System.out.println(str.matches(regex));
    }
}

2.5 Matcher

2.5.1 概述

?构造方法也是私有的，不能随意创建，只能通过Pattern.matcher(CharSequence input)方法得到该类的实例 Matcher m = p.matcher(“aaaaab”);
?支持便捷强大的正则匹配操作，包括分组、多次匹配支持

2.5.2 三大方法

Matcher.matches()：对整个字符串进行匹配，只有整个字符串都匹配了才返回true
Matcher.lookingAt()：对前面的字符串进行匹配，只有匹配到的字符串在最前面才返回true
Matcher.find()：对字符串进行匹配,匹配到的字符串可以在任何位置

2.5.3 字符串匹配

public class _02_Matcher {
    public static void main(String[] args) {
        String regex = "\\d{11}";
        String tel = "13131313111";
        // 引擎
        Pattern pattern = Pattern.compile(regex);
        // 匹配器
        Matcher matcher = pattern.matcher(tel);

        // 三种匹配模式
        // matches：全词匹配 xxx
        // find：任意位置均可 .*xxx.*
        // lookingAt：从前到后 xxx.*

        // 全词匹配，等于写着^和$
        System.out.println(matcher.matches());
        // 注意：一个匹配器对象(matcher),调用相同的方法可以连用，其他的不建议混用

        matcher = pattern.matcher(tel);
        // a123131321就不行
        System.out.println(matcher.lookingAt());

        matcher = pattern.matcher(tel);
        System.out.println(matcher.find());
    }
}

2.5.4 数据提取

public class _03_Matcher {
    public static void main(String[] args) {
        // 可以使用()对匹配到的数据进行分组，第一个()就是第一组，第二个()就是第二组
        // 也可以不分组，如果不分组的情况下做数据提取，就只能提取到整个匹配到的字符串
        // 分组之后 可以提取对应组的数据
        // 第一组(.{2,3}电话号码是)
        // 第二组(.{2,3})
        // 第三组(\\d{11}))
        String string = "张三电话号码是12345678911";
        String regex = "((.{2,3})电话号码是)(\\d{11})";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(string);
        // find 匹配任意位置，匹配到一个之后就停止
        // 如果接着调用find方法，就会接着刚停止的地方继续向后面匹配
        while (matcher.find()) {
            // 所以结合find特性，可以和group连用，做到数据提取
            // group：0或者无参，获取匹配到的整个数据
            // 一个小括号就是一组
            System.out.println(matcher.group(1) + " : " + matcher.group(2));
        }
    }
}

2.5.5 叠词去重

public class _04_Test {
    public static void main(String[] args) {
        String str = "我我我、、、我我、、我我要要要学学编编程程";
        // 1 先把其他没用的都去掉，只留下汉字
        // \u4e00-\u9fa5:汉字
        str = str.replaceAll("[^\\u4e00-\\u9fa5]", "");
        // System.out.println(str);
        // \\1 获取前面组的数据
        // (\\d)\\1 :表示连续出现的数字，11，22，33，44，55
        // (\\d)(a)\\1:表示 第一个是数字，第二个是a，第三个和第一个一样 1a1
        // (\\d)(a)\\2 :表示第一个是数字，第二个是a，第三个和第二个一样 1aa
        String regex = "(.)(\\1+)";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        while (matcher.find()) {
            // 我
            System.out.println(matcher.group());
            System.out.println(matcher.group(1));
            System.out.println(matcher.group(2));
        }
        // 用第一组把整个匹配道德数据替换即可
        // $1就等于 group(1)
        str = str.replaceAll(regex, "$1");
        System.out.println(str);
    }
}