Android笔记：利用InputStream和BufferedReader 进行字节流字符流处理

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

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.net.Socket;

import java.net.UnknownHostException;

import java.util.Arrays;
import android.content.Context;

import android.content.SharedPreferences;

import android.os.Handler;

import android.os.Message;

import android.util.Log;
public class SocThread extends Thread {

    private String ip = "10.0.0.113";

    private int port = 6666;

    private String TAG = "socket thread";

    private int timeout = 10000;

    int maxsize = 256;
public Socket client = null;

    PrintWriter out;

    BufferedReader in;

    public boolean isRun = true;

    Handler inHandler;

    Handler outHandler;

    Context ctx;

    private String TAG1 = "===Send===";

    SharedPreferences sp;
public SocThread(Handler handlerin, Handler handlerout, Context context) {

        inHandler = handlerin;

        outHandler = handlerout;

        ctx = context;

        MyLog.i(TAG, "创建线程socket");

    }
/**

     * 连接socket服务器

     */

    public void conn() {
try {

            initdate();

            Log.i(TAG, "连接中……");

            client = new Socket(ip, port);

            client.setSoTimeout(timeout);// 设置阻塞时间

            MyLog.i(TAG, "连接成功");

            in = new BufferedReader(new InputStreamReader(

                    client.getInputStream()));

            out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(

                    client.getOutputStream())), true);

            MyLog.i(TAG, "输入输出流获取成功");

        } catch (UnknownHostException e) {

            MyLog.i(TAG, "连接错误UnknownHostException 重新获取");

            e.printStackTrace();

            conn();

        } catch (IOException e) {

            MyLog.i(TAG, "连接服务器io错误");

            e.printStackTrace();

        } catch (Exception e) {

            MyLog.i(TAG, "连接服务器错误Exception" + e.getMessage());

            e.printStackTrace();

        }

    }
public void initdate() {

        sp = ctx.getSharedPreferences("SP", ctx.MODE_PRIVATE);

        ip = sp.getString("ipstr", ip);

        port = Integer.parseInt(sp.getString("port", String.valueOf(port)));

        MyLog.i(TAG, "获取到ip端口:" + ip + ";" + port);

    }
/**

     * 实时接受数据

     */

    @Override

    public void run() {

        MyLog.i(TAG, "线程socket开始运行");

        conn();

        MyLog.i(TAG, "1.run开始");

        String line = "";

        while (isRun) {

            try {

                if (client != null) {

                    MyLog.i(TAG, "2.检测数据");

                    // 以下是按行直接读取字符流

                     while ((line = in.readLine()) != null) {

                     MyLog.i(TAG,

                     "3.getdata" + line + " len=" + line.length());

                     MyLog.i(TAG, "4.start set Message");

                     Message msg = inHandler.obtainMessage();

                     msg.obj = line;

                     inHandler.sendMessage(msg);// 结果返回给UI处理

                     MyLog.i(TAG1, "5.send to handler");

                     }
} else {

                    MyLog.i(TAG, "没有可用连接");

                    conn();

                }

            } catch (Exception e) {

                MyLog.i(TAG, "数据接收错误" + e.getMessage());

                e.printStackTrace();

            }

        }

    }
/**

     * 发送数据

     *

     * @param mess

     */

    public void Send(String mess) {

        try {

            if (client != null) {

                MyLog.i(TAG1, "发送" + mess + "至"

                        + client.getInetAddress().getHostAddress() + ":"

                        + String.valueOf(client.getPort()));

                out.println(mess);//按字符流发送

                out.flush();

                MyLog.i(TAG1, "发送成功");

                Message msg = outHandler.obtainMessage();

                msg.obj = mess;

                msg.what = 1;

                outHandler.sendMessage(msg);// 结果返回给UI处理

            } else {

                MyLog.i(TAG, "client 不存在");

                Message msg = outHandler.obtainMessage();

                msg.obj = mess;

                msg.what = 0;

                outHandler.sendMessage(msg);// 结果返回给UI处理

                MyLog.i(TAG, "连接不存在重新连接");

                conn();

            }
} catch (Exception e) {

            MyLog.i(TAG1, "send error");

            e.printStackTrace();

        } finally {

            MyLog.i(TAG1, "发送完毕");
}

    }
/**

     * 关闭连接

     */

    public void close() {

        try {

            if (client != null) {

                MyLog.i(TAG, "close in");

                in.close();

                MyLog.i(TAG, "close out");

                out.close();

                MyLog.i(TAG, "close client");

                client.close();

            }

        } catch (Exception e) {

            MyLog.i(TAG, "close err");

            e.printStackTrace();

        }
}

}

原始字节流读取处理如下

package com.example.testsocket;
import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.net.Socket;

import java.net.UnknownHostException;
import android.content.Context;

import android.content.SharedPreferences;

import android.os.Handler;

import android.os.Message;

import android.util.Log;
public class SocThread extends Thread {

    private String ip = "10.0.0.113";

    private int port = 6666;

    private String TAG = "socket thread";

    private int timeout = 10000;

    private int maxsize = 256;// 默认接受大小
public Socket client = null;

    // PrintWriter out;

    // BufferedReader in;

    OutputStream out;

    InputStream in;

    public boolean isRun = true;

    Handler inHandler;

    Handler outHandler;

    Context ctx;

    private String TAG1 = "===Send===";

    SharedPreferences sp;
public SocThread(Handler handlerin, Handler handlerout, Context context) {

        inHandler = handlerin;

        outHandler = handlerout;

        ctx = context;

        MyLog.i(TAG, "创建线程socket");

    }
/**

     * 连接socket服务器

     */

    public void conn() {
try {

            initdate();

            Log.i(TAG, "连接中……");

            client = new Socket(ip, port);

            client.setSoTimeout(timeout);// 设置阻塞时间

            MyLog.i(TAG, "连接成功");

            in = client.getInputStream();

            out = client.getOutputStream();

            // 以下在字符流时比较好用

            // in = new BufferedReader(new InputStreamReader(

            // client.getInputStream()));

            // out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(

            // client.getOutputStream())), true);

            MyLog.i(TAG, "输入输出流获取成功");

        } catch (UnknownHostException e) {

            MyLog.i(TAG, "连接错误UnknownHostException 重新获取");

            e.printStackTrace();

            conn();

        } catch (IOException e) {

            MyLog.i(TAG, "连接服务器io错误");

            e.printStackTrace();

        } catch (Exception e) {

            MyLog.i(TAG, "连接服务器错误Exception" + e.getMessage());

            e.printStackTrace();

        }

    }
public void initdate() {

        sp = ctx.getSharedPreferences("SP", ctx.MODE_PRIVATE);

        ip = sp.getString("ipstr", ip);

        port = Integer.parseInt(sp.getString("port", String.valueOf(port)));

        MyLog.i(TAG, "获取到ip端口:" + ip + ";" + port);

    }
/**

     * 实时接受数据

     */

    @Override

    public void run() {

        MyLog.i(TAG, "线程socket开始运行");

        conn();

        MyLog.i(TAG, "1.run开始");

        String line = "";

        while (isRun) {

            try {

                if (client != null) {

                    MyLog.i(TAG, "2.检测数据");

                    byte[] temp = new byte[maxsize];// 默认最带为256

                    int size = 0;

                    while ((size = in.read(temp)) > 0) {

                        // -1表示文件结尾

                        byte[] res = new byte[size];// 默认最带为256

                        MyLog.i(TAG, "4.start set Message 字节读取");

                        System.arraycopy(temp, 0, res, 0, size);

                        for (int i = 0; i < size; i++) {

                            line += res[i] + " ";

                        }

                        MyLog.i(TAG, "3.getdata " + line + " size=" + size);

                        MyLog.i(TAG, "4.start set Message");

                        Message msg = inHandler.obtainMessage();

                        msg.obj = line;

                        inHandler.sendMessage(msg);// 结果返回给UI处理

                        MyLog.i(TAG1, "5.send to handler");

                    }
} else {

                    MyLog.i(TAG, "没有可用连接");

                    conn();

                }

            } catch (Exception e) {

                MyLog.i(TAG, "数据接收错误" + e.getMessage());

                e.printStackTrace();

            }

        }

    }
/**

     * 发送数据

     *

     * @param mess

     */

    public void Send(byte[] mess) {

        try {

            if (client != null) {

                MyLog.i(TAG1, "发送" + mess + "至"

                        + client.getInetAddress().getHostAddress() + ":"

                        + String.valueOf(client.getPort()));

                out.write(mess);//按字节发送

                out.flush();

                MyLog.i(TAG1, "发送成功");

                Message msg = outHandler.obtainMessage();

                msg.obj = mess;

                msg.what = 1;

                outHandler.sendMessage(msg);// 结果返回给UI处理

            } else {

                MyLog.i(TAG, "client 不存在");

                Message msg = outHandler.obtainMessage();

                msg.obj = mess;

                msg.what = 0;

                outHandler.sendMessage(msg);// 结果返回给UI处理

                MyLog.i(TAG, "连接不存在重新连接");

                conn();

            }
} catch (Exception e) {

            MyLog.i(TAG1, "send error");

            e.printStackTrace();

        } finally {

            MyLog.i(TAG1, "发送完毕");
}

    }
/**

     * 关闭连接

     */

    public void close() {

        try {

            if (client != null) {

                MyLog.i(TAG, "close in");

                in.close();

                MyLog.i(TAG, "close out");

                out.close();

                MyLog.i(TAG, "close client");

                client.close();

            }

        } catch (Exception e) {

            MyLog.i(TAG, "close err");

            e.printStackTrace();

        }
}

}

参考：

java 从InputStream
获取字节数组

Android笔记：利用InputStream和BufferedReader 进行字节流字符流处理,布布扣,bubuko.com

时间： 2024-08-04 14:11:37

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

在程序中所有的数据都是以流的方式进行传输和保存的,程序需要数据的时候要使用输入流读取数据,而程序需要将一些数据保存起来则需要使用输出流来完成. 在JAVA.IO包中操作文件内容的主要有两大类:字节流,字符流,两类都分为输入和输出操作.在字节流中输出数据主要是使用OutputStream,输入主要使用InputStream,在字符流中输出主要使用Writer类完成,输入只要使用Reader类完成. 主要的操作流程如下: 使用FILE类打开一个文件通过字节流或者字符流的子类,指定输出的位置. 进行

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

/* 本地文件 URL 文件拷贝 *//*文本文件拷贝可以通过字符流,也可以通过字节流*/ /*二进制文件拷贝只可以通过字节流*//* 希望这个例子能帮助搞懂字符流与字节流的区别 */ import java.io.*; //in order to utilize stream object import java.util.*; // in order to utilize ArrayList import java.net.*; class Copy{ public static v

Java 字节流字符流转换流

我们知道Java中的流分为字符流和字节流,其中字符流主要针对字符文本进行处理,而字节流处理范围更为广泛,毕竟图片.电影等只要是文件都是以二进制的形式存在的,而不是字符. 字符流: FileReader FileWriter. BufferedReader BufferedWriter 字节流: FileInputStream FileOutputStream BufferedInputStream BufferedOutputStream 我们看一下J2SE文档: BufferedReader(

字节流字符流 - 12

一.IO概述 Java中I/O操作主要是指使用java.io包下的内容,进行输入.输出操作.输入也叫做读取数据,输出也叫做作写出数据. 输入流 :把数据从其他设备上读取到内存中的流. 输出流 :把数据从内存中写出到其他设备上的流. 字节流 :以字节为单位,读写数据的流. 字符流 :以字符为单位,读写数据的流. 二.字节流一切皆为字节 OutputStream.FileOutputStream java.io.OutputStream抽象类是表示字节输出流的所有类的超类,将指定的字节信息写出到

Java+字节流+字符流转换

原文地址:http://blog.51cto.com/janephp/2150039

字节流与字符流简单操作（OutputStream、InputStream、Writer、Reader）

操作流程使用File类打开一个文件通过字节流或者字符流的子类.指定输出的位置. 进行读/写操作关闭输入/出字节流与字符流在java.io包中操作文件内容主要有两大类:字节流字符流.两大类分为输入和输出操作,在字节流中输出数据主要是OutputStream完成,输入使用InputStream,在字符流冲输出主要是使用Writer类完成,输入主要是Reader完成字节流字节流主要是操作byte类型数据,以byte数组为准,主要操作类是OutputStream和InputSream 字节

黑马程序员—IO(一)流概述、字符流、字节流、流操作规律

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 第一节 IO概述概述 1.IO流:即InputOutput的缩写. 2.特点: 1)IO流用来处理设备间的数据传输. 2)Java对数据的操作是通过流的方式. 3)Java用于操作流的对象都在IO包中. 4)流按其操作数据的类型分为两种:字节流和字符流. 5)流按其流向分为:输入流和输出流. 注意:流只能操作数据,而不能操作文件. 3.IO流的常用基类: 1)字节流的抽象基流:Inp

黑马程序员——IO流概述、字符流、字节流、流操作规律(一)

第一节 IO概述概述 1.IO流:即InputOutput的缩写. 2.特点: 1)IO流用来处理设备间的数据传输. 2)Java对数据的操作是通过流的方式. 3)Java用于操作流的对象都在IO包中. 4)流按其操作数据的类型分为两种:字节流和字符流. 5)流按其流向分为:输入流和输出流. 注意:流只能操作数据,而不能操作文件. 3.IO流的常用基类: 1)字节流的抽象基流:InputStream和OutputStream 2)字符流的抽象基流:Reader和Writer 注:此四个

Java基础---IO(一)---IO流概述、字符流、字节流、流操作规律

第一讲 IO概述概述 1.IO流:即InputOutput的缩写. 2.特点: 1)IO流用来处理设备间的数据传输. 2)Java对数据的操作是通过流的方式. 3)Java用于操作流的对象都在IO包中. 4)流按操作数据分为两种:字节流和字符流. 5)流按流向分为:输入流和输出流. 注意:流只能操作数据,而不能操作文件. 3.IO流的常用基类: 1)字节流的抽象基流:InputStream和OutputStream 2)字符流的抽象基流:Reader和Writer 注:此四个类派生出来

Android笔记：利用InputStream和BufferedReader 进行字节流 字符流处理

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

Android笔记：利用InputStream和BufferedReader 进行字节流字符流处理

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