1.system.out.write 为什么可以将流里的字符在控制台打印出来
2.java中如何实现从客户端发送文件到服务器端？
3.解析System.outoprinlt();输出语句的奥秘
4.java网络编程 PrintWriter
5.System.out.write和System.out.println
6.java，System.out.println();

system.out.write 为什么可以将流里的字符在控制台打印出来

       你可以看下

       System.out.print的源码。。也就是PrintStream里面print方法的源码。。

       public void print(String s) {

        if (s == null) {

        s = "null";

        }

        write(s);

        }

       就是调用的write方法而已。。ipsectools源码解析

       所以你那个System.out.write(i);和System.out.print(i)是一样 的哈

java中如何实现从客户端发送文件到服务器端？

       服务器端源码：

       import java.io.BufferedReader;

       import java.io.File;

       import java.io.FileNotFoundException;

       import java.io.FileOutputStream;

       import java.io.IOException;

       import java.io.InputStream;

       import java.io.InputStreamReader;

       import java.net.ServerSocket;

       import java.net.Socket;

       /

        * 文件名：ServerReceive.java

        * 实现功能：作为服务器接收客户端发送的文件

        * 具体实现过程：

        * 1、建立SocketServer，等待客户端的连接

        * 2、当有客户端连接的时候，按照双方的约定，这时要读取一行数据

        * 其中保存客户端要发送的文件名和文件大小信息

        * 3、根据文件名在本地创建文件，并建立好流通信

        * 4、循环接收数据包，小米lot源码将数据包写入文件

        * 5、当接收数据的长度等于提前文件发过来的文件长度，即表示文件接收完毕，关闭文件

        * 6、文件接收工作结束

       public class ServerReceive {

        public static void main(String[] args) {

        /**与服务器建立连接的通信句柄*/

        ServerSocket ss = null;

        Socket s = null;

        /**定义用于在接收后在本地创建的文件对象和文件输出流对象*/

        File file = null;

        FileOutputStream fos = null;

        /**定义输入流，使用socket的inputStream对数据包进行输入*/

        InputStream is = null;

        /**定义byte数组来作为数据包的存储数据包*/

        byte[] buffer = new byte[ * 5];

        /**用来接收文件发送请求的字符串*/

        String comm = null;

       /**建立socekt通信，等待服务器进行连接*/

        try {

        ss = new ServerSocket();

        s = ss.accept();

        } catch (IOException e) {

        e.printStackTrace();

        }

       /**读取一行客户端发送过来的生态视频源码约定信息*/

        try {

        InputStreamReader isr = new InputStreamReader(s.getInputStream());

        BufferedReader br = new BufferedReader(isr);

        comm = br.readLine();

        } catch (IOException e) {

        System.out.println("服务器与客户端断开连接");

        }

        /**开始解析客户端发送过来的请求命令*/

        int index = comm.indexOf("/#");

        /**判断协议是否为发送文件的协议*/

        String xieyi = comm.substring(0, index);

        if(!xieyi.equals("")){

        System.out.println("服务器收到的协议码不正确");

        return;

        }

        /**解析出文件的名字和大小*/

        comm = comm.substring(index + 2);

        index = comm.indexOf("/#");

        String filename = comm.substring(0, index).trim();

        String filesize = comm.substring(index + 2).trim();

       /**创建空文件，用来进行接收文件*/

        file = new File(filename);

        if(!file.exists()){

        try {

        file.createNewFile();

        } catch (IOException e) {

        System.out.println("服务器端创建文件失败");

        }

        }else{

        /**在此也可以询问是否覆盖*/

        System.out.println("本路径已存在相同文件，进行覆盖");

        }

        /**以上就是客户端代码中写到的服务器的准备部分*/

       /

        * 服务器接收文件的关键代码*/

        try {

        /**将文件包装到文件输出流对象中*/

        fos = new FileOutputStream(file);

        long file_size = Long.parseLong(filesize);

        is = s.getInputStream();

        /**size为每次接收数据包的长度*/

        int size = 0;

        /**count用来记录已接收到文件的长度*/

        long count = 0;

        /**使用while循环接收数据包*/

        while(count < file_size){

        /**从输入流中读取一个数据包*/

        size = is.read(buffer);

        /**将刚刚读取的数据包写到本地文件中去*/

        fos.write(buffer, 0, size);

        fos.flush();

        /**将已接收到文件的长度+size*/

        count += size;

        System.out.println("服务器端接收到数据包，大小为" + size);

        }

        } catch (FileNotFoundException e) {

        System.out.println("服务器写文件失败");

        } catch (IOException e) {

        System.out.println("服务器：客户端断开连接");

        }finally{

        /

        * 将打开的文件关闭

        * 如有需要，也可以在此关闭socket连接

        * */

        try {

        if(fos != null)

        fos.close();

        } catch (IOException e) {

        e.printStackTrace();

        }//catch (IOException e)

        }//finally

        }//public static void main(String[] args)

       }//public class ServerReceive

       客户端源码：

       import java.io.File;

       import java.io.FileInputStream;

       import java.io.FileNotFoundException;

       import java.io.IOException;

       import java.io.OutputStream;

       import java.io.PrintStream;

       import java.net.Socket;

       /

        * 文件名：ClientSend.java

        * 实现功能：作为客户端向服务器发送一个文件

        * 具体实现过程：

        * 1、建立与服务器端的连接，IP：.0.0.1， port：

        * 2、鸿蒙源码水平将文件的名字和大小通过自定义的文件传输协议，发送到服务器

        * 3、循环读取本地文件，将文件打包发送到数据输出流中

        * 4、关闭文件，结束传输

        * */

       public class ClientSend {

        public static void main(String[] args) {

        /**与服务器建立连接的通信句柄*/

        Socket s = null;

        /**定义文件对象，即为要发送的济源来源码文件

        * 如果使用绝对路径，不要忘记使用'/'和'\'的区别

        * 具体区别，请读者自行查询

        * */

        File sendfile = new File("API.CHM");

        /**定义文件输入流，用来打开、读取即将要发送的文件*/

        FileInputStream fis = null;

        /**定义byte数组来作为数据包的存储数据包*/

        byte[] buffer = new byte[ * 5];

        /**定义输出流，使用socket的outputStream对数据包进行输出*/

        OutputStream os = null;

       /**检查要发送的文件是否存在*/

        if(!sendfile.exists()){

        System.out.println("客户端：要发送的文件不存在");

        return;

        }

       /**与服务器建立连接*/

        try {

        s = new Socket(".0.0.1", );

        }catch (IOException e) {

        System.out.println("未连接到服务器");

        }

        /**用文件对象初始化fis对象

        * 以便于可以提取出文件的大小

        * */

        try {

        fis = new FileInputStream(sendfile);

        } catch (FileNotFoundException e1) {

        e1.printStackTrace();

        }

       /**首先先向服务器发送关于文件的信息，以便于服务器进行接收的相关准备工作

        * 具体的准备工作，请查看服务器代码。

        * 发送的内容包括：发送文件协议码（此处为）/#文件名（带后缀名）/#文件大小

        * */

        try {

        PrintStream ps = new PrintStream(s.getOutputStream());

        ps.println("/#" + sendfile.getName() + "/#" + fis.available());

        ps.flush();

        } catch (IOException e) {

        System.out.println("服务器连接中断");

        }

       /

        * 此处睡眠2s，等待服务器把相关的工作准备好

        * 也是为了保证网络的延迟

        * 读者可自行选择添加此代码

        * */

        try {

        Thread.sleep();

        } catch (InterruptedException e1) {

        e1.printStackTrace();

        }

       /**之前的准备工作结束之后

        * 下面就是文件传输的关键代码

        * */

        try {

        /**获取socket的OutputStream，以便向其中写入数据包*/

        os = s.getOutputStream();

        /** size 用来记录每次读取文件的大小*/

        int size = 0;

        /**使用while循环读取文件，直到文件读取结束*/

        while((size = fis.read(buffer)) != -1){

        System.out.println("客户端发送数据包，大小为" + size);

        /**向输出流中写入刚刚读到的数据包*/

        os.write(buffer, 0, size);

        /**刷新一下*/

        os.flush();

        }

        } catch (FileNotFoundException e) {

        System.out.println("客户端读取文件出错");

        } catch (IOException e) {

        System.out.println("客户端输出文件出错");

        }finally{

        /

        * 将打开的文件关闭

        * 如有需要，也可以在此关闭socket连接

        * */

        try {

        if(fis != null)

        fis.close();

        } catch (IOException e) {

        System.out.println("客户端文件关闭出错");

        }//catch (IOException e)

        }//finally

        }//public static void main(String[] args)

       }//public class ClientSend

解析System.outoprinlt();输出语句的奥秘

       解析System.out.println();输出语句的奥秘

       1. 示例代码:

       Object a;

       System.out.println(a);

       该语句调用java.lang.System类的out字段，out是一个PrintStream类型的引用变量。原始代码在java.lang.System中为：

       public final static PrintStream out = null;

       出是“标准字节输出流”。

       2. PrintStream类:

       PrintStream是“打印流”，称为“字节输出流”。有另一种打印流，即PrintWriter，称为“字符输出流”。

       3. 打印Object:

       调用PrintStream类的方法打印Object，并在行末结束。

       4. 方法源码:

       public void println(Object x)。

       解析:

       依赖java.lang.Thread类中的public static Thread currentThread()方法。

       该方法返回当前正在执行的线程对象引用。

       中断线程。

       执行流程如图所示。

       代码中出现的synchronized (this) {

       }

       涉及并发编程中的“锁”问题。

java网络编程 PrintWriter

       ç½‘络编程 输入输出流都用二进制流呗，字符流会出问题，和ftp的命令差不错的概念，如果用字符的，可能会出问题，如果用二进制流肯定不会错

System.out.write和System.out.println

       System.out的类型为PrintStream；

       System.out.println('a'); 实际上调用是PrintStream的println(char c)方法；而println(char c)方法的源代码为：

       public void println(String x) {

        synchronized (this) {

        print(x);

        newLine();

        }

        }

       å¯è§Println调用了print(char c)方法，print(char c)方法的源代码如下：

       public void print(char c) {

       write(String.valueOf(c));

       }

       å¯è§è°ƒç”¨çš„是write(String s)方法，write(String s)的代码为：

       private void write(String s) {

        try {

        synchronized (this) {

        ensureOpen();

        textOut.write(s);

        textOut.flushBuffer();

        charOut.flushBuffer();

        if (autoFlush && (s.indexOf('\n') >= 0))

        out.flush();

        }

        }

        catch (InterruptedIOException x) {

        Thread.currentThread().interrupt();

        }

        catch (IOException x) {

        trouble = true;

        }

        }

       å½“字符串中含有'\n'时会刷新out，此处的out是OutStream对象的实例。println(String s)最后调用newLine() 方法，newLine()的代码如下:

       private void newLine() {

        try {

        synchronized (this) {

        ensureOpen();

        textOut.newLine();

        textOut.flushBuffer();

        charOut.flushBuffer();

        if (autoFlush)

        out.flush();

        }

        }

        catch (InterruptedIOException x) {

        Thread.currentThread().interrupt();

        }

        catch (IOException x) {

        trouble = true;

        }

        }

       newLine()会刷新out。

       System.out.write(a); 调用的是PrintStream.write(int b)方法

       write(int b) 的源代码如下：

        public void write(int b) {

        try {

        synchronized (this) {

        ensureOpen();

        out.write(b);

        if ((b == '\n') && autoFlush)

        out.flush();

        }

        }

        catch (InterruptedIOException x) {

        Thread.currentThread().interrupt();

        }

        catch (IOException x) {

        trouble = true;

        }

        }

       çœ‹è¿‡æºä»£ç åŽåº”该明白两者之间的差异了，println(String s)不但会刷新out，而且还会同时刷新textOut和charOut，而write(int b)只有当b == '\n'时才刷新out。这也是为什么加了System.out.write('\n'); 后就能显示出来了，问题就在于out没有刷新。

       æ¥¼ä¸»çš„第二个问题很好解释，因为在print(String s)中，会刷新textOut和charOut。

       textOut和charOut是什么？看一下PrintStream中的定义：

        private BufferedWriter textOut;

        private OutputStreamWriter charOut;

       textOut和charOut在init(OutputStreamWriter osw)方法中初始化，init(OutputStreamWriter osw)的代码如下：

       private void init(OutputStreamWriter osw) {

       this.charOut = osw;

       this.textOut = new BufferedWriter(osw);

        }

       init()函数在构造函数中被调用

       public PrintStream(OutputStream out, boolean autoFlush) {

        this(autoFlush, out);

        init(new OutputStreamWriter(this));

        }

       å¯è§ï¼ŒtextOut和charOut操作的输出流和out是一样的，因此对textOut和charOut刷新同时刷新了out，因此print(String s)即便没有'\n'，也同样会直接输出出来。

java，System.out.println();

       out是System提供的用于标准输出的流，在没有重定向的情况下，会直接打印到终端，而println这个方式实际上是PrintStream类提供的功能

       é‡å®šå‘错误输出在jdk中有一段说明：

       é€šå¸¸ï¼Œæ­¤æµå¯¹åº”于显示器输出或者由主机环境或用户指定的另一个输出目标。按照惯例，此输出流用于显示错误消息，或者显示那些即使用户输出流（变量 out 的值）已经重定向到通常不被连续监视的某一文件或其他目标，也应该立刻引起用户注意的其他信息。