`
cuisuqiang
  • 浏览: 3959035 次
  • 性别: Icon_minigender_1
  • 来自: 北京
博客专栏
3feb66c0-2fb6-35ff-968a-5f5ec10ada43
Java研发技术指南
浏览量:3669087
社区版块
存档分类
最新评论

InputStream,int,shot,long与byte数组之间的互相转换

    博客分类:
  • JDK
阅读更多

没别的,直接上代码!

 

package com.dst.util;

import java.io.*;

/**
 * 流操作工具类
 * 
 * @author 崔素强
 */
public class StreamTool {

	/**
	 * @方法功能 InputStream 转为 byte
	 * @param InputStream
	 * @return 字节数组
	 * @throws Exception
	 */
	public static byte[] inputStream2Byte(InputStream inStream)
			throws Exception {
		// ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
		// byte[] buffer = new byte[1024];
		// int len = -1;
		// while ((len = inStream.read(buffer)) != -1) {
		// outSteam.write(buffer, 0, len);
		// }
		// outSteam.close();
		// inStream.close();
		// return outSteam.toByteArray();
		int count = 0;
		while (count == 0) {
			count = inStream.available();
		}
		byte[] b = new byte[count];
		inStream.read(b);
		return b;
	}

	/**
	 * @方法功能 byte 转为 InputStream
	 * @param 字节数组
	 * @return InputStream
	 * @throws Exception
	 */
	public static InputStream byte2InputStream(byte[] b) throws Exception {
		InputStream is = new ByteArrayInputStream(b);
		return is;
	}

	/**
	 * @功能 短整型与字节的转换
	 * @param 短整型
	 * @return 两位的字节数组
	 */
	public static byte[] shortToByte(short number) {
		int temp = number;
		byte[] b = new byte[2];
		for (int i = 0; i < b.length; i++) {
			b[i] = new Integer(temp & 0xff).byteValue();// 将最低位保存在最低位
			temp = temp >> 8; // 向右移8位
		}
		return b;
	}

	/**
	 * @功能 字节的转换与短整型
	 * @param 两位的字节数组
	 * @return 短整型
	 */
	public static short byteToShort(byte[] b) {
		short s = 0;
		short s0 = (short) (b[0] & 0xff);// 最低位
		short s1 = (short) (b[1] & 0xff);
		s1 <<= 8;
		s = (short) (s0 | s1);
		return s;
	}

	/**
	 * @方法功能 整型与字节数组的转换
	 * @param 整型
	 * @return 四位的字节数组
	 */
	public static byte[] intToByte(int i) {
		byte[] bt = new byte[4];
		bt[0] = (byte) (0xff & i);
		bt[1] = (byte) ((0xff00 & i) >> 8);
		bt[2] = (byte) ((0xff0000 & i) >> 16);
		bt[3] = (byte) ((0xff000000 & i) >> 24);
		return bt;
	}

	/**
	 * @方法功能 字节数组和整型的转换
	 * @param 字节数组
	 * @return 整型
	 */
	public static int bytesToInt(byte[] bytes) {
		int num = bytes[0] & 0xFF;
		num |= ((bytes[1] << 8) & 0xFF00);
		num |= ((bytes[2] << 16) & 0xFF0000);
		num |= ((bytes[3] << 24) & 0xFF000000);
		return num;
	}

	/**
	 * @方法功能 字节数组和长整型的转换
	 * @param 字节数组
	 * @return 长整型
	 */
	public static byte[] longToByte(long number) {
		long temp = number;
		byte[] b = new byte[8];
		for (int i = 0; i < b.length; i++) {
			b[i] = new Long(temp & 0xff).byteValue();
			// 将最低位保存在最低位
			temp = temp >> 8;
			// 向右移8位
		}
		return b;
	}

	/**
	 * @方法功能 字节数组和长整型的转换
	 * @param 字节数组
	 * @return 长整型
	 */
	public static long byteToLong(byte[] b) {
		long s = 0;
		long s0 = b[0] & 0xff;// 最低位
		long s1 = b[1] & 0xff;
		long s2 = b[2] & 0xff;
		long s3 = b[3] & 0xff;
		long s4 = b[4] & 0xff;// 最低位
		long s5 = b[5] & 0xff;
		long s6 = b[6] & 0xff;
		long s7 = b[7] & 0xff; // s0不变
		s1 <<= 8;
		s2 <<= 16;
		s3 <<= 24;
		s4 <<= 8 * 4;
		s5 <<= 8 * 5;
		s6 <<= 8 * 6;
		s7 <<= 8 * 7;
		s = s0 | s1 | s2 | s3 | s4 | s5 | s6 | s7;
		return s;
	}
}

 

请您到ITEYE看我的原创:http://cuisuqiang.iteye.com

或支持我的个人博客,地址:http://www.javacui.com

 

2
0
分享到:
评论
8 楼 cuisuqiang 2012-03-07  
canghailan 写道
cuisuqiang 写道
canghailan 写道
我原来也做过类似的事情,后来读JDK源码时发现已经有更精妙完善的解决方法。

是吗,发出来分享一下

http://www.oschina.net/code/list_by_user?id=116768

没有仔细看,不过好像也差不多吧!还是谢谢分享,希望共同进步!
7 楼 canghailan 2012-03-06  
cuisuqiang 写道
canghailan 写道
我原来也做过类似的事情,后来读JDK源码时发现已经有更精妙完善的解决方法。

是吗,发出来分享一下

http://www.oschina.net/code/list_by_user?id=116768
6 楼 cuisuqiang 2012-03-06  
canghailan 写道
我原来也做过类似的事情,后来读JDK源码时发现已经有更精妙完善的解决方法。

是吗,发出来分享一下
5 楼 canghailan 2012-03-02  
我原来也做过类似的事情,后来读JDK源码时发现已经有更精妙完善的解决方法。
4 楼 canghailan 2012-03-02  
cuisuqiang 写道
遇到一个问题,字节数组中包含了一系列short数据,要么要将字节数组解析为short数组,其实两个字节包含一个short值。
public static void main(String[] args) {
	short a = 65;
	short b = 12;
	short c = 15;
	short d = 24;
	byte[] bt = new byte[8];
	byte[] aa = shortToByte(a);
	byte[] bb = shortToByte(b);
	byte[] cc = shortToByte(c);
	byte[] dd = shortToByte(d);
	// 数组源,数组源拷贝的开始位子,目标,目标填写的开始位子,拷贝的长度
	System.arraycopy(aa, 0, bt, 0, 2);
	System.arraycopy(bb, 0, bt, 2, 2);
	System.arraycopy(cc, 0, bt, 4, 2);
	System.arraycopy(dd, 0, bt, 6, 2);

	short[] res = byteArray2ShortArray(bt);
	for (short t : res) {
		System.out.println(t);
	}
	System.out.println("--------------------------");
	byte[] stt = shortArray2ByteArray(res);
	res = byteArray2ShortArray(stt);
	for (short t : res) {
		System.out.println(t);
	}
}

/**
 * @说明 主要是为解析静态数据包,将一个字节数组转换为short数组
 * @param b
 */
public static short[] byteArray2ShortArray(byte[] b) {
	int len = b.length / 2;
	int index = 0;
	short[] re = new short[len];
	byte[] buf = new byte[2];
	for (int i = 0; i < b.length;) {
		buf[0] = b[i];
		buf[1] = b[i + 1];
		short st = byteToShort(buf);
		re[index] = st;
		index++;
		i += 2;
	}
	return re;
}

/**
 * @说明 主要是为解析静态数据包,将一个short数组反转为字节数组
 * @param b
 */
public static byte[] shortArray2ByteArray(short[] b) {
	byte[] rebt = new byte[b.length * 2];
	int index = 0;
	for (int i = 0; i < b.length; i++) {
		short st = b[i];
		byte[] bt = shortToByte(st);
		rebt[index] = bt[0];
		rebt[index + 1] = bt[1];
		index += 2;
	}
	return rebt;
}

其实也有现成的解决方法,相当强悍:
ByteBuffer bytes = ByteBuffer.allocate(8)
        .putShort((short) 65)
        .putShort((short) 12)
        .putShort((short) 15)
        .putShort((short) 24);
System.out.println(Arrays.toString(bytes.array()));

short [] shorts = new short[4];
ByteBuffer.wrap(new byte[] {0, 65, 0, 12, 0, 15, 0, 24})
        .asShortBuffer()
        .get(shorts);
System.out.println(Arrays.toString(shorts));
3 楼 cuisuqiang 2012-03-02  
遇到一个问题,字节数组中包含了一系列short数据,要么要将字节数组解析为short数组,其实两个字节包含一个short值。
public static void main(String[] args) {
	short a = 65;
	short b = 12;
	short c = 15;
	short d = 24;
	byte[] bt = new byte[8];
	byte[] aa = shortToByte(a);
	byte[] bb = shortToByte(b);
	byte[] cc = shortToByte(c);
	byte[] dd = shortToByte(d);
	// 数组源,数组源拷贝的开始位子,目标,目标填写的开始位子,拷贝的长度
	System.arraycopy(aa, 0, bt, 0, 2);
	System.arraycopy(bb, 0, bt, 2, 2);
	System.arraycopy(cc, 0, bt, 4, 2);
	System.arraycopy(dd, 0, bt, 6, 2);

	short[] res = byteArray2ShortArray(bt);
	for (short t : res) {
		System.out.println(t);
	}
	System.out.println("--------------------------");
	byte[] stt = shortArray2ByteArray(res);
	res = byteArray2ShortArray(stt);
	for (short t : res) {
		System.out.println(t);
	}
}

/**
 * @说明 主要是为解析静态数据包,将一个字节数组转换为short数组
 * @param b
 */
public static short[] byteArray2ShortArray(byte[] b) {
	int len = b.length / 2;
	int index = 0;
	short[] re = new short[len];
	byte[] buf = new byte[2];
	for (int i = 0; i < b.length;) {
		buf[0] = b[i];
		buf[1] = b[i + 1];
		short st = byteToShort(buf);
		re[index] = st;
		index++;
		i += 2;
	}
	return re;
}

/**
 * @说明 主要是为解析静态数据包,将一个short数组反转为字节数组
 * @param b
 */
public static byte[] shortArray2ByteArray(short[] b) {
	byte[] rebt = new byte[b.length * 2];
	int index = 0;
	for (int i = 0; i < b.length; i++) {
		short st = b[i];
		byte[] bt = shortToByte(st);
		rebt[index] = bt[0];
		rebt[index + 1] = bt[1];
		index += 2;
	}
	return rebt;
}
2 楼 cuisuqiang 2012-03-01  
canghailan 写道
public int available() throws IOException
返回此输入流下一个方法调用可以不受阻塞地从此输入流读取(或跳过)的估计字节数。下一个调用可能是同一个线程,也可能是另一个线程。一次读取或跳过此估计数个字节不会受阻塞,但读取或跳过的字节数可能小于该数。
注意,有些 InputStream 的实现将返回流中的字节总数,但也有很多实现不会这样做。试图使用此方法的返回值分配缓冲区,以保存此流所有数据的做法是不正确的。

下面几个方法BigInteger完全实现了:
BigInteger.valueOf(512).toByteArray();
new BigInteger(bytes).longValue();

虚心领教,还忘多多指点
1 楼 canghailan 2012-03-01  
public int available() throws IOException
返回此输入流下一个方法调用可以不受阻塞地从此输入流读取(或跳过)的估计字节数。下一个调用可能是同一个线程,也可能是另一个线程。一次读取或跳过此估计数个字节不会受阻塞,但读取或跳过的字节数可能小于该数。
注意,有些 InputStream 的实现将返回流中的字节总数,但也有很多实现不会这样做。试图使用此方法的返回值分配缓冲区,以保存此流所有数据的做法是不正确的。

下面几个方法BigInteger完全实现了:
BigInteger.valueOf(512).toByteArray();
new BigInteger(bytes).longValue();

相关推荐

    Drawable Bitmap InputStream byte[]相互转化工具类

    在Android开发中,处理图像数据时,我们经常需要在Drawable、Bitmap、InputStream和byte数组之间进行转换。这些类型的转换在不同的场景下具有重要的作用,例如从网络加载图片、存储图片到本地或者显示在ImageView上...

    浅谈java的byte数组的不同写法

    在编程中,我们常常用到byte数组,它用于存储大量的字节数据。在Java中,有几种不同的方式来初始化和表示byte数组,如下所述: 1. **二进制表示**: 我们可以用二进制数来初始化byte数组。例如,`byte[] aa = {...

    原理讲解-ServletInputStream.readLine(byte[] b, int off, int len) 方法

    `readLine(byte[] b, int off, int len)` 方法是 `ServletInputStream` 提供的一个方法,用于读取输入流中的一行数据。这个方法在处理文本数据时非常有用,因为它可以方便地按行读取数据,而不仅仅是单个字节。 在...

    Blob、InputStream、byte 互转

    #### InputStream与byte[]之间的转换 1. **InputStream转byte[]** ```java private byte[] inputStreamToByte(InputStream is) throws IOException { ByteArrayOutputStream bytestream = new ...

    读取图片数据到byte[]数组,合并inputStream每次读取产生的缓冲byte[]

    本文将深入探讨如何将图片数据读取到`byte[]`数组,并如何合并由多次`InputStream`读取产生的缓冲`byte[]`。这涉及到Java编程语言中的IO流操作以及数据转换。 首先,我们来理解“读取图片数据到byte[]数组”。在...

    byte与各类型之间的转化

    尤其在处理二进制数据时,byte类型与其他数据类型(如String、boolean、int、InputStream等)之间的转换尤为重要。本文档旨在详细介绍byte与各种常见类型之间的转换方法,帮助开发者更好地理解和掌握这一技能。 ###...

    字节流工具

    2. **InputStream与byte数组转换** - 将InputStream转换为byte数组:可以使用ByteArrayOutputStream来实现。通过调用InputStream的read()方法,将数据读取到ByteArrayOutputStream中,然后调用其toByteArray()方法...

    Java String与Byte类型转换

    - **字节数组转换**: 使用`new String(bytes)`构造函数创建字符串。同样,如果字节数组采用特定编码,需要提供编码名称,如`new String(bytes, "UTF-8")`。 - **使用InputStream**: 当从输入流读取字节时,可以先...

    将输出流OutputStream转化为输入流InputStream的方法

    如果`OutputStream`是其他类型,如`FileOutputStream`,则不能直接转换,因为它们并不直接与字节数组关联。在这种情况下,可能需要先将`OutputStream`的内容刷新到目标(例如文件),然后再创建一个新的`InputStream...

    Java中InputStream类.pdf

    - `public int read(byte[] b, int off, int len) throws IOException`: 类似于上一个方法,但可以指定在数组`b`的哪个偏移量`off`开始存储,以及最多读取`len`个字节。 - `public void reset() throws IOException`...

    InputStream与OutputStream及File间互转

    下面我们将详细探讨`InputStream`、`OutputStream`以及它们与`File`之间的转换方法。 1. `InputStream`与`File`的转换: 当我们需要从文件中读取数据时,可以使用`FileInputStream`类,它是`InputStream`的一个...

    简单说说JAVA的String和byte[]的关系

    在Java编程语言中,`String`对象与`byte[]`数组之间的转换是常见的操作之一。理解这两者之间的关系对于处理文本数据、网络通信及文件读写等任务至关重要。 #### 一、String与byte[]的基本概念 - **String**: 在...

    Java 类型相互转换byte[]类型,Blob类型详细介绍

    在Java编程中,数据存储和传输常常涉及到不同类型的数据转换,特别是在数据库操作中,与二进制大数据相关的类型如`byte[]`(字节数组)和`Blob`(Binary Large Object)之间的转换尤为常见。本篇文章将详细讲解如何...

    Java 的常用包与数组的复制与排序25

    此外,集合框架中的`List`接口提供了`addAll()`方法,可以方便地将一个数组转换为`ArrayList`并添加到另一个`List`中。 对于数组的排序,Java的`Arrays`类提供了静态方法`sort()`。它可以对任何类型的对象数组进行...

    Java中几个文件输入流和文件输出流的研究.pdf

    4. 读取方法:public int read(byte[] b) throws IOException:从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。 5. 关闭方法:public void close() throws IOException:关闭此文件输入流并释放与...

    springboot 解决InputStream只能读取一次的问题

    然后,我们创建了一个`CachedServletInputStream`类,它实现了`ServletInputStream`接口,并从缓存的字节数组中读取数据。 在处理请求时,我们可以先创建一个`RepeatableHttpServletRequest`实例,将其传递给我们的...

    j2me系统文件的操作(包括把图片byte化)

    这个过程首先加载图片,将其转换为`BufferedImage`,然后利用`ImageIO.write`方法将图片写入`ByteArrayOutputStream`,最终得到byte数组。 值得注意的是,由于J2ME的限制,处理大型图片时可能会遇到性能问题。因此...

    Socket粘包问题终极解决方案-Netty版.docx

    // 将 byte 数组转换为 int String headStr = new String(headerBytes); return Integer.parseInt(headStr); } } ``` 使用该解决方案,可以将消息封装成消息头和消息体,并确定消息的边界,解决粘包和半包问题...

    java InputStream读取数据问题

    在Java编程中,`InputStream`是Java I/O流的基础类,用于从各种输入源读取数据。它提供了读取原始字节的基本方法,是所有字节输入流的超类。当我们遇到“Java InputStream读取数据问题”时,通常涉及到如何正确、...

    java实现图片转base64字符串 java实现base64字符串转图片

    首先,我们需要使用 Inputstream 读取图片文件,然后将其转换为 byte 数组,最后使用 Base64Encoder 将 byte 数组转换为 Base64 编码的字符串。 在上面的代码中,我们使用了 Inputstream 和 Outputstream 两个类来...

Global site tag (gtag.js) - Google Analytics