通过socket获取字节流处理时最初使用的是BufferedReader和PrintWriter  这种方式在解析字符串时是比较方便的 但是在处理字节时不够方便最终还是回归到InputStream和OutputStream方式 不使用缓存直接使用字节流操作，一次传输的字节数据在300字节以内，目前没有测试差距会有多大。

  1. import java.io.BufferedReader;
  2. import java.io.BufferedWriter;
  3. import java.io.IOException;
  4. import java.io.InputStreamReader;
  5. import java.io.OutputStreamWriter;
  6. import java.io.PrintWriter;
  7. import java.net.Socket;
  8. import java.net.UnknownHostException;
  9. import java.util.Arrays;
  10.  
  11. import android.content.Context;
  12. import android.content.SharedPreferences;
  13. import android.os.Handler;
  14. import android.os.Message;
  15. import android.util.Log;
  16.  
  17. public class SocThread extends Thread {
  18.     private String ip = "10.0.0.113";
  19.     private int port = 6666;
  20.     private String TAG = "socket thread";
  21.     private int timeout = 10000;
  22.     int maxsize = 256;
  23.  
  24.     public Socket client = null;
  25.     PrintWriter out;
  26.     BufferedReader in;
  27.     public boolean isRun = true;
  28.     Handler inHandler;
  29.     Handler outHandler;
  30.     Context ctx;
  31.     private String TAG1 = "===Send===";
  32.     SharedPreferences sp;
  33.  
  34.     public SocThread(Handler handlerin, Handler handlerout, Context context) {
  35.         inHandler = handlerin;
  36.         outHandler = handlerout;
  37.         ctx = context;
  38.         MyLog.i(TAG, "创建线程socket");
  39.     }
  40.  
  41.     /**
  42.      * 连接socket服务器
  43.      */
  44.     public void conn() {
  45.  
  46.         try {
  47.             initdate();
  48.             Log.i(TAG, "连接中……");
  49.             client = new Socket(ip, port);
  50.             client.setSoTimeout(timeout);// 设置阻塞时间
  51.             MyLog.i(TAG, "连接成功");
  52.             in = new BufferedReader(new InputStreamReader(
  53.                     client.getInputStream()));
  54.             out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
  55.                     client.getOutputStream())), true);
  56.             MyLog.i(TAG, "输入输出流获取成功");
  57.         } catch (UnknownHostException e) {
  58.             MyLog.i(TAG, "连接错误UnknownHostException 重新获取");
  59.             e.printStackTrace();
  60.             conn();
  61.         } catch (IOException e) {
  62.             MyLog.i(TAG, "连接服务器io错误");
  63.             e.printStackTrace();
  64.         } catch (Exception e) {
  65.             MyLog.i(TAG, "连接服务器错误Exception" + e.getMessage());
  66.             e.printStackTrace();
  67.         }
  68.     }
  69.  
  70.     public void initdate() {
  71.         sp = ctx.getSharedPreferences("SP", ctx.MODE_PRIVATE);
  72.         ip = sp.getString("ipstr", ip);
  73.         port = Integer.parseInt(sp.getString("port", String.valueOf(port)));
  74.         MyLog.i(TAG, "获取到ip端口:" + ip + ";" + port);
  75.     }
  76.  
  77.     /**
  78.      * 实时接受数据
  79.      */
  80.     @Override
  81.     public void run() {
  82.         MyLog.i(TAG, "线程socket开始运行");
  83.         conn();
  84.         MyLog.i(TAG, "1.run开始");
  85.         String line = "";
  86.         while (isRun) {
  87.             try {
  88.                 if (client != null) {
  89.                     MyLog.i(TAG, "2.检测数据");
  90.                     // 以下是按行直接读取字符流
  91.                      while ((line = in.readLine()) != null) {
  92.                      MyLog.i(TAG,
  93.                      "3.getdata" + line + " len=" + line.length());
  94.                      MyLog.i(TAG, "4.start set Message");
  95.                      Message msg = inHandler.obtainMessage();
  96.                      msg.obj = line;
  97.                      inHandler.sendMessage(msg);// 结果返回给UI处理
  98.                      MyLog.i(TAG1, "5.send to handler");
  99.                      }
  100.  
  101.                 } else {
  102.                     MyLog.i(TAG, "没有可用连接");
  103.                     conn();
  104.                 }
  105.             } catch (Exception e) {
  106.                 MyLog.i(TAG, "数据接收错误" + e.getMessage());
  107.                 e.printStackTrace();
  108.             }
  109.         }
  110.     }
  111.  
  112.     /**
  113.      * 发送数据
  114.      *
  115.      * @param mess
  116.      */
  117.     public void Send(String mess) {
  118.         try {
  119.             if (client != null) {
  120.                 MyLog.i(TAG1, "发送" + mess + "至"
  121.                         + client.getInetAddress().getHostAddress() + ":"
  122.                         + String.valueOf(client.getPort()));
  123.                 out.println(mess);//按字符流发送
  124.                 out.flush();
  125.                 MyLog.i(TAG1, "发送成功");
  126.                 Message msg = outHandler.obtainMessage();
  127.                 msg.obj = mess;
  128.                 msg.what = 1;
  129.                 outHandler.sendMessage(msg);// 结果返回给UI处理
  130.             } else {
  131.                 MyLog.i(TAG, "client 不存在");
  132.                 Message msg = outHandler.obtainMessage();
  133.                 msg.obj = mess;
  134.                 msg.what = 0;
  135.                 outHandler.sendMessage(msg);// 结果返回给UI处理
  136.                 MyLog.i(TAG, "连接不存在重新连接");
  137.                 conn();
  138.             }
  139.  
  140.         } catch (Exception e) {
  141.             MyLog.i(TAG1, "send error");
  142.             e.printStackTrace();
  143.         } finally {
  144.             MyLog.i(TAG1, "发送完毕");
  145.  
  146.         }
  147.     }
  148.  
  149.     /**
  150.      * 关闭连接
  151.      */
  152.     public void close() {
  153.         try {
  154.             if (client != null) {
  155.                 MyLog.i(TAG, "close in");
  156.                 in.close();
  157.                 MyLog.i(TAG, "close out");
  158.                 out.close();
  159.                 MyLog.i(TAG, "close client");
  160.                 client.close();
  161.             }
  162.         } catch (Exception e) {
  163.             MyLog.i(TAG, "close err");
  164.             e.printStackTrace();
  165.         }
  166.  
  167.     }
  168. }

原始字节流读取处理如下

  1. package com.example.testsocket;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.BufferedWriter;
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. import java.io.InputStreamReader;
  8. import java.io.OutputStream;
  9. import java.io.OutputStreamWriter;
  10. import java.io.PrintWriter;
  11. import java.net.Socket;
  12. import java.net.UnknownHostException;
  13.  
  14. import android.content.Context;
  15. import android.content.SharedPreferences;
  16. import android.os.Handler;
  17. import android.os.Message;
  18. import android.util.Log;
  19.  
  20. public class SocThread extends Thread {
  21.     private String ip = "10.0.0.113";
  22.     private int port = 6666;
  23.     private String TAG = "socket thread";
  24.     private int timeout = 10000;
  25.     private int maxsize = 256;// 默认接受大小
  26.  
  27.     public Socket client = null;
  28.     // PrintWriter out;
  29.     // BufferedReader in;
  30.     OutputStream out;
  31.     InputStream in;
  32.     public boolean isRun = true;
  33.     Handler inHandler;
  34.     Handler outHandler;
  35.     Context ctx;
  36.     private String TAG1 = "===Send===";
  37.     SharedPreferences sp;
  38.  
  39.     public SocThread(Handler handlerin, Handler handlerout, Context context) {
  40.         inHandler = handlerin;
  41.         outHandler = handlerout;
  42.         ctx = context;
  43.         MyLog.i(TAG, "创建线程socket");
  44.     }
  45.  
  46.     /**
  47.      * 连接socket服务器
  48.      */
  49.     public void conn() {
  50.  
  51.         try {
  52.             initdate();
  53.             Log.i(TAG, "连接中……");
  54.             client = new Socket(ip, port);
  55.             client.setSoTimeout(timeout);// 设置阻塞时间
  56.             MyLog.i(TAG, "连接成功");
  57.             in = client.getInputStream();
  58.             out = client.getOutputStream();
  59.             // 以下在字符流时比较好用
  60.             // in = new BufferedReader(new InputStreamReader(
  61.             // client.getInputStream()));
  62.             // out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
  63.             // client.getOutputStream())), true);
  64.             MyLog.i(TAG, "输入输出流获取成功");
  65.         } catch (UnknownHostException e) {
  66.             MyLog.i(TAG, "连接错误UnknownHostException 重新获取");
  67.             e.printStackTrace();
  68.             conn();
  69.         } catch (IOException e) {
  70.             MyLog.i(TAG, "连接服务器io错误");
  71.             e.printStackTrace();
  72.         } catch (Exception e) {
  73.             MyLog.i(TAG, "连接服务器错误Exception" + e.getMessage());
  74.             e.printStackTrace();
  75.         }
  76.     }
  77.  
  78.     public void initdate() {
  79.         sp = ctx.getSharedPreferences("SP", ctx.MODE_PRIVATE);
  80.         ip = sp.getString("ipstr", ip);
  81.         port = Integer.parseInt(sp.getString("port", String.valueOf(port)));
  82.         MyLog.i(TAG, "获取到ip端口:" + ip + ";" + port);
  83.     }
  84.  
  85.     /**
  86.      * 实时接受数据
  87.      */
  88.     @Override
  89.     public void run() {
  90.         MyLog.i(TAG, "线程socket开始运行");
  91.         conn();
  92.         MyLog.i(TAG, "1.run开始");
  93.         String line = "";
  94.         while (isRun) {
  95.             try {
  96.                 if (client != null) {
  97.                     MyLog.i(TAG, "2.检测数据");
  98.                     byte[] temp = new byte[maxsize];// 默认最带为256
  99.                     int size = 0;
  100.                     while ((size = in.read(temp)) > 0) {
  101.                         // -1表示文件结尾
  102.                         byte[] res = new byte[size];// 默认最带为256
  103.                         MyLog.i(TAG, "4.start set Message 字节读取");
  104.                         System.arraycopy(temp, 0, res, 0, size);
  105.                         for (int i = 0; i < size; i++) {
  106.                             line += res[i] + " ";
  107.                         }
  108.                         MyLog.i(TAG, "3.getdata " + line + " size=" + size);
  109.                         MyLog.i(TAG, "4.start set Message");
  110.                         Message msg = inHandler.obtainMessage();
  111.                         msg.obj = line;
  112.                         inHandler.sendMessage(msg);// 结果返回给UI处理
  113.                         MyLog.i(TAG1, "5.send to handler");
  114.                     }
  115.  
  116.                 } else {
  117.                     MyLog.i(TAG, "没有可用连接");
  118.                     conn();
  119.                 }
  120.             } catch (Exception e) {
  121.                 MyLog.i(TAG, "数据接收错误" + e.getMessage());
  122.                 e.printStackTrace();
  123.             }
  124.         }
  125.     }
  126.  
  127.     /**
  128.      * 发送数据
  129.      *
  130.      * @param mess
  131.      */
  132.     public void Send(byte[] mess) {
  133.         try {
  134.             if (client != null) {
  135.                 MyLog.i(TAG1, "发送" + mess + "至"
  136.                         + client.getInetAddress().getHostAddress() + ":"
  137.                         + String.valueOf(client.getPort()));
  138.                 out.write(mess);//按字节发送
  139.                 out.flush();
  140.                 MyLog.i(TAG1, "发送成功");
  141.                 Message msg = outHandler.obtainMessage();
  142.                 msg.obj = mess;
  143.                 msg.what = 1;
  144.                 outHandler.sendMessage(msg);// 结果返回给UI处理
  145.             } else {
  146.                 MyLog.i(TAG, "client 不存在");
  147.                 Message msg = outHandler.obtainMessage();
  148.                 msg.obj = mess;
  149.                 msg.what = 0;
  150.                 outHandler.sendMessage(msg);// 结果返回给UI处理
  151.                 MyLog.i(TAG, "连接不存在重新连接");
  152.                 conn();
  153.             }
  154.  
  155.         } catch (Exception e) {
  156.             MyLog.i(TAG1, "send error");
  157.             e.printStackTrace();
  158.         } finally {
  159.             MyLog.i(TAG1, "发送完毕");
  160.  
  161.         }
  162.     }
  163.  
  164.     /**
  165.      * 关闭连接
  166.      */
  167.     public void close() {
  168.         try {
  169.             if (client != null) {
  170.                 MyLog.i(TAG, "close in");
  171.                 in.close();
  172.                 MyLog.i(TAG, "close out");
  173.                 out.close();
  174.                 MyLog.i(TAG, "close client");
  175.                 client.close();
  176.             }
  177.         } catch (Exception e) {
  178.             MyLog.i(TAG, "close err");
  179.             e.printStackTrace();
  180.         }
  181.  
  182.     }
  183. }

参考：

java 从InputStream 获取字节数组

Android笔记：利用InputStream和BufferedReader 进行字节流 字符流处理的更多相关文章

  1. -1-4 java io java流 常用流 分类 File类 文件 字节流 字符流 缓冲流 内存操作流 合并序列流

      File类 •文件和目录路径名的抽象表示形式 构造方法 •public File(String pathname) •public File(String parent,Stringchild) ...

  2. IO流(字节流,字符流,缓冲流)

    一:IO流的分类(组织架构) 根据处理数据类型的不同分为:字节流和字符流 根据数据流向不同分为:输入流和输出流   这么庞大的体系里面,常用的就那么几个,我们把它们抽取出来,如下图:   二:字符字节 ...

  3. IO 复习字节流字符流拷贝文件

    /* 本地文件 URL 文件拷贝 *//*文本文件拷贝 可以通过 字符流,也可以通过字节流*/ /*二进制文件拷贝 只可以通过字节流*//* 希望这个例子能帮助搞懂 字符流与字节流的区别 */ imp ...

  4. IO—》字节流&字符流

    字节流 一.字节输出流OutputStream OutputStream此抽象类,是表示输出字节流的所有类的超类.操作的数据都是字节,定义了输出字节流的基本共性功能方法. FileOutputStre ...

  5. Java之IO流(字节流,字符流)

    IO流和Properties IO流 IO流是指计算机与外部世界或者一个程序与计算机的其余部分的之间的接口.它对于任何计算机系统都非常关键, 因而所有 I/O 的主体实际上是内置在操作系统中的.单独的 ...

  6. 【C#IO 操作】stream 字节流|字符流 |比特流

    stream的简介 Stream 所有流的抽象基类. 流是字节序列的抽象,例如文件.输入/输出设备.进程中通信管道或 TCP/IP 套接字. Stream类及其派生类提供这些不同类型的输入和输出的一般 ...

  7. servlet 之 response 回复 字节流 字符流

    重定向 设置状态吗为302  添加响应头Location(告诉他重定向到哪里去)           //response.setStatus(302);         //添加响应头Locatio ...

  8. Java开发笔记（八十五）通过字符流读写文件

    前面介绍了文件的信息获取.管理操作,以及目录下的文件遍历,那么文件内部数据又是怎样读写的呢?这正是本文所要阐述的内容.File工具固然强大,但它并不能直接读写文件,而要借助于其它工具方能开展读写操作. ...

  9. java 输入输出IO流 字节流| 字符流 的缓冲流：BufferedInputStream；BufferedOutputStream；BufferedReader(Reader in)；BufferedWriter(Writer out)

    什么是缓冲流: 缓冲流的基本原理,是在创建流对象时,会创建一个内置的默认大小的缓冲区数组,通过缓冲区读写,减少系统IO次数,从而提高读写的效率. 图解: 1.字节缓冲流BufferedInputStr ...

随机推荐

  1. BZOJ4377 : [POI2015]Kurs szybkiego czytania

    因为$a$与$n$互质,所以对于$0$到$n-1$里每个$i$,$ai\bmod n$的值互不相同. 设匹配成功的起点为$i$,那么可以得到$3m$段$ai\bmod n$的值不能取的禁区,每段都是连 ...

  2. 【推荐】开放静态文件 CDN服务staticfile.org

    虽然国内外有很多类似的服务器,比如最初的google ajax api,还有后来的sae,百度等都有提供,但是也都有不同的弊端,比如国内访问速度慢.提供的静态文件不全等...staticfile有望解 ...

  3. 编译gcc4.7.3 其他版本的应该也可以

    编译它真麻烦啊..耗费了我一下午..我是ubuntu10.10环境的.内置的gcc版本很老了,好像是4.2吧.源里又没有高版本的,于是自己编译了. 准备 下载gcc:点我打开 //源,找个最快的.下你 ...

  4. BZOJ3236: [Ahoi2013]作业

    Description Input Output Sample Input 3 4 1 2 2 1 2 1 3 1 2 1 1 1 3 1 3 2 3 2 3 Sample Output 2 2 1 ...

  5. BestCoder Round #73

    这场比赛打完后可以找何神玩了orz(orz)* T1Rikka with Chess 嘿嘿嘿.输出n/2+m/2即可. 我能说我智商捉鸡想了4min吗? T2Rikka with Graph 由于N个 ...

  6. 移动Web—CSS为Retina屏幕替换更高质量的图片

    来源:互联网 作者:佚名 时间:12-24 10:37:45 [大 中 小] 点评:Retian似乎是屏幕显示的一种趋势,这也是Web设计师面对的一个新挑战;移动应用程序的设计师们已经学会了如何为Re ...

  7. 关于 swift 的图片多选问题

    http://stackoverflow.com/questions/20756899/how-to-select-multiple-images-from-uiimagepickercontroll ...

  8. Scrum会议8(Beta版本)

    组名:天天向上 组长:王森 组员:张政.张金生.林莉.胡丽娜 代码地址:HTTPS:https://git.coding.net/jx8zjs/llk.git SSH:git@git.coding.n ...

  9. 1st-code-review summary

    每次做code review,先贤谆谆教诲便在耳畔响起: "There are only two hard problems in Computer Science: cache inval ...

  10. html 符号大全

    ░ ▒ ▬ ♦ ◊ ◦ ♠ ♣ ▣ ۰•● ❤ ●•۰► ◄ ▧ ▨ ♨ ◐ ◑ ↔ ↕ ▪ ▫ ☼ ♦ ♧♡♂♀♠♣♥❤☜☞☎☏⊙◎ ☺☻☼▧▨♨◐◑↔↕▪ ▒ ◊◦▣▤▥ ▦▩◘ ◈◇♬♪♩♭♪の ...