首页 > 其他分享> 文章详细

2021-07-25

2021-07-25 22:58:36 阅读：153 来源： 互联网

标签：25 String matcher 2021 07 println new 接字 out

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.1TCP
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 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();
       }
       // 4 关闭流,先打开的后关闭
       out.close();
       os.close();
       skt.close();
       ss.close();
       System.out.println("连接已关闭");
   }
}
1.3.1.5客户端
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());
       }
       br.close();
       is.close();
       skt.close();
   }
}
1.3.1.6多线程阻塞式交互
1.3.2UDP
1.3.2.1概述

1.3.2.2常用方法

1.3.2.3服务端
public static void main(String[] args) throws Exception{
       // 打开UDP对象,并监听某个端口
       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 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();

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

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

2.正则表达式
2.1概述
正则表达式 : 定义了字符串的匹配模式
*
* 可以用来搜索,编辑或处理文本,并不仅限于某一种语言,但是每种语言中有细微的差别
*
* JDK1.4 推出的 java.util.regex 包,很好的支持了正则表达式

重要内容

常用语法 :
*
*        \ 转移符 , 把有意义字符转换为无意义字符
*            但是java中 \ 也是转移符,所以在java中编写正则表达式的时候,需要转移符的时候需要些两个 \\
*
*        字符取值范围相关
*            [abc] : 表示可能是a, 也可能是b, 也可能是c (是abc中的任意一个)
*            [^abc] : 表示不是a,b,c中的任何一个
*            [a-zA-Z] : 表示是大小写字母 , [a-z] 小写字母 , [A-Z] 大写字母 [0-9] 数字0-9
*            [a-zA-Z0-9] : 表示是数字或字母
*
*        简洁表示
*            . : 匹配任意字符
*            \d : 表示数字等同于[0-9]
*            \D : 表示非数字等同于 [^0-9]
*            \s : 表示由空字符组成, [\t\n\r\x\f]
*            \S : 表示非空字符组成
*            \w : 表示由字母数字下划线组成 [a-zA-Z0-9_]
*            \W : 表示非字母数字下划线 [^a-zA-Z0-9_]
*
*        表示数量的
*            ? : 表示出现0次或1次
*            + : 表示1次或多次, 大于等于1
*            * : 任意次数(0~N)
*            {n} : 表示出现n次 , {2} 表示出现2次
*            {n,m} : 表示出现n次到m次 , {2,5} : 表示出现2~5次
*            {n,} : 表示出现n及以上 >=n
*
*    () : 把他们看做一个整体
*
* | 或 , a|b ,a和b都可以匹配
*
* ^ : 以什么什么打头 , 但是用在[^xxxx] 就表示取反
* $ : 以什么什么结尾
* ^a[^a-z] , a1 , aA , a3, 22
*
* 校验非汉字
* [^\u4e00-\u9fa5]
*
* Pattern : 创建正则表达式对象,能做一些基本的简单操作
*
*    三大功能 :
*        验证 : boolean matchers(String regex);
*        拆分 : String[] split(String regex);
*        替换 : String replaceAll(String regex,String replacement);
* 实际操作中,有时候我们嫌麻烦,也可以直接使用String里面的一些方法,比如替换,拆分,验证String类中也有的
2.2语法

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

2.4.2使用
public static void main(String[] args) {
       // test_01();
       test_02();
   }
   // 验证 : boolean matchers(String regex);
   public static void test_02() {
       String regex = "(-)?\\d+(\\.\\d+)?";
       String str = "2.43";
       // 全词匹配
       boolean flag = Pattern.matches(regex, str);
       System.out.println(flag);

       // String类中的用法,也是全词匹配
       System.out.println(str.matches(regex));
   }
   // 拆分 String[] split(String regex);
   public static void test_01(){
       String str = "1,2@3!4";
       // 创建正则表达式对象
       Pattern pattern = Pattern.compile("[^0-9]");
       String[] strArray = pattern.split(str);
       for (String string : strArray) {
           System.out.println(string);
       }
       // String的
       String[] strArray1 = str.split("[^0-9]");
       for (String string : strArray1) {
           System.out.println(string);
       }
   }
}
2.5Matcher
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 static void main(String[] args) {
       String regex = "\\d{11}";
       String tel = "a131131131112";
       // 引擎
       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);
       // 只要最前面的是符合条件的就行
       System.out.println(matcher.lookingAt());

       matcher = pattern.matcher(tel);
       // 任意位置符合条件就行
       System.out.println(matcher.find());
   }
}
2.5.4 数据提取
public static void main(String[] args) {
       // 可以使用() 对匹配到的数据进行分组, 第一个() 就是第一组,第二个() 就是第二组
       // 也可以不分组,如果不分组的情况下做数据提取,就只能提取到整个匹配到的字符串
       // 分组之后可以提取对应组的数据
       // ((.{2,3})电话号码是) 第一组
       // (.{2,3}) 第二组
       // (\\d{11}) 第三组
       String string = "张三电话号码是13113113111张三四电话号码是13113113112张三五电话号码是13113113113张四电话号码是13113113114王五电话号码是13113113115赵六电话号码是13113113333孙小黑电话号码是13113113211小红电话号码是13113113311";
       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或者无参, 获取匹配到的整个数据,1 就是第一组,2就是第二组
           // 一个小括号就是一组
           System.out.println(matcher.group(2) + " : " + matcher.group(3));
       }
   }
}
2.5.5叠词去重
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 , 2a2 , 3a3
       // (\\d)(a)\\2 : 表示第一个是数字,第二个是a, 第三个和第二个一样, 1aa,2aa,3aa
       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);
   }

标签：25,String,matcher,2021,07,println,new,接字,out
来源： https://blog.csdn.net/l13731380061/article/details/119089483

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

2021-07-25