JavaSE9-11学习总结（字节流，字符流，缓冲流，转换流，序列化，打印流，网络编程）

9、IO流的顶级父类

	输入流	输出流
字节流	字节输入流InputStream	字节输出流OutputStream
字符流	字符输入流Reader	字节输出流Writer

一、字节流

1.1 字节输出流【OutputStream】（所有字节输出流的超类。抽象类）

它的方法为字节输出流的基本共性功能方法

public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
public void write(byte[] b) ：将 b.length字节从指定的字节数组写入此输出流。
public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
public abstract void write(int b) ：将指定的字节输出流。

1.2 FileOutputStream类（文件输出流）

构造方法

public FileOutputStream(File file) ：创建文件输出流以写入由指定的 File对象表示的文件。
public FileOutputStream(String name) ： 创建文件输出流以指定的名称写入文件。

以下两个构造方法可以选择文件复写或续写

append：true 表示追加数据， false 表示清空原有数据
public FileOutputStream(File file, boolean append) ： 创建文件输出流以写入由指定的 File对象表示的文件。
public FileOutputStream(String name, boolean append) ： 创建文件输出流以指定的名称写入文件。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

方法

write(int b) 方法，每次可以写出一个字节数据

FileOutputStream fos = new FileOutputStream("fos.txt");     
       // 写出数据   
       fos.write(97); // 写出第1个字节 "a"
       fos.write(98); // 写出第2个字节 "b"  
       fos.write(99); // 写出第3个字节 "c"
       // 关闭资源   
        fos.close();

write(byte[] b) ，每次可以写出数组中的数据

byte[] b = "黑马程序员".getBytes();	//String的getBytes方法可快速得到字节数组
fos.write("\r\n".getBytes());	//\r 代表回车\n 代表换行 在windows系统中代表换行

write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节

1.3 字节输入流【InputStream】（所有字节输入流的超类。抽象类）

它的方法为字节输入流的基本共性功能方法

public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
public abstract int read() ： 从输入流读取数据的下一个字节。
public int read(byte[] b) ： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

1.4 FileInputStream类（文件输入流）

构造方法：

FileInputStream(File file) ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
FileInputStream(String name) ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

方法

read() 方法 ，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回 -1
read(byte[] b) ，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回 -1

public static void main(String[] args) throws IOException{
       // 使用文件名称创建流对象.   
        FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde  
       // 定义变量，作为有效个数   
        int len ；
        // 定义字节数组，作为装字节数据的容器   
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=‐1) {
            // 每次读取后,把数组的有效字节部分，变成字符串打印  
            System.out.println(new String(b，0，len));//  len 每次读取的有效字节个数
        }
		// 关闭资源         
        fis.close();
    }

字节流读取文本文件,尤其是中文,虽然可以用String类的构造方法String(byte[] bytes, int offset, int length, Charset charset) 将字节数组转换为字符串。但是是不推荐的,因为,不知道几个字节组成一个中文!!!用字符流更好

二、字符流

2.1 字符输入流【Reader】（用于读取字符流的所有类的超类，抽象类）

public void close() ：关闭此流并释放与此流相关联的任何系统资源。
public int read() ： 从输入流读取一个字符。
public int read(char[] cbuf) ： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

2.2 FileReader (读取字符文件的便利类。)

构造方法

构造时使用系统默认的字符编码（widows为GBK，IDEA为UTF8）和默认字节缓冲区。

FileReader(File file) ： 创建一个新的 FileReader ，给定要读取的File对象。
FileReader(String fileName) ： 创建一个新的 FileReader ，给定要读取的文件的名称。
注意 必须保证文件存在才可以读，且文件编码为非二进制（记事本打开不乱码）

方法

read() ，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回 -1,自动向下一位读取。
read(char[] cbuf) ，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回 -1

public static void main(String[] args) throws IOException {
       // 使用文件名称创建流对象   
        FileReader fr = new FileReader("read.txt");  
       // 定义变量，保存有效字符个数   
        int len ；
        // 定义字符数组，作为装字符数据的容器
        char[] cbuf = new char[2];	//建议1024*8,
        // 循环读取
        while ((len = fr.read(cbuf))!=‐1) {
            System.out.println(new String(cbuf,0,len));//String类的构造方法，截取一定长度字符数组并转为字符串
        }
     	// 关闭资源     
        fr.close();
    }

2.3 字符输出流【Writer】（用于输出字符流的所有类的超类，抽象类）

方法

void write(int c) 写入单个字符。
void write(char[] cbuf) 写入字符数组。
abstract void write(char[] cbuf, int off, int len) 写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
void write(String str) 写入字符串。
void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
void flush() 刷新该流的缓冲，将缓冲区的数据刷新到硬盘上。
void close() 关闭此流，但要先刷新它。如果流没有关闭，数据只会保存到缓冲区，而不是硬盘上。

2.4 FileWriter (写出字符到文件的便利类。)

构造时使用系统默认的字符编码和默认字节缓冲区。

构造方法

FileWriter(File file) ： 创建一个新的 FileWriter，给定要读取的File对象。
FileWriter(String fileName) ： 创建一个新的 FileWriter，给定要读取的文件的名称。

方法

write(int b) 方法，每次可以写出一个字符数据
write(char[] cbuf) 和 write(char[] cbuf, int off, int len) 每次可以写出字符数组中的数据，用法类似FileOutputStream
write(String str) 和 write(String str, int off, int len) ，每次可以写出字符串中的数据

字符流，只能操作文本文件，不能操作图片，视频等非文本文件

10.1.缓冲流

字节缓冲流： BufferedInputStream ， BufferedOutputStream
字符缓冲流： BufferedReader ， BufferedWriter

1、字节缓冲流

基本原理：是在创建流对象时，会创建一个内置的默认大小（1024 * 8）的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率

public static void main(String[] args) throws FileNotFoundException {
       // 记录开始时间   
        long start = System.currentTimeMillis();
// 创建流对象         
        try (
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));             
 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));         
        ){
           // 读写数据   
            int len;
            byte[] bytes = new byte[8*1024];
            while ((len = bis.read(bytes)) != ‐1) {
                bos.write(bytes, 0 , len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
// 记录结束时间         
        long end = System.currentTimeMillis();
        System.out.println("缓冲流使用数组复制时间:"+(end ‐ start)+" 毫秒");
    }

缓冲流使用数组复制时间:666 毫秒
//缓冲流+数组的方式在传字符时速度最快

2、缓冲字符流

BufferedWriter【缓冲输出流】

构造: BufferedWriter(Writer writer); 1024 * 8

// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

成员方法:
void close();
flush();
write(char[] arr ); —>写一个字符数组到硬盘上的文件中
write(int c); —>写一个字符数据
write(char[] arr,int start, int length);—>写一个字符数组的一部分到硬盘上的文件中
write(String str); —>可以写字符串
write(String str,int start,int len);写字符串的一部分
newLine(); —>根据操作系统写出对应的换行符，由系统属性定义符号

BufferedWriter【缓冲输出流】

构造:BufferedReader(Reader reader); 1024 * 8

// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));

成员方法:
void close();
int read(); —>一次读一个字符,返回的是字符对应的整数表现形式
int read(char[] arr); 一次读多个字符,返回的读取的有效个数
String readLine(); —>读取一行数据,但是不读取换行符号在读取到最后没有数据的一行时，会返回null而不是-1

//描述:
//  请将文本信息恢复顺序。
//2.宫中府中，俱为一体，陟罚臧否，不宜异同。
//1.先帝创业未半而中道崩殂，
//3.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。
//5.亲贤臣，远小人，此先汉所以兴隆也；
//4.将军向宠，性行淑均，晓畅军事，试用之于昔日，先帝称之曰能，是以众议举宠为督。
//
//找规律，明显每一句在开头的编号和和正文以“.”隔开，使用spilt将两部分分割
ublic class BufferedTest {
    public static void main(String[] args) throws IOException {
        // 创建map集合,保存文本数据,键为序号,值为文字
        HashMap<String, String> lineMap = new HashMap<>();
 
        // 创建流对象
        BufferedReader br = new BufferedReader(new FileReader("in.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
 
        // 读取数据
        String line  = null;
        while ((line = br.readLine())!=null) {	//判断是否是最后一行
            // 解析文本
            String[] split = line.split("\\.");
            // 保存到集合
            lineMap.put(split[0],split[1]);
        }
        // 释放资源
        br.close();
 
        // 遍历map集合
        for (int i = 1; i <= lineMap.size(); i++) {
            String key = String.valueOf(i);	//将int值转换为String类型
            // 获取map中文本
            String value = lineMap.get(key);
           // 写出拼接文本   
            bw.write(key+"."+value);
           // 写出换行   
            bw.newLine();
        }
// 释放资源         
        bw.close();
    }
}

10.2 转换流

字符编码 Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。

字符集 Charset ：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。（ASCII字符集，ISO-8859-1字符集，GBxxx字符集，Unicode字符集）

Windows系统的默认是GBK编码，IDEA都是默认的 UTF-8 编码，

当在idea中读取Windows系统中创建的文本文件时，就会出现乱码。

构造：

InputStreamReader(InputStream in) : 创建一个使用默认字符集的字符流。
InputStreamReader(InputStream in, String charsetName) : 创建一个指定字符集的字符流。

InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

OutputStreamWriter(OutputStream in) : 创建一个使用默认字符集的字符流。
OutputStreamWriter(OutputStream in, String charsetName) : 创建一个指定字符集的字符流。

OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

10.3 序列化

用一个字节序列可以表示一个对象，该字节序列包含该对象的数据 、 对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。(一般会有较多乱码)

对象输出

构造

public ObjectOutputStream(OutputStream out) ： 创建一个指定OutputStream的ObjectOutputStream。将Java对象的原始数据类型写出到文件,实现对象的持久存储。

ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));

方法

public final void writeObject (Object obj) : 将指定的对象写出。

注意事项：

一个对象要想序列化，必须满足两个条件:
该类必须实现 java.io.Serializable 接口， Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出 NotSerializableException 。（）
该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。（也可用static修饰）

对象写入

构造

public ObjectInputStream(InputStream in) ： 创建一个指定InputStream的ObjectInputStream。将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

方法

public final Object readObject() : 读取一个对象。

注意事项

当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个 InvalidClassException 异常。发生这个异常的原因如下：
该类的序列版本号与从流中读取的类描述符的版本号不匹配
该类包含未知数据类型
该类没有可访问的无参数构造方法

可以在创建对象的时候就为其赋值一个serialVersionUID 的版本号，之后在对对象有什么更改都会成功反序列化。（private static final long serialVersionUID = 1243121L;）在对象已经序列化后再为其赋值版本号后，在反序列化定会因为序列号不同失败！

public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("student.txt"));
        wirte();	//调用序列化
        Object o = ois.readObject();		//也可以在这里直接强转为ArrayList。 (ArrayList<Student>)ois.readObject();）
        System.out.println(o);	//会自动调用list的toString方法和Student的toString方法
        ois.close();
    }

    private static void wirte() throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("student.txt"));
        ArrayList<Student> al = new ArrayList<>();
        al.add(new Student("张三",18));
        al.add(new Student("李四",99));
        al.add(new Student("王五",67));
        
        oos.writeObject(al);	//序列化封装为ArrayList的Student对象们
        oos.close();
    }

10.4 打印流

构造

public PrintStream(String fileName) ： 使用指定的文件名创建一个新的打印流。
PrintStream(OutputStream out);需要一个字节流
PrintStream(OutputStream out, boolean autoFlush) ；自动刷新

方法

write(int len); —>一次写一个字节
write(byte[] arr) —>字节数组,和字节一部分
print(); —>写出任何数据,保持原样
println()—>写出任何数据,保持原样,并且换行
void close();

特点: 既可以写字节数据(write),还可以写字符数据(println)；尤其可以自动刷新出存储在缓冲区中的数据，在即时通信中很好用！

11 网络编程

c/s结构

全称为Client/Server结构，是指客户端和服务器结构。

B/S结构

全称为Browser/Server结构，是指浏览器和服务器结构。

网络编程，就是在一定的协议下，实现两台计算机的通信的程序。（服务器实际也是一台计算机）

1、网络连接协议

TCP/IP协议： 传输控制协议/因特网互联协议( Transmission Control Protocol/Internet Protocol)，是Internet最基本、最广泛的协议。它定义了计算机如何连入因特网，以及数据如何在它们之间传输的标准。它的内部包含一系列的用于处理数据通信的协议，并采用了4层的分层模型，每一层都呼叫它的下一层所提供的协议来完成自己的需求。

TCP：传输控制协议 (Transmission Control Protocol)。TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。
三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。

第一次握手，客户端向服务器端发出连接请求，等待服务器确认。
第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。
第三次握手，客户端再次向服务器端发送确认收到服务器的回应信息，确认连接。

---

ACK ： TCP协议规定，只有ACK=1时有效，也规定连接建立后所有发送的报文的ACK必须为1
SYN(SYNchronization) ： 在连接建立时用来同步序号。当SYN=1而ACK=0时，表明这是一个连接请求报文。对方若同意建立连接，则应在响应报文中使SYN=1和ACK=1. 因此, SYN置1就表示这是一个连接请求或连接接受报文。
FIN （finis）即完，终结的意思， 用来释放一个连接。当 FIN = 1 时，表明此报文段的发送方的数据已经发送完毕，并要求释放连接。

三次握手：

TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。

1.第一次握手：建立连接。客户端发送连接请求报文段，将SYN设置为1，Seqr为x;然后，客户端进入SYN_SEND状态，等待服务器的确认;

2.第二次握手：服务器收到客户端的SYN报文段，需要对这个SYN报文段进行确认，设置Ack为x+1(Seq+1);同时，自己自己还要发送SYN请求信息，将SYN位置为1，Seq为y;服务器端将上述所有信息放到一个报文段(即SYN+ACK报文段)中，一并发送给客户端，此时服务器进入SYN_RECV状态;

3.第三次握手：客户端收到服务器的SYN+ACK报文段。然后将Ack设置为y+1，向服务器发送ACK确认连接报文段，这个报文段发送完毕以后，客户端和服务器端都进入ESTABLISHED状态，完成TCP三次握手。

四次挥手：

1.第一次挥手：主机1(可以是客户端，也可以是服务器端)，设置Seq和Ack，向主机2发送一个FIN报文段;此时，主机1进入FIN_WAIT_1状态;这表示主机1没有数据要发送给主机2了;

2.第二次挥手：主机2收到了主机1发送的FIN报文段，向主机1回一个ACK报文段，Ack为Seq加1;主机1进入FIN_WAIT_2状态;主机2告诉主机1，我也没有数据要发送了，可以进行关闭连接了;

3.第三次挥手：主机2向主机1发送FIN报文段，请求关闭连接，同时主机2进入CLOSE_WAIT状态;

4.第四次挥手：主机1收到主机2发送的FIN报文段，主机1向主机2发送ACK报文段，表示收到并进入TIME_WAIT状态;主机2收到主机1的ACK报文段以后，主机2就关闭连接;此时，主机1等待2MSL后依然没有收到回复，则证明Server端已正常关闭，那好，主机1也可以关闭连接了。

UDP：用户数据报协议(User Datagram Protocol)。UDP协议是一个面向无连接的协议。传输数据时，不需要建立连接，不管对方端服务是否启动，直接将数据、数据源和目的地都封装在数据包中，直接发送。每个数据包的大小限制在64k以内。它是不可靠协议，因为无连接，所以传输速度快，但是容易丢失数据。日常应用中,例如视频会议、QQ聊天等。

2、网络编程三要素

协议、IP地址、端口号

IP地址：指互联网协议地址（Internet Protocol Address），俗称IP。IP地址用来给一个网络中的计算机设备做唯一的编号。
IP地址分类：
IPv4：是一个32位的二进制数，通常被分为4个字节，表示成 a.b.c.d 的形式，例如 192.168.65.100 。其中a、b、c、d都是0~255之间的十进制整数，那么最多可以表示42亿个。
IPv6：由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。为了扩大地址空间，拟通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，表示成 ABCD:EF01:2345:6789:ABCD:EF01:2345:6789 。
端口号：用两个字节表示的整数，它的取值范围是0-65535（256*256）。其中，0-1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败

3、TCP通信程序

TCP通信的步骤：

1. 服务端程序，需要事先启动，等待客户端的连接。
2. 客户端主动连接服务器端，连接成功才能通信。服务端不可以主动连接客户端。

在Java中，提供了两个类用于实现TCP通信程序：

1. 客户端： java.net.Socket 类表示。创建 Socket 对象，向服务端发出连接请求，服务端响应请求，两者建立连接开始通信。
2. 服务端： java.net.ServerSocket 类表示。创建 ServerSocket 对象，相当于开启一个服务，并等待客户端的连接。

socket类

构造方法：

public Socket(String host, int port) :创建套接字对象并将其连接到指定主机上的指定端口号。如果指定的host是null ，则相当于指定地址为回送地址。

成员方法：

public InputStream getInputStream() ： 返回此套接字的输入流。
如果此Scoket具有相关联的通道，则生成的InputStream 的所有操作也关联该通道。
关闭生成的InputStream也将关闭相关的Socket。

public g etOutputStream() ： 返回此套接字的输出流。
如果此Scoket具有相关联的通道，则生成的OutputStream 的所有操作也关联该通道。
关闭生成的OutputStream也将关闭相关的Socket。

public void close() ：关闭此套接字。
一旦一个socket被关闭，它不可再使用。
关闭此socket也将关闭相关的InputStream和OutputStream 。

public void shutdownOutput() ： 禁用此套接字的输出流。
任何先前写出的数据将被发送，随后终止输出流。

ServerSocket类

这个类实现了服务器套接字，该对象等待通过网络的请求。

构造方法

public ServerSocket(int port) ：使用该构造方法在创建ServerSocket对象时，就可以将其绑定到一个指定的端口号上，参数port就是端口号。

成员方法

public Socket accept() ：侦听并接受连接，返回一个新的Socket对象，用于和客户端实现通信。该方法会一直阻塞直到建立连接。

网络编程即时通讯案例：

//服务器端：
	ServerSocket ss = new ServerSocket(9999);
        Socket socket = ss.accept();
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));	
        //缓冲流内置字符转换流，确保不会出现乱码	
        PrintStream pw= new PrintStream(socket.getOutputStream(),true);
	//直接使用输出流，可自动刷新出数据显示
	
	//第一条线程进行发送作业
        new Thread(){
            @Override
            public void run() {
                while (true){		//设置死循环，在任何时刻都可以发送
                    Scanner sc = new Scanner(System.in);
                    pw.println(sc.nextLine());		//输出一行就直接换行，方便接收
                }
            }
        }.start();

	//第二条线程进行接受作业
        new Thread(){
            @Override
            public void run() {
                while (true){
                    try {
                    //Date() 的totoLocaleString()方法已过时，但可以便捷输出当前时间
                        System.out.println(new Date().toLocaleString()+"来自客户端：");
                        System.out.println(br.readLine());
                       //一次读一整行数据
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }


//客户端
public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1",9999);	//与本机的相同端口号建立连接
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        //缓冲流内置字符转换流，确保不会出现乱码	
        PrintStream pw= new PrintStream(socket.getOutputStream(),true);
        Scanner sc = new Scanner(System.in);

        new Thread(){
            @Override
            public void run() {
                while (true){
                    pw.println(sc.nextLine());
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                while (true){
                    try {
                        System.out.println(new Date().toLocaleString()+"来自服务器：");
                        System.out.println(br.readLine());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }

网络编程上传文件案例：

//服务器接收端
ServerSocket serverSocket = new ServerSocket(8899);
        while (true) {
            Socket socket = serverSocket.accept();
            new Thread() {
                @Override
                public void run() {
                    try {
                        InputStream is = socket.getInputStream();       
                        //输入字节流，接收所有传来的数据
                        BufferedReader br =new BufferedReader(new InputStreamReader(is)); 
                        //新建一个缓冲流，套接一个转换流，接收题目，并防止乱码      
                        PrintStream  ps = new PrintStream(socket.getOutputStream(), true);

                        String title = br.readLine();
                        //接收第一段发来的第一行字符串为题目
                        String saveTitle = UUID.randomUUID().toString()+"_"+title;
                        //UUID的randomUUID方法可以根据时间生成一个随机的字符串,永远不重复
                        FileOutputStream fos = new FileOutputStream(new File("C:\\Users\\hs\\Desktop\\新建文件夹\\" + saveTitle));
                        //字节输出流
                        
                        byte[] b = new byte[1024 * 8];
                        int len;
                        while ((len = is.read(b)) != -1) {
                            fos.write(b, 0, len);
                        }
                        ps.print("上传成功！");
                       //向客户端发送完成数据
                        fos.close();
                        ps.close();
                        br.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }.start();
        }
    }




//客户端发送端
public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 8899);
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        PrintStream ps = new PrintStream(socket.getOutputStream(), true);
	//发送第一行字符串为文件标题
        ps.println("扁鹊三连");
	//字节输入流
        FileInputStream fis = new FileInputStream(new File("heima11\\src\\Part3\\扁鹊三连.jpg"));
        byte[] bytes = new byte[1024 * 8];
        int len;
        while ((len = fis.read(bytes)) != -1) {
            ps.write(bytes,0,len);
        }
        socket.shutdownOutput();
	//传输完成后发送一个关闭信息，完成上传
        System.out.println(br.readLine());
	//接收服务器端的完成信号
        br.close();
        ps.close();
        socket.close();
    }