1、昨日复习

1.说明流的三种分类方式
流向：输入流、输出流
数据单位：字节流、字符流
流的角色：节点流、处理流
2.写出4个IO流中的抽象基类，4个文件流，4个缓冲流
InputStream FileXxx BufferedXxx
OutputStream
Reader
Writer

InputStreamReader:父类Reader
异常：XxxException XxxError

RandomAccessFile
3.字节流与字符流的区别与使用情境
字节流：read(byte[] buffer) / read() 非文本文件
字符流：read(char[] cbuf) / read() 文本文件
4.使用缓冲流实现a.jpg文件复制为b.jpg文件的操作
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File(“a.jpg”)));

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File(“b.jpg”)));

byte[] buffer = new byte[1024];
int len;
while((len = bis.read(buffer))!= -1){
bos.write(buffer,0,len);
}

bos.close();
bis.close();

//此时的异常应该使用try-catch-finally处理。

5.转换流是哪两个类，分别的作用是什么？请分别创建两个类的对象。
InputStreamReader:将输入的字节流转换为输入的字符流。解码
OutputStreamWriter：将输出的字符流转换为输出的字节流。编码

InputStreamReader isr = new InputStreamReader(new FileInputStream(“a.txt”),”utf-8”);

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(“b.txt”),”gbk”);

对后面学习的启示：
客户端/浏览器 <—————->后台（java、go、Python、node.js、PHP）<—————->数据库
要求前前后后使用的字符集都统一为：UTF-8

2、对象流

ObjectInputStream和OjbectOutputSteam
 用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
序列化：用ObjectOutputStream类保存基本类型数据或对象的机制
反序列化：用ObjectInputStream类读取基本类型数据或对象的机制
 ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原来的Java对象
序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原
序列化是 RMI（Remote Method Invoke – 远程方法调用）过程的参数和返回值都必须实现的机制，而 RMI 是 JavaEE 的基础。因此序列化机制是JavaEE 平台的基础
如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。否则，会抛出NotSerializableException异常
Serializable
Externalizable

  1. package com.atguigu.java1;
  3. import org.junit.Test;
  5. import java.io.*;
  7. /*
  8. 对象留的使用：
  9. 1、ObjectInputStream和ObjectOutputStream
  10. 2、作用：用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
  11. 3、要想一个java对象是可序列化的，需要满足相应的要求。
  12.    ①需要实现接口：Serializable
  13.    ②凡是实现Serializable接口的类都有一个表示序列化版本标识符的全局常量，具体的值没有要求：private static final long serialVersionUID;
  14. 4、除了当前类需要实现Serializable接口之外，还必须保证其内部所有的属性
  15.     也必须是可序列化的。（默认情况下，基本数据类型也可以序列化）
  16. 补充：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
  18.  */
  19. public class ObjectInputStreamTest {
  20.     /*
  21.     序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去
  22.     使用ObjectOutputStream实现
  23.      */
  24.     @Test
  25.     public void test1() {
  26.         ObjectOutputStream oos = null;
  27.         try {
  28.             oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
  29.             oos.writeObject(new String("我爱北京天安门"));
  30.             oos.flush();//刷新操作
  31.             oos.writeObject(new Person("Tom",23));
  32.             oos.flush();
  33.         } catch (IOException e) {
  34.             e.printStackTrace();
  35.         }finally {
  36.             try {
  37.                 oos.close();
  38.             } catch (IOException e) {
  39.                 e.printStackTrace();
  40.             }
  41.         }
  42.     }
  43.     /*
  44.     反序列化：将磁盘文件中的对象还原为内存中的一个java对象
  45.     使用ObjectInputStream来实现
  46.      */
  47.     @Test
  48.     public void test2(){
  49.         ObjectInputStream ois = null;
  50.         try {
  51.             ois = new ObjectInputStream(new FileInputStream("object.dat"));
  53.             Object obj = ois.readObject();
  54.             String str = (String) obj;
  55.             Person p = (Person) ois.readObject();
  56.             System.out.println(str);
  57.             System.out.println(p);
  58.         } catch (IOException e) {
  59.             e.printStackTrace();
  60.         } catch (ClassNotFoundException e) {
  61.             e.printStackTrace();
  62.         }finally {
  63.             if (ois!=null) {
  64.                 try {
  65.                     ois.close();
  66.                 } catch (IOException e) {
  67.                     e.printStackTrace();
  68.                 }
  69.             }
  70.         }
  73.     }
  75. }

3、随机存取文件流

  1. package com.atguigu.java1;
  3. import org.junit.Test;
  5. import java.io.File;
  6. import java.io.FileNotFoundException;
  7. import java.io.IOException;
  8. import java.io.RandomAccessFile;
  10. /*
  11. RandomAccessFile的使用：
  12. 1、RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口
  13. 2、RandomAccessFile既可以作为一个输入流，又可以作为一个输出流
  14. 3、如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建
  15.    如果写出到的文件存在，则会对原有文件内容进行覆盖。（默认情况下，从头覆盖）
  16. 4、可以通过相关的操作，实现RandomAccessFile“插入”数据的效果
  18.  */
  19. public class RandomAccessFileTest {
  20.     @Test
  21.     public void test1() {
  22.         RandomAccessFile raf1 = null;
  23.         RandomAccessFile raf2 = null;
  24.         try {
  25.             raf1 = new RandomAccessFile(new File("大家好.png"), "r");
  26.             raf2 = new RandomAccessFile(new File("大家好1.png"), "rw");
  27.             byte[] buffer = new byte[1024];
  28.             int len;
  29.             while ((len = raf1.read(buffer)) != -1) {
  30.                 raf2.write(buffer, 0, len);
  31.             }
  32.         } catch (IOException e) {
  33.             e.printStackTrace();
  34.         } finally {
  35.             if (raf1 != null) {
  36.                 try {
  37.                     raf1.close();
  38.                 } catch (IOException e) {
  39.                     e.printStackTrace();
  40.                 }
  41.             }
  42.             if (raf2 != null) {
  43.                 try {
  44.                     raf2.close();
  45.                 } catch (IOException e) {
  46.                     e.printStackTrace();
  47.                 }
  48.             }
  49.         }
  52.     }
  54.     @Test
  55.     public void test2() {
  56.         RandomAccessFile raf1 = null;
  57.         try {
  58.             raf1 = new RandomAccessFile("hello.txt", "rw");
  59.             raf1.seek(new File("hello.txt").length());//指针调到脚标为3的位置
  60.             raf1.write("xyz".getBytes());
  61.         } catch (IOException e) {
  62.             e.printStackTrace();
  63.         } finally {
  64.             if (raf1 != null) {
  65.                 try {
  66.                     raf1.close();
  67.                 } catch (IOException e) {
  68.                     e.printStackTrace();
  69.                 }
  70.             }
  71.         }
  72.     }
  74.     @Test
  75.     public void test3() throws IOException {
  76.         RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");
  77.         raf1.seek(3);
  78.         //保存指针3后面的数据
  79.         StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
  80.         byte[] buffer = new byte[20];
  81.         int len;
  82.         while ((len=raf1.read(buffer))!=-1){
  83.             builder.append(new String(buffer,0,len));
  84.         }
  85.         //调回指针，写入：“xyz”
  86.         raf1.seek(3);
  87.         raf1.write("xyz".getBytes());
  88.         raf1.write(builder.toString().getBytes());
  90.         raf1.close();
  92.     }
  93. }

RandomAccessFile类为用户提供了两种构造方法：
1、RandomAccessFile(File file, String mode)
2、RandomAccessFile(String name, String mode)
其实第二种构造方法也是new一个File出来再调用第一种构造方法，建议使用第一种构造方法，因为第一篇文章就说了File是IO的基础，有一个File不仅仅可以通过RandomAccessFile对文件进行操作，也可以通过File对象对文件进行操作。至于mode，Java给开发者提供了四种mode：

模 式 作 用
r 表示以只读方式打开，调用结果对象的任何write方法都将导致抛出IOException
rw 打开以便读取和写入，如果该文件尚不存在，则尝试创建该文件
rws 打开以便读取和写入，相对于”rw”，还要求对文件内容或元数据的每个更新都同步写入到底层存储设备
rwd 打开以便读取和写入，相对于”rw”，还要求对文件内容的每个更新都同步写入到底层存储设备

注意第二点”rw”模式，对rw模式的解释意味着Java并不强求指定的路径下一定存在某个文件，假如文件不存在，会自动创建
RandomAccessFile中的方法
RandomAccessFile中有如下一些常用方法：

方 法 作 用
void close() 重要，关闭此随机访问文件流并释放与该流关联的所有系统资源
FileChannel getChannel() 返回与此文件关联的唯一FileChannel对象，NIO用到
long getFilePointer() 返回此文件中的当前偏移量
long length() 返回此文件的长度
int read() 从此文件中读取一个数据字节
int read(byte[] b) 将最多b.length个数据字节从此文件读入byte数组，返回读入的总字节数，如果由于已经达到文件末尾而不再有数据，则返回-1。在至少一个输入字节可用前，此方法一直阻塞
int read(byte[] b, int off, int len) 将最多len个数据字节从此文件的指定初始偏移量off读入byte数组
boolean readBoolean() 从此文件读取一个boolean，其余readByte()、readChar()、readDouble()等类似
String readLine() 从此文件读取文本的下一行
void seek(long pos) 重要，设置到此文件开头测量到的文件指针偏移量，在该位置发生下一个读取或写入操作
int skipBytes(int n) 重要，尝试跳过输入的n个字节以丢弃跳过的字节，返回跳过的字节数
void write(byte[] b) 将b.length个字节从指定byte数组写入到此文件中
void write(byte[] b, int off, int len) 将len个字节从指定byte数组写入到此文件，并从偏移量off处开始
void write(int b) 向此文件写入指定的字节
void writeBoolean(boolean v) 按单字节值将boolean写入该文件，其余writeByte(int v)、writeBytes(String s)、writeChar(int v)等都类似

QQ截图20220126154010.png

4、网络编程

网络基础
计算机网络：
把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大、功能强的网络系统，从而使众多的计算机可以方便地互相传递信息、共享硬件、软件、数据信息等资源。
网络编程的目的：
直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯。
网络编程中有两个主要的问题：
如何准确地定位网络上一台或多台主机；定位主机上的特定的应用
找到主机后如何可靠高效地进行数据传输
如何实现网络中的主机互相通信
通信双方地址
IP
端口号
一定的规则（即：网络通信协议。有两套参考模型）
OSI参考模型：模型过于理想化，未能在因特网上进行广泛推广
TCP/IP参考模型(或TCP/IP协议)：事实上的国际标准。
QQ截图20220126165501.png
QQ截图20220126165711.png

QQ截图20220126170520.png
本地回路地址：127.0.0.1 对应着：localhost
QQ截图20220126172737.png

QQ截图20220126170533.png

QQ截图20220126174223.png
QQ截图20220126174337.png
QQ截图20220126175521.png
QQ截图20220126175539.png
什么是Socket
Socket的概念很简单，它是网络上运行的两个程序间双向通讯的一端，既可以接收请求，也可以发送请求，利用它可以较为方便地编写网络上数据的传递。
所以简而言之，Socket就是进程通信的端点，Socket之间的连接过程可以分为几步：
1、服务器监听
服务器端Socket并不定位具体的客户端Socket，而是处于等待连接的状态，实时监控网络状态
2、客户端请求
客户端Socket发出连接请求，要连接的目标是服务端Socket。为此，客户端Socket必须首先描述它要连接的服务端Socket，指出服务端Socket的地址和端口号，然后就向服务端Socket提出连接请求
3、连接确认
当服务端Socket监听到或者说是接收到客户端Socket的连接请求，它就响应客户端Socket的请求，建立一个新的线程，把服务端Socket的描述发给客户端，一旦客户端确认了此描述，连接就好了。而服务端Socket继续处于监听状态，继续接收其他客户端套接字的连接请求

  1. package com.atguigu.java2;
  3. import org.junit.Test;
  5. import java.io.*;
  6. import java.net.InetAddress;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  10. /*
  11. 实现TCP的网络编程
  12. 例子1：客户端发送信息给服务端，服务端将数据显示在控制台上
  13.  */
  14. public class TCPTest1 {
  15.     //客户端
  16.     @Test
  17.     public void client() {
  18.         Socket socket = null;
  19.         OutputStream os = null;
  20.         try {
  21.             //1、创建Socket对象，指明服务器短的IP和端口号
  22.             InetAddress inet = InetAddress.getByName("127.0.0.1");
  23.             socket = new Socket(inet, 9900);
  24.             //2、获取一个输出流，用于输出数据
  25.             os = socket.getOutputStream();
  26.             //3、写出数据的操作
  27.             os.write("你好，我是客户端mm".getBytes());
  28.         } catch (IOException e) {
  29.             e.printStackTrace();
  30.         } finally {
  31.             //4、资源关闭
  32.             if (os != null) {
  33.                 try {
  34.                     os.close();
  35.                 } catch (IOException e) {
  36.                     e.printStackTrace();
  37.                 }
  38.             }
  39.             if (socket != null) {
  40.                 try {
  41.                     socket.close();
  42.                 } catch (IOException e) {
  43.                     e.printStackTrace();
  44.                 }
  45.             }
  46.         }
  48.     }
  50.     //服务端
  51.     @Test
  52.     public void server() {
  53.         ServerSocket ss = null;
  54.         Socket socket = null;
  55.         InputStream is = null;
  56.         ByteArrayOutputStream baos = null;
  57.         try {
  58.             //1、创建服务器端的ServerSocket，指明自己的端口号
  59.             ss = new ServerSocket(9900);
  60.             //2、调用accept表明接收来自客户端的socket
  61.             socket = ss.accept();
  62.             //3、获取输入流
  63.             is = socket.getInputStream();
  64.             //不建议这样写，可能会有乱码
  65.         /*byte[] buffer = new byte[20];
  66.         int len;
  67.         while ((len=is.read())!=-1){
  68.             String str = new String(buffer,0,len);
  69.             System.out.println(str);
  70.         }*/
  71.             //4、读取输入流中的数据
  72.             baos = new ByteArrayOutputStream();
  73.             byte[] buffer = new byte[100];
  74.             int len;
  75.             while ((len = is.read(buffer)) != -1) {
  76.                 baos.write(buffer, 0, len);
  77.             }
  78.             System.out.println(baos.toString());
  79.             System.out.println("收到了来自于："+socket.getInetAddress().getHostAddress()+"的数据");
  80.         } catch (IOException e) {
  81.             e.printStackTrace();
  82.         } finally {
  83.             if (baos != null) {
  84.                 try {
  85.                     baos.close();
  86.                 } catch (IOException e) {
  87.                     e.printStackTrace();
  88.                 }
  89.             }
  90.             if (is != null) {
  91.                 try {
  92.                     is.close();
  93.                 } catch (IOException e) {
  94.                     e.printStackTrace();
  95.                 }
  96.             }
  97.             if (socket != null) {
  98.                 try {
  99.                     socket.close();
  100.                 } catch (IOException e) {
  101.                     e.printStackTrace();
  102.                 }
  103.             }
  104.             if (ss != null) {
  105.                 try {
  106.                     ss.close();
  107.                 } catch (IOException e) {
  108.                     e.printStackTrace();
  109.                 }
  110.             }
  112.         }
  113.     }
  114. }
  1. package com.atguigu.java2;
  3. import org.junit.Test;
  5. import java.io.*;
  6. import java.net.InetAddress;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  9. import java.net.UnknownHostException;
  11. /*
  12. 实现TCP的网络编程
  13. 例子2：客户端发送文件给服务端，服务端将文件保存在本地。
  14.  */
  15. public class TCPTest2 {
  17.     @Test
  18.     public void client(){
  19.         Socket socket = null;
  20.         OutputStream os = null;
  21.         FileInputStream fis = null;
  22.         try {
  23.             //1、
  24.             socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090);
  25.             //2、
  26.             os = socket.getOutputStream();
  27.             //3、
  28.             fis = new FileInputStream(new File("java学习路线图.png"));
  29.             //4、
  30.             byte[] buffer = new byte[1024];
  31.             int len;
  32.             while ((len = fis.read(buffer)) != -1) {
  33.                 os.write(buffer, 0, len);
  34.             }
  35.         } catch (IOException e) {
  36.             e.printStackTrace();
  37.         } finally {
  38.             if (fis!=null){
  39.                 try {
  40.                     fis.close();
  41.                 } catch (IOException e) {
  42.                     e.printStackTrace();
  43.                 }
  44.             }
  45.             if (os!=null){
  46.                 try {
  47.                     os.close();
  48.                 } catch (IOException e) {
  49.                     e.printStackTrace();
  50.                 }
  51.             }
  52.             if (socket!=null){
  53.                 try {
  54.                     socket.close();
  55.                 } catch (IOException e) {
  56.                     e.printStackTrace();
  57.                 }
  58.             }
  59.         }
  60.     }
  62.     @Test
  63.     public void server(){
  64.         ServerSocket ss = null;
  65.         Socket socket = null;
  66.         InputStream is = null;
  67.         FileOutputStream fos = null;
  68.         try {
  69.             ss = new ServerSocket(9090);
  70.             socket = ss.accept();
  71.             is = socket.getInputStream();
  72.             fos = new FileOutputStream(new File("java学习路线图1.png"));
  73.             byte[] buffer = new byte[1024];
  74.             int len;
  75.             while ((len = is.read(buffer))!=-1){
  76.                 fos.write(buffer,0,len);
  77.             }
  78.         } catch (IOException e) {
  79.             e.printStackTrace();
  80.         }finally {
  81.             if (fos!=null){
  82.                 try {
  83.                     fos.close();
  84.                 } catch (IOException e) {
  85.                     e.printStackTrace();
  86.                 }
  87.             }
  88.             if (is!=null){
  89.                 try {
  90.                     is.close();
  91.                 } catch (IOException e) {
  92.                     e.printStackTrace();
  93.                 }
  94.             }
  95.             if (socket!=null){
  96.                 try {
  97.                     socket.close();
  98.                 } catch (IOException e) {
  99.                     e.printStackTrace();
  100.                 }
  101.             }
  102.             if (ss!=null){
  103.                 try {
  104.                     ss.close();
  105.                 } catch (IOException e) {
  106.                     e.printStackTrace();
  107.                 }
  108.             }
  109.         }
  115.     }
  116. }
  1. package com.atguigu.java2;
  3. import org.junit.Test;
  5. import java.io.*;
  6. import java.net.InetAddress;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  10. /*
  11. 例题3：从客户端发送文件给服务端，服务端保存到本地。并返回“发送成功”给客户端。
  12. 并关闭相应的连接。
  13.  */
  14. public class TCPTest3 {
  15.     @Test
  16.     public void client() {
  17.         Socket socket = null;
  18.         OutputStream os = null;
  19.         FileInputStream fis = null;
  20.         InputStream is = null;
  21.         ByteArrayOutputStream baos = null;
  22.         try {
  23.             //1、
  24.             socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090);
  25.             //2、
  26.             os = socket.getOutputStream();
  27.             //3、
  28.             fis = new FileInputStream(new File("java学习路线图.png"));
  29.             //4、
  30.             byte[] buffer = new byte[1024];
  31.             int len;
  32.             while ((len = fis.read(buffer)) != -1) {
  33.                 os.write(buffer, 0, len);
  34.             }
  35.             //关闭数据的输出
  36.             socket.shutdownOutput();
  37.             //接收来自服务器端的数据，并显示到控制台上
  38.             is = socket.getInputStream();
  40.             baos = new ByteArrayOutputStream();
  41.             byte[] buffer2 = new byte[20];
  42.             int len2;
  43.             while ((len2 = is.read(buffer2)) != -1) {
  44.                 baos.write(buffer2, 0, len2);
  45.             }
  46.             System.out.println(baos.toString());
  47.         } catch (IOException e) {
  48.             e.printStackTrace();
  49.         } finally {
  50.             if (fis != null) {
  51.                 try {
  52.                     fis.close();
  53.                 } catch (IOException e) {
  54.                     e.printStackTrace();
  55.                 }
  56.             }
  57.             if (os != null) {
  58.                 try {
  59.                     os.close();
  60.                 } catch (IOException e) {
  61.                     e.printStackTrace();
  62.                 }
  63.             }
  64.             if (socket != null) {
  65.                 try {
  66.                     socket.close();
  67.                 } catch (IOException e) {
  68.                     e.printStackTrace();
  69.                 }
  70.             }
  71.             if (is != null) {
  72.                 try {
  73.                     is.close();
  74.                 } catch (IOException e) {
  75.                     e.printStackTrace();
  76.                 }
  77.             }
  78.             if (baos != null) {
  79.                 try {
  80.                     baos.close();
  81.                 } catch (IOException e) {
  82.                     e.printStackTrace();
  83.                 }
  84.             }
  85.         }
  86.     }
  88.     @Test
  89.     public void server() {
  90.         ServerSocket ss = null;
  91.         Socket socket = null;
  92.         InputStream is = null;
  93.         FileOutputStream fos = null;
  94.         OutputStream os = null;
  95.         try {
  96.             ss = new ServerSocket(9090);
  97.             socket = ss.accept();
  98.             is = socket.getInputStream();
  99.             fos = new FileOutputStream(new File("java学习路线图2.png"));
  100.             byte[] buffer = new byte[1024];
  101.             int len;
  102.             while ((len = is.read(buffer)) != -1) {
  103.                 fos.write(buffer, 0, len);
  104.             }
  105.             System.out.println("图片传输完成");
  106.             //服务器端给客户端反馈
  107.             os = socket.getOutputStream();
  108.             os.write("你好，客户，照片我已经收到了，非常漂亮".getBytes());
  109.         } catch (IOException e) {
  110.             e.printStackTrace();
  111.         } finally {
  112.             if (fos != null) {
  113.                 try {
  114.                     fos.close();
  115.                 } catch (IOException e) {
  116.                     e.printStackTrace();
  117.                 }
  118.             }
  119.             if (is != null) {
  120.                 try {
  121.                     is.close();
  122.                 } catch (IOException e) {
  123.                     e.printStackTrace();
  124.                 }
  125.             }
  126.             if (socket != null) {
  127.                 try {
  128.                     socket.close();
  129.                 } catch (IOException e) {
  130.                     e.printStackTrace();
  131.                 }
  132.             }
  133.             if (ss != null) {
  134.                 try {
  135.                     ss.close();
  136.                 } catch (IOException e) {
  137.                     e.printStackTrace();
  138.                 }
  139.             }
  140.             if (os != null) {
  141.                 try {
  142.                     os.close();
  143.                 } catch (IOException e) {
  144.                     e.printStackTrace();
  145.                 }
  146.             }
  147.         }
  148.     }
  149. }

PPT36页，练习题可以试试。

  1. package com.atguigu.java2;
  3. import org.junit.Test;
  5. import java.io.IOException;
  6. import java.net.*;
  8. /*
  9. UDPd协议的网络编程
  11.  */
  12. public class UDPTest {
  13.     //发送端
  14.     @Test
  15.     public void test1() throws IOException {
  16.         DatagramSocket socket = new DatagramSocket();
  17.         String str = "我是UDP方式发送的导弹";
  18.         byte[] data = str.getBytes();
  19.         InetAddress inet = InetAddress.getLocalHost();
  20.         DatagramPacket packet = new DatagramPacket(data,data.length,inet,9090);
  21.         socket.send(packet);
  22.         socket.close();
  23.     }
  24.     //接收端
  25.     @Test
  26.     public void test2() throws IOException {
  27.         DatagramSocket socket = new DatagramSocket(9090);
  28.         byte[] buffer = new byte[100];
  29.         DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);
  30.         socket.receive(packet);
  31.         System.out.println(new String(packet.getData(),0,packet.getLength()));
  32.         socket.close();
  33.     }
  34. }
  1. package com.atguigu.java2;
  3. import java.net.MalformedURLException;
  4. import java.net.URL;
  6. /*
  7.  URL网络编程
  8.  1、URL(Uniform Resource Locator)：统一资源定位符，它表示 Internet 上某一资源的地址。
  9.  2、格式：
  10.  http://localhost:8080/example/beauty.jpg?username=Tom
  11.  协议    主机名  端口号 资源地址           参数列表
  12.  */
  13. public class URLTest {
  14.     public static void main(String[] args){
  15.         try {
  16.             URL url = new URL("http://localhost:8080/example/beauty.jpg?username=Tom");
  17. //        public String getProtocol( ) 获取该URL的协议名
  18.             System.out.println(url.getProtocol());//http
  19. //        public String getHost( ) 获取该URL的主机名
  20.             System.out.println(url.getHost());//localhost
  21. //        public String getPort( ) 获取该URL的端口号
  22.             System.out.println(url.getPort());//8080
  23. //        public String getPath( ) 获取该URL的文件路径
  24.             System.out.println(url.getPath());///example/beauty.jpg
  25. //        public String getFile( ) 获取该URL的文件名
  26.             System.out.println(url.getFile());///example/beauty.jpg?username=Tom
  27. //        public String getQuery( ) 获取该URL的查询名
  28.             System.out.println(url.getQuery());//username=Tom
  29.         } catch (MalformedURLException e) {
  30.             e.printStackTrace();
  31.         }
  32.     }
  33. }
  1. package com.atguigu.java2;
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.net.HttpURLConnection;
  7. import java.net.MalformedURLException;
  8. import java.net.URL;
  9. import java.net.URLConnection;
  11. public class URLTest1 {
  12.     public static void main(String[] args){
  13.         HttpURLConnection urlConnection = null;
  14.         InputStream is = null;
  15.         FileOutputStream fos = null;
  16.         try {
  17. //            URL url = new URL("http://localhost:8080/example/beauty.jpg");
  18.             URL url = new URL("https://cn.bing.com/images/search?view=detailV2&ccid=JQ%2bVhVrs&id=FCAE6777DDD995B9CF11C3FEF6D5D753230E0706&thid=OIP.JQ-VhVrsScl0rLNrPtMlcQHaE8&mediaurl=https%3a%2f%2ftse1-mm.cn.bing.net%2fth%2fid%2fR-C.250f95855aec49c974acb36b3ed32571%3frik%3dBgcOI1PX1fb%252bww%26riu%3dhttp%253a%252f%252fwww.desktx.com%252fd%252ffile%252fwallpaper%252fscenery%252f20170120%252f387b1a5181ebeddbec90fd5f19e606ce.jpg%26ehk%3dFeb%252bz1leZKOVuTS20av3z7LKELRP0HH277cc6aSrAeI%253d%26risl%3d%26pid%3dImgRaw%26r%3d0&exph=1334&expw=2000&q=%e5%9b%be%e7%89%87&simid=608018209402674333&FORM=IRPRST&ck=77D525DA175DD85099F2804D96188A98&selectedIndex=0&ajaxhist=0&ajaxserp=0");
  19.             urlConnection = (HttpURLConnection) url.openConnection();
  20.             urlConnection.connect();
  21.             is = urlConnection.getInputStream();
  22.             fos = new FileOutputStream("Day26\\beauty2.jpg");
  23.             byte[] buffer = new byte[1024];
  24.             int len;
  25.             while ((len = is.read(buffer))!=-1){
  26.                 fos.write(buffer,0,len);
  27.             }
  28.             System.out.println("下载完成");
  29.         } catch (IOException e) {
  30.             e.printStackTrace();
  31.         } finally {
  32.             if (fos!=null){
  33.                 try {
  34.                     fos.close();
  35.                 } catch (IOException e) {
  36.                     e.printStackTrace();
  37.                 }
  38.             }
  39.             if (is!=null){
  40.                 try {
  41.                     is.close();
  42.                 } catch (IOException e) {
  43.                     e.printStackTrace();
  44.                 }
  45.             }
  46.             if (urlConnection!=null){
  47.                 urlConnection.disconnect();
  48.             }
  49.         }
  54.     }
  55. }

尚硅谷宋红康第14章_网络编程.pdf