Java基础知识_毕向东_Java基础视频教程笔记(22-25 GUI 网络编程 正则)

　　22天-01-GUI
GUI：Graphical User Interface 图形用户接口
Java为GUI提供的对象都存在java.Awt和javax.Swing两个包中
CLI：Common line User Interface 命令行用户接口

Awt：Abstract Window ToolKit(抽象工具包)，需要调用本地系统方法实现功能，属于重量级控件。
Swing：在Awt的基础上，建立的一套图形界面系统，其中提供了更多的组件，而且完全由Java实现，增强了移植性，属于轻量级控件。

继承关系：
Component 　　　　　　Container Window、Panel Frame、　　　　　　　　Dialog FileDialog
　　　　　　　　　　　  Button、Label、Checkbox、TextComponent 　　　  TextArea、TextField

Container：为容器，是一个特殊的组件，该组件可以通过add方法添加其他组件进来。
Swing继承关系图：

布局：容器中的组件排放方式
常见的布局管理器：
FlowLayout:　　　　流式布局管理器，从左到右的顺序排列，Panel默认的布局管理器
BorderLayout：　　 边界布局管理器，中东南西北，Frame默认的布局管理器
GridLayout：　　　  网格布局管理器，规则的矩阵
CardLayout：　　　 卡片布局管理器，选项卡
GridBagLayout：　   网格包布局管理器，非规则的矩阵

事件监听机制的特点：
1.事件源：就是awt包或者swing包中的那些图形界面组件。
2.事件：每一个事件源都有自己特有的对应事件和共性事件。
3.监听器：将可以触发某个事件的动作(不止一个动作)都已经封装到了监听器中。
4.事件处理

制作可执行文件：
1.制作配置文件config.txt，冒号后面必须有一个空格，最后一行必须换行
Main-Class: myPackage.ExecuteFile
2.先编译　　 javac -d packagePath File.java
javac -d . ExecuteFile.java
3.打包　　　 jar -cvfm package.jar config.txt PackageDirectory
jar -cvfm ExecuteFile.jar config.txt myPackage

ExecuteFile示例：

 package myPackage;
 import java.util.*;
 import java.io.*;
 import java.awt.*;
 import java.awt.event.*;

 public class ExecuteFile
 {
     private Frame fr;
     public static void main(String[] args)throws IOException
     {
         new ExecuteFile();
     }
     public ExecuteFile()
     {
         init();
     }
     private void init()
     {
         fr=new Frame("Demo");
         fr.setSize(,);
         fr.setLocation(,);
         fr.setVisible(true);
         fr.addWindowListener(new WindowAdapter(){
             public void windowClosing(WindowEvent e) {
                 System.exit();
             }
         });
     }
 }

ExecuteFile

 Main-Class: myPackage.ExecuteFile

config.txt

　　23天-01-网络编程

网络基础知识：
IP地址：网络中设备的标识
本地回环地址：　　127.0.0.1 　　 主机名：localhost
端口号：用于标识进程的逻辑地址，不同进程的标识。有效端口号：0~65535，其中0~1024为系统使用或者保留端口。
Internet默认端口：　80 　　　　 tomcat默认端口：8080 　　　　数据库默认端口：3306
传输协议：计算机之间通信的规则。常见协议：TCP，UDP

OSI模型：　　应用层，表示层，会话层，传输层，网络层，数据链路层，物理层
TCP/IP模型： 　　 应用层， 　　　　　  传输层，网络层，　　主机至网络层

UDP：将数据及源和目的封装成数据包中，不需要建立连接，每个数据报的大小限制64k内，因无连接，是不可靠协议，不需要建立连接，速度快。
TCP：建立连接，形成传输数据的通道，在连接中进行大量数据传输，通过三次握手完成连接，是可靠协议，必须建立连接，效率稍低。

TCP与UDP区别：
1、TCP面向连接（如打电话要先拨号建立连接）; 　　 　　　　　　UDP是无连接的，即发送数据之前不需要建立连接
2、TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达; 　　　　 UDP尽最大努力交付，即不保证可靠交付
3、TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流;　　　　UDP是面向报文的，UDP没有拥塞控制，因此网络出现拥塞不会使源主机的发送速率降低（对实时应用很有用，如IP电话，实时视频会议等）
4、每一条TCP连接只能是点到点的; 　　　　　　　　　　　　　　 UDP支持一对一，一对多，多对一和多对多的交互通信
5、TCP首部开销20字节; 　　　　　　　　　　　　　　　　　　　 UDP的首部开销小，只有8个字节
6、TCP的逻辑通信信道是全双工的可靠信道；　　　　　　　　　　UDP则是不可靠信道

Socket：是为网络服务提供的一种机制，通信的两端都有Socket，数据在两个Socket间通过IO传输。
注：IP地址段中，一个网段的最后两段是1.0和1.255时比较特殊，1.0 表示一个区域的网络地址-网络段，1.255代表此网段的广播地址

　　UDP传输：
UDP发送端：
1.建立UDPSocket服务，通过DatagramSocket对象建立；
2.获取数据，并将数据封装到数据包中，数据包对象DatagramPacket；
3.通过Socket服务的发送功能send();方法，将数据包发送出去；
4.关闭资源。

UDP接收端：
1.定义UDPSocket服务，建立DatagramSocket对象时通常会监听一个端口，其实就是给这个接收网络应用程序定义数字标识。方便于明确哪些数据过来该应用程序可以处理；
2.定义一个数据包用来存储接收到的字节数据。数据包对象中有很多功能可以提取字节数据中的不同数据信息，数据包DatagramPacket对象；
3.通过服务DatagramSocket的receive();方法将接收到的数据存入数据包对象中；
4.在数据包DatagramPacket对象中将这些不同的数据取出来。
5.关闭资源。

Socket UDP聊天软件聊天示例：

 /**
  * 模拟聊天软件，有收数据的部分和发送数据的部分。这两部分需要同时执行，
  * 使用多线程技术一个线程控制收，一个线程控制发。
  * 因为收和发动作不是一致的，所以要定义两个run方法，而这两个方法要封装到不同类中
  */
 class Demo
 {
     public static void main(String[] args) throws Exception
     {
         DatagramSocket send = new DatagramSocket();
         DatagramSocket receive = new DatagramSocket();
         new Thread(new UDPSend(send)).start();
         new Thread(new UDPReceive(receive)).start();
     }
 }

 class UDPSend implements Runnable
 {    //发送端
     private DatagramSocket ds;
     UDPSend(DatagramSocket ds)
     {
         this.ds = ds;
     }
     public void run()
     {
         try
         {
             BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
             String temp;
             while ((temp = br.readLine()) != null)
             {
                 if ("exit".equals(temp))
                 { break;}
                 byte[] line = temp.getBytes();
                 DatagramPacket dp = new DatagramPacket(line, line.length, InetAddress.getByName("192.168.0.255"), );
                 ds.send(dp);
             }
             ds.close();
         }
         catch (Exception e)
         {
             e.getStackTrace();
         }
     }
 }

 class UDPReceive implements Runnable
 {    //接收端
     private DatagramSocket ds;
     UDPReceive(DatagramSocket ds)
     {
         this.ds = ds;
     }
     public void run()
     {
         try
         {
             while (true)
             {
                 byte[] line = new byte[ * ];
                 DatagramPacket dp = new DatagramPacket(line, line.length);
                 ds.receive(dp);
                 String ip = dp.getAddress().getHostAddress();
                 String data = new String(dp.getData(), , dp.getLength());
                 System.out.println(ip + ": " + data);
             }
         }
         catch (Exception e)
         {
             e.getStackTrace();
         }
     }
 }

Socket UDP

　　TCP传输：

1.TCP分客户端和服务端,分别是独立的两个应用程序。
2.客户端对应的对象是Socket，服务端对应的是ServerSocket，建立连接后，通过Socket中的IO流进行数据的传输

客户端：通过Socket对象，建立连接指定主机的连接。因为TCP是面向连接的，所以在建立Socket连接时，就要有服务端存在，并确保连接成功形成通路后，在该通道进行数据的传输。
客户端建立步骤：
1.创建客户端Socket服务，并指定要连接的主机和端口；
2.准备发送数据，获取Socket流中的输出流；
3.关闭资源。

服务端：
服务端建立步骤：
1.建立服务端的Socket服务，ServerSocket(port);并监听一个端口；
2.获取连接过来的客户端对象。通过ServerSocket的accept();方法，在没有连接时就会等待，所以这个方法是阻塞式的；
3.客户端如果发过来数据，那么服务端要使用对应的客服端对象，并获取到该客户端对象的读取流来读取发过来的数据；
4.关闭客户端，服务端一般不关闭(可选)。

TCP文件上传示例：

 /**
  * 实现并发上传数据
  * 服务端采用多线程，给每一个客户端访问连接分配一个线程，实现并发多客户端访问服务端
  */
 class FileClient
 {
     public static void main(String[] agrs) throws Exception
     {
         Socket s = new Socket("192.168.0.102", );
         OutputStream out = s.getOutputStream();
         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
         System.out.println("upload file name or full path:");
         //客户端准备上传的文件名
         String fileName = br.readLine();
         System.out.println("server file name:");
         //上传文件在服务端名称
         String modifyName = br.readLine();
         out.write(modifyName.getBytes());

         FileInputStream fis = new FileInputStream(fileName);
         byte[] b = new byte[];
         int len;
         while ((len = fis.read(b)) != -)
         {
             out.write(b, , len);
         }
         s.shutdownInput();
         s.close();
     }
 }
 class ServerThread implements Runnable
 {
     private Socket s;
     ServerThread(Socket s)
     {
         this.s = s;
     }
     @Override
     public void run()
     {
         String ip = s.getInetAddress().getHostAddress();
         try
         {
             System.out.println(ip + ".....connected success");
             byte[] b = new byte[];
             int len;
             InputStream in = s.getInputStream();
             len = in.read(b);
             String fileName = new String(b, , len);
             FileOutputStream fos = new FileOutputStream(fileName);
             byte[] bt=new byte[];
             while ((len = in.read(bt)) != -)
             {
                 fos.write(bt, , len);
             }
             OutputStream out = s.getOutputStream();
             out.write(("上传成功：" + fileName).getBytes());
             fos.close();
             s.close();
         }
         catch (Exception e)
         {
             System.out.println(ip + "......upload fail");
             System.out.println(e.getStackTrace());
         }
     }
 }
 class FileServer
 {
     public static void main(String[] agrs) throws Exception
     {
         ServerSocket ss = new ServerSocket();
         while (true)
         {
             Socket s = ss.accept();
             new Thread(new ServerThread(s)).start();
         }
     }
 }

Upload File

TCP登录示例：

 /**
  * 客户端通过键盘录入用户名和密码，服务端对这个用户名和密码进行校验
  * 如果该用户名存在，并且密码正确，在服务端显示XX已登录，并在客户端显示XXX，欢迎光临
  * 如果该用户尝试三次登录，用户名和密码没有同时校验通过，则关闭客户端
  */
 class LoginClient
 {
     public static void main(String[] args) throws Exception
     {
         Socket s = new Socket("192.168.0.102", );
         BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));
         BufferedReader bfw = new BufferedReader(new InputStreamReader(s.getInputStream()));
         PrintWriter pw = new PrintWriter(s.getOutputStream(), true);

         for (int i = ; i < ; i++)
         {
             System.out.println("user name:");
             String userName = bfr.readLine();
             System.out.println("user password:");
             String userPwd = bfr.readLine();
             pw.println(userName);
             pw.println(userPwd);
             String data = bfw.readLine();
             String[] result = data.split(":");
             if ("true".equals(result[]))
             {
                 System.out.println(userName + "，欢迎光临！");
                 break;
             }
             else
             {
                 System.out.println(userName + "，登录失败! " + result[]);
             }
         }
         bfr.close();
         pw.close();
         s.close();
     }
 }
 class UserThread implements Runnable
 {
     private Socket s;
     UserThread(Socket s)
     {
         this.s = s;
     }
     @Override
     public void run()
     {
         String ip = s.getInetAddress().getHostAddress();
         try
         {
             System.out.println(ip + "......connected success");
             BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
             BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

             for (int i = ; i < ; i++)
             {
                 String userName = br.readLine();
                 String userPwd = br.readLine();
                 if (userName.isEmpty() || userPwd.isEmpty())
                 {
                     bw.write("false:The user name or password can not be empty");
                     bw.newLine();
                     bw.flush();
                     System.out.println("user name or password is empty");
                     continue;
                 }
                 String pwd = getConfigInfo("config.properties", userName);
                 if (!userPwd.equals(pwd))
                 {
                     bw.write("false:The username or password is wrong");
                     bw.newLine();
                     bw.flush();
                     System.out.println("user password is wrong");
                 }
                 else
                 {
                     System.out.println("user is Login");
                     bw.write("true:Login success");
                     bw.newLine();
                     bw.flush();
                     break;
                 }
             }
             br.close();
             bw.close();
             s.close();
             System.out.println(ip + "......disconnected");
         }
         catch (Exception e)
         {
             System.out.println(ip + "......connected fail");
             System.out.println(e.getMessage());
             StackTraceElement[] stack = e.getStackTrace();
             if (stack != null)
             {
                 for (int i = ; i < stack.length; i++)
                 {
                     System.out.println(stack[i].toString());
                 }
             }
         }
     }

     /**
      * 获取配置文件信息
      *
      * @param filePath 文件路径
      * @param key      键值
      * @return 值
      */
     private String getConfigInfo(String filePath, String key)
     {
         Properties properties = new Properties();
         try
         {
             properties.load(new BufferedReader(new FileReader(filePath)));
             return properties.getProperty(key);
         }
         catch (FileNotFoundException e)
         {
             e.printStackTrace();
         }
         catch (IOException e)
         {
             e.printStackTrace();
         }
         return null;
     }
 }
 class LoginServer
 {
     public static void main(String[] args) throws Exception
     {
         ServerSocket ss = new ServerSocket();
         while (true)
         {
             Socket s = ss.accept();
             new Thread(new UserThread(s)).start();
         }
     }
 }

Login

　　URL类：统一资源定位符

URLConnection openConnection();　　//获取URL 所引用的远程对象的连接
URLConnection conn=url.openConnection();
abstract void connect();　　//子类实现方法建立到远程对象的实际连接
OutputStream getOutputStream();　　//获取连接读取的输入流
InputStream getInputStream();　　　 //获取连接的输出流
void setConnectTimeout(int timeout);  //设置一个指定的超时值（以毫秒为单位）
void setReadTimeout(int timeout);//将读超时设置为指定的超时值，以毫秒为单位

模拟浏览器客户端：

 class Demo
 {
     public static void main(String[] args) throws Exception
     {
         URL url = new URL("http://www.google.cn/");
         URLConnection conn = url.openConnection();
         conn.connect();
         InputStream in = conn.getInputStream();
         int len;
         byte[] bt = new byte[*];
         while ((len = in.read(bt)) != -)
         {
             //注意编码格式，GBK，UTF-8,Unicode
             System.out.println(new String(bt, , len, "UTF-8"));
         }
     }
 }

Browser

　　25天-01-正则表达式

正则表达式：符合一定规则的表达式，用于专门操作字符串。
特点：用一些特定的符号来表示一些代码操作，简化对特殊字符串的校验

使用正则表达式思路：
1.如果只想知道该字符串是对是错，使用匹配；
2.如果想要将已有的字符串变成另一个字符串，替换；
3.如果想要按照自定的方式将字符串变成多个字符串，切割，获取规则以外的子串；
4.如果想要拿到符合需求的字符串子串，获取，获取符合规则的子串。

正则表达式校验邮箱地址：
//较为精确匹配
String reg="[a-zA-Z0-9]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";
//相对上面,@后面采用模糊匹配，1@1.1会通过校验
String reg="\\w+@\\w+(\\.\\w+)+";

具体操作功能：用规则匹配整个字符串，只要有一处不符合规则，匹配就结束，返回false
1.匹配方法：boolean matches(String regex); 　　 Pattern.matches(regex, str);
Regex示例：
//QQ号匹配：全部为数字，第一位不为0，总共有5到15位
String reg="[1-9]\\d{4,14}";
//手机号匹配：13xxx、15xxx、18xxx三个段位，总共11位数字
String reg="1[358]\\d{9}";

2.切割方法：String[] split(String regex); String[] split(String regex, int limit);
Regex示例：
//按照多个空格进行切割
String reg=" +";
//按照.号进行切割
String reg="\\.";
//按照\\进行切割，用于文件路径操作
String reg="\\\\";
//按照叠词完成切割。为了可以让规则的结果被重用，可以将规则封装成一个组，用()表示。组的出现都有编号，从1开始，定义编号\\n，想要使用已有的组可以通过$n(n就是组的编号)的形式来获取
String reg="(.)\\1+";

3.替换方法：String replace(char oldChar, char newChar);　　String replace(CharSequence target, CharSequence replacement);
String replaceAll(String regex, String replacement);　　　　　String replaceFirst(String regex, String replacement);
Regex示例：
//将字符串中的数字替换成*，防止联系方式泄露
replaceAll("\\d{5,}","*");
//将重叠的字符替换成单个字母,$1 是获取前面组的编号.例如：dafaaaffffc ->dafafc
replaceAll("(.)\\1+","$1");

4.获取方法：将字符串中符合规则的子集取出
步骤：
1.将正则表达式封装成对象；
2.让正则对象和要操作的字符串相关联；
3.关联后，获取正则匹配引擎；
4.通过引擎对符合规则的子串进行操作。

获取单词示例：

 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 /**
  * 其实String类中的matches方法用的就是Pattern和Matcher对象完成的。只不过被String的方法封装后用起来较为简单，但是功能却单一。
  */
 class Demo
 {
     public static void main(String[] args)
         throws Exception
     {
         String str = "ming tian ni shi fou yao jia gei wo!";
         String reg = "\\b[a-zA-Z]{2,}\\b";
         //将规则封装成对象
         Pattern p = Pattern.compile(reg);
         //让正则对象和要作用的字符串相关联，获取匹配器对象
         Matcher m = p.matcher(str);
         //将规则作用到字符串上，并进行符合规则的子集查找，group前必须find
         while (m.find())
         {
             //用于获取匹配后的结果
             System.out.println(m.group());
             System.out.println(m.start() + "..." + m.end());
         }
     }
 }

Obtain word

获取网页邮箱示例：

 import java.io.BufferedReader;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.net.URL;
 import java.net.URLConnection;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 class Demo
 {
     private static final String REGEX_MAIL = "\\w+@\\w+(\\.\\w+)+";
     public static void main(String[] args)throws Exception
     {
         String dad = "dadaffa@dada.com";
         System.out.println(dad.matches(REGEX_MAIL));

         BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));
         boolean flag = false;
         while (true)
         {
             if (flag)
             {
                 break;
             }
             String str = null;
             while ((str = bfr.readLine()) != null)
             {
                 if ("exit".equals(str))
                 {
                     flag = true;
                     break;
                 }
                 else
                 {
                     try
                     {
                         regexMail(str);
                     }
                     catch (Exception e)
                     {
                         System.out.println("input url is wrong");
                         System.out.println(e.getMessage());
                     }
                 }
                 System.out.println("**********************");
                 System.out.println("please input next url:");
             }
         }
         System.out.println("program is over!");
     }
     private static void regexMail(String param)throws Exception
     {
         Pattern pattern = Pattern.compile(REGEX_MAIL);
         URL url = new URL(param);
         URLConnection conn = url.openConnection();
         InputStream in = conn.getInputStream();
         BufferedReader bfr = new BufferedReader(new InputStreamReader(in, "utf-8"));

         String len = null;
         while ((len = bfr.readLine()) != null)
         {
             Matcher m = pattern.matcher(len);
             while (m.find())
             {
                 System.out.println(m.group());
             }
         }
     }
 }

Web Mail

　　Regex正则表达式规则：

字符
x 　　　　 　　 字符 x
\\ 　　　　 　　反斜线字符
\0n 　　　　　  带有八进制值 0 的字符 n (0 <= n <= 7)
\0nn 　　　　　带有八进制值 0 的字符 nn (0 <= n <= 7)
\0mnn 　　　　带有八进制值 0 的字符 mnn（0 <= m <= 3、0 <= n <= 7）
\xhh 　　　　　带有十六进制值 0x 的字符 hh
\uhhhh 　　　   带有十六进制值 0x 的字符 hhhh
\t 　　　　　　  制表符 ('\u0009')
\n 　　　　　　 新行（换行）符 ('\u000A')
\r 　　　　　　 回车符 ('\u000D')
\f 　　　　　　 换页符 ('\u000C')
\a 　　　　　　 报警 (bell) 符 ('\u0007')
\e 　　　　　　 转义符 ('\u001B')
\cx 　　　　　　对应于 x 的控制符

字符类
[abc]　　　　　　　a、b 或 c（简单类）
[^abc] 　　　　　　 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] 　　　 　　a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]] 　　  　　a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]] 　　　  d、e 或 f（交集）
[a-z&&[^bc]] 　　　  a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]] 　　　a 到 z，而非 m 到 p：[a-lq-z]（减去）

预定义字符类

. 　　　　　　　　 匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 \.
* 　　　　　　　　 匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 \*
+ 　　　　　　　　匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+
[ 　　　　　　　　 标记一个中括号表达式的开始。要匹配 [，请使用 \[
? 　　　　　　　　匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 \?
\ 　　　　　　　　 将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\\' 匹配 "\"，而 '\(' 则匹配 "("
^ 　　　　　　　　 匹配输入字符串的开始位置，除非在方括号表达式中使用，此时它表示不接受该字符集合。要匹配 ^ 字符本身，请使用 \^
{ 　　　　　　　　 标记限定符表达式的开始。要匹配 {，请使用 \{
| 　　　　　　　　 指明两项之间的一个选择。要匹配 |，请使用 \|
( ) 　　　　　　　   标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 \( 和 \)

边界匹配器

\A　　　　　　　　　输入的开头
\b 　　　　　　　　   单词边界
\B　　　　　　　　　非单词边界
\d 　　　　　　　　   数字：[0-9]
\D　　　　　　　　　非数字： [^0-9]
\G 　　　　　　　　  上一个匹配的结尾
\s 　　　　　　　　　空白字符：[ \t\n\x0B\f\r]
\S 　　　　　　　　   非空白字符：[^\s]
\w 　　　　　　　　   单词字符：[a-zA-Z_0-9]
\W 　　　　　　　　  非单词字符：[^\w]
\Z 　　　　　　　　   输入的结尾，仅用于最后的结束符（如果有的话）
\z　　　　　　　　　 输入的结尾

Greedy 数量词
X? 　　　　　　　　 X，一次或一次也没有
X* 　　　　　　　　  X，零次或多次
X+ 　　　　　　　     X，一次或多次
X{n} 　　　　　　　   X，恰好 n 次
X{n,} 　　　　　　　  X，至少 n 次
X{n,m} 　　　　　　   X，至少 n 次，但是不超过 m 次