那个学网络编程这块了，要用到IO输入输出流，要编写一个通信程序的客户端和服务端，怎么就理不清用到的流呢，大虾们给理下思路！！！！感激
    这里通信程序就是跟QQ一样的，能收能发的

说真的，我看了不少书，也看了好多辅导机构的视频讲解（包括传智播客自己的）——都没有毕老师这一节说的那么明白！！！不是说毕老师讲的有多好，反正就是简练！！！我就喜欢简练的东西，而且食品中提出的问题都是我之前犯过的而且留下很深的伤痕的，所以得以解决估计这辈子都忘不了了。
楼主要思路，而且要IO流的思路。这个我今天还在论坛中看到有人问同样的问题，而且下面有位童鞋总结的非常好——分层次的（赞一个！）而老毕的四大法则也是非常有用的。下面我就就提论题说一下通信中所用到流的总结。
通信中的IO大多是用来传送字符串的（聊天嘛！）所以对于流的封装甚至可以模板化：

1. //读取流（从物理键盘读出）
   
2. Scanner sc = new Scanner(System.in);
   
3. //读字符串
   
4. String str = sc.next();
   
5. //读取一行
   
6. String line = nextLine();
   
7. //写入流
   
8. PrintWriter out = new PrintWriter(socket.getOutputStream(),true);
   
9. //写入一行（带换行符，自动刷新！）
   
10. out.println("i love java...");

复制代码

这里特别强调的是PrintWriter中的第二个参数，flush（自动刷新）是否为true，默认为false，这个一定要为true，不然就会有莫名的阻塞！！！而且如果读取流是按行读取的，那么就一定要用Println（否则就需要再输出一个换行符（”\r\n“）），这两点曾经非常深深地伤害了我，所以这里希望楼主要切记！

抄三遍你都没思路，你把自己当复印机了?
首先Socket建立通信
然后用它带的功能实现通信，因为你要的是文本传输，所以就要一个转换流，把字节流转换为字符流。
再次，如果要实现两边同时发送信息，Socket的实现机制是阻塞线程的  然后就该用多线程来分别在两边实现接收和输出

哥要思路！！！程序抄三遍了

这是前几天写的一个局域网两台机器相互聊天的功能的代码  你改一下应该就可以了


import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class MyClient {
        public static void main(String[] args ) throws UnknownHostException, IOException{
                Socket s=new Socket("172.28.138.185",30000);
                new ClientIn(s).start();
                 new ClientOut(s).start();
               
        }
       

}
class ClientIn extends Thread{
        Socket s;
        BufferedReader br;
        public ClientIn(Socket s) throws IOException{
                this.s=s;
                br=new BufferedReader(new InputStreamReader(s.getInputStream()));
               
        }
        public void run(){
                try {
                        String str;
                        while((str=br.readLine())!=null){
                                System.out.println(str);
                        }
                       
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }
       
}
class ClientOut extends Thread{
        private Socket s=null;
        BufferedReader br;
        BufferedWriter bw;
        BufferedReader br1;
        public ClientOut(Socket s) throws IOException{
                this.s=s;
                br=new BufferedReader(new InputStreamReader(s.getInputStream()));
                bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
                br1=new BufferedReader(new InputStreamReader(System.in));
                }
        public void run(){
               
                try {
                       
                        String str;
                       
                        while((str=br1.readLine())!=null){
                                bw.write(str);
                                bw.newLine();
                                bw.flush();
                               
                        }
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                finally{
                        try {
                                bw.close();
                        } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                        try {
                                br1.close();
                        } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                }
        }
       
}









import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;

public class MyServer {
        public static ArrayList<Socket> list=new ArrayList();
        public static void main(String[] args) throws IOException{
                ServerSocket ss=new ServerSocket(30000);
                while(true){
                        Socket s=ss.accept();
                        list.add(s);
                        new ServerOut(s).start();
                        new ServerIn(s).start();
                       
                }
        }

}
class ServerOut extends Thread{
        private Socket s=null;
        BufferedReader br;
        BufferedWriter bw;
        BufferedReader br1;
        public ServerOut(Socket s) throws IOException{
                this.s=s;
                br=new BufferedReader(new InputStreamReader(s.getInputStream()));
                bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
                br1=new BufferedReader(new InputStreamReader(System.in));
                }
        public void run(){
                InetAddress ip=s.getInetAddress();
                System.out.println(ip+"已连接.....");
                try {
                        bw.write("您已成功连接服务器");
                        bw.newLine();
                        bw.flush();
                        String str;
                       
                        while((str=br1.readLine())!=null){
                                bw.write(str);
                                bw.newLine();
                                bw.flush();
                               
                        }
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                finally{
                        try {
                                bw.close();
                        } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                        try {
                                br1.close();
                        } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                }
        }
       
       
}
class ServerIn extends Thread{
        Socket s;
        BufferedReader br;
        public ServerIn(Socket s) throws IOException{
                this.s=s;
                br=new BufferedReader(new InputStreamReader(s.getInputStream()));
               
        }
        public void run(){
                try {
                        String str;
                        while((str=br.readLine())!=null){
                                System.out.println(str);
                        }
                       
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }
}

那哥们要编一个客户端的程序，能收发信息（文本），你能给出这个程序的思路么，流会用就是想不起来还有这步

首先吧  Socket提供的流是字节流 比如Socket s=new Scoket() s.getInputStream() s.getOutputStream() 这两个一个输入一个输出，都是字节流 你使用的时候要是需要用自己流的话  直接使用就好了   如果要用字符流  就需要转换了 BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));