Java整型数与网络字节序byte[]数组转换关系详解
本文实例讲述了Java整型数与网络字节序byte[]数组转换关系。分享给大家供大家参考，具体如下：
工作项目需要在java和c/c++之间进行socket通信，socket通信是以字节流或者字节包进行的，socket发送方须将数据转换为字节流或者字节包，而接收方则将字节流和字节包再转换回相应的数据类型。如果发送方和接收方都是同种语言，则一般只涉及到字节序的调整。而对于java和c/c++的通信，则情况就要复杂一些，主要是因为java中没有unsigned类型，并且java和c在某些数据类型上的长度不一致。
针对这种情况，本文整理了java数据类型和网络字节流或字节包(相当于java的byte数组)之间转换方法。实际上网上这方面的资料不少，但往往不全，甚至有些有错误，于是就花了点时间对java整型数和网络字节序的byte[]之间转换的各种情况做了一些验证和整理。整理出来的函数如下：
public class ByteConvert {
// 以下 是整型数 和 网络字节序的 byte[] 数组之间的转换
public static byte[] longToBytes(long n) {
byte[] b = new byte[8];
b[7] = (byte) (n & 0xff);
b[6] = (byte) (n >> 8 & 0xff);
b[5] = (byte) (n >> 16 & 0xff);
b[4] = (byte) (n >> 24 & 0xff);
b[3] = (byte) (n >> 32 & 0xff);
b[2] = (byte) (n >> 40 & 0xff);
b[1] = (byte) (n >> 48 & 0xff);
b[0] = (byte) (n >> 56 & 0xff);
return b;
}
public static void longToBytes( long n, byte[] array, int offset ){
array[7+offset] = (byte) (n & 0xff);
array[6+offset] = (byte) (n >> 8 & 0xff);
array[5+offset] = (byte) (n >> 16 & 0xff);
array[4+offset] = (byte) (n >> 24 & 0xff);
array[3+offset] = (byte) (n >> 32 & 0xff);
array[2+offset] = (byte) (n >> 40 & 0xff);
array[1+offset] = (byte) (n >> 48 & 0xff);
array[0+offset] = (byte) (n >> 56 & 0xff);
}
public static long bytesToLong( byte[] array )
{
return ((((long) array[ 0] & 0xff) << 56)
| (((long) array[ 1] & 0xff) << 48)
| (((long) array[ 2] & 0xff) << 40)
| (((long) array[ 3] & 0xff) << 32)
| (((long) array[ 4] & 0xff) << 24)
| (((long) array[ 5] & 0xff) << 16)
| (((long) array[ 6] & 0xff) << 8)
| (((long) array[ 7] & 0xff) << 0));
}
public static long bytesToLong( byte[] array, int offset )
{
return ((((long) array[offset + 0] & 0xff) << 56)
| (((long) array[offset + 1] & 0xff) << 48)
| (((long) array[offset + 2] & 0xff) << 40)
| (((long) array[offset + 3] & 0xff) << 32)
| (((long) array[offset + 4] & 0xff) << 24)
| (((long) array[offset + 5] & 0xff) << 16)
| (((long) array[offset + 6] & 0xff) << 8)
| (((long) array[offset + 7] & 0xff) << 0));
}
public static byte[] intToBytes(int n) {
byte[] b = new byte[4];
b[3] = (byte) (n & 0xff);
b[2] = (byte) (n >> 8 & 0xff);
b[1] = (byte) (n >> 16 & 0xff);
b[0] = (byte) (n >> 24 & 0xff);
return b;
}
public static void intToBytes( int n, byte[] array, int offset ){
array[3+offset] = (byte) (n & 0xff);
array[2+offset] = (byte) (n >> 8 & 0xff);
array[1+offset] = (byte) (n >> 16 & 0xff);
array[offset] = (byte) (n >> 24 & 0xff);
}
public static int bytesToInt(byte b[]) {
return b[3] & 0xff
| (b[2] & 0xff) << 8
| (b[1] & 0xff) << 16
| (b[0] & 0xff) << 24;
}
public static int bytesToInt(byte b[], int offset) {
return b[offset+3] & 0xff
| (b[offset+2] & 0xff) << 8
| (b[offset+1] & 0xff) << 16
| (b[offset] & 0xff) << 24;
}
public static byte[] uintToBytes( long n )
{
byte[] b = new byte[4];
b[3] = (byte) (n & 0xff);
b[2] = (byte) (n >> 8 & 0xff);
b[1] = (byte) (n >> 16 & 0xff);
b[0] = (byte) (n >> 24 & 0xff);
return b;
}
public static void uintToBytes( long n, byte[] array, int offset ){
array[3+offset] = (byte) (n );
array[2+offset] = (byte) (n >> 8 & 0xff);
array[1+offset] = (byte) (n >> 16 & 0xff);
array[offset] = (byte) (n >> 24 & 0xff);
}
public static long bytesToUint(byte[] array) {
return ((long) (array[3] & 0xff))
| ((long) (array[2] & 0xff)) << 8
| ((long) (array[1] & 0xff)) << 16
| ((long) (array[0] & 0xff)) << 24;
}
public static long bytesToUint(byte[] array, int offset) {
return ((long) (array[offset+3] & 0xff))
| ((long) (array[offset+2] & 0xff)) << 8
| ((long) (array[offset+1] & 0xff)) << 16
| ((long) (array[offset] & 0xff)) << 24;
}
public static byte[] shortToBytes(short n) {
byte[] b = new byte[2];
b[1] = (byte) ( n & 0xff);
b[0] = (byte) ((n >> 8) & 0xff);
return b;
}
public static void shortToBytes(short n, byte[] array, int offset ) {
array[offset+1] = (byte) ( n & 0xff);
array[offset] = (byte) ((n >> 8) & 0xff);
}
public static short bytesToShort(byte[] b){
return (short)( b[1] & 0xff
|(b[0] & 0xff) << 8 );
}
public static short bytesToShort(byte[] b, int offset){
return (short)( b[offset+1] & 0xff
|(b[offset] & 0xff) << 8 );
}
public static byte[] ushortToBytes(int n) {
byte[] b = new byte[2];
b[1] = (byte) ( n & 0xff);
b[0] = (byte) ((n >> 8) & 0xff);
return b;
}
public static void ushortToBytes(int n, byte[] array, int offset ) {
array[offset+1] = (byte) ( n & 0xff);
array[offset] = (byte) ((n >> 8) & 0xff);
}
public static int bytesToUshort(byte b[]) {
return b[1] & 0xff
| (b[0] & 0xff) << 8;
}
public static int bytesToUshort(byte b[], int offset) {
return b[offset+1] & 0xff
| (b[offset] & 0xff) << 8;
}
public static byte[] ubyteToBytes( int n ){
byte[] b = new byte[1];
b[0] = (byte) (n & 0xff);
return b;
}
public static void ubyteToBytes( int n, byte[] array, int offset ){
array[0] = (byte) (n & 0xff);
}
public static int bytesToUbyte( byte[] array ){
return array[0] & 0xff;
}
public static int bytesToUbyte( byte[] array, int offset ){
return array[offset] & 0xff;
}
// char 类型、 float、double 类型和 byte[] 数组之间的转换关系还需继续研究实现。
}
测试程序如下：
public class ByteConvertTest {
public static String byte2Hex(byte[] buf)
{
StringBuffer strbuf = new StringBuffer();
strbuf.append("{");
for (byte b : buf)
{
if (b == 0)
{
strbuf.append("00");
}
else if (b == -1)
{
strbuf.append("FF");
}
else
{
String str = Integer.toHexString(b).toUpperCase();
// sb.append(a);
if (str.length() == 8)
{
str = str.substring(6, 8);
}
else if (str.length() < 2)
{
str = "0" + str;
}
strbuf.append(str);
}
strbuf.append(" ");
}
strbuf.append("}");
return strbuf.toString();
}
public static byte[] longToBytes(long n) {
byte[] b = new byte[8];
b[7] = (byte) (n & 0xff);
b[6] = (byte) (n >> 8 & 0xff);
b[5] = (byte) (n >> 16 & 0xff);
b[4] = (byte) (n >> 24 & 0xff);
b[3] = (byte) (n >> 32 & 0xff);
b[2] = (byte) (n >> 40 & 0xff);
b[1] = (byte) (n >> 48 & 0xff);
b[0] = (byte) (n >> 56 & 0xff);
return b;
}
public static long bytesToLong( byte[] array )
{
return ((((long) array[ 0] & 0xff) << 56)
| (((long) array[ 1] & 0xff) << 48)
| (((long) array[ 2] & 0xff) << 40)
| (((long) array[ 3] & 0xff) << 32)
| (((long) array[ 4] & 0xff) << 24)
| (((long) array[ 5] & 0xff) << 16)
| (((long) array[ 6] & 0xff) << 8)
| (((long) array[ 7] & 0xff) ));
}
public static int bytesToInt(byte b[]) {
return b[3] & 0xff
| (b[2] & 0xff) << 8
| (b[1] & 0xff) << 16
| (b[0] & 0xff) << 24;
}
public static long bytesToUint(byte[] array) {
return ((long) (array[3] & 0xff))
| ((long) (array[2] & 0xff)) << 8
| ((long) (array[1] & 0xff)) << 16
| ((long) (array[0] & 0xff)) << 24;
}
public static byte[] uintToBytes( long n )
{
byte[] b = new byte[4];
b[3] = (byte) (n & 0xff);
b[2] = (byte) (n >> 8 & 0xff);
b[1] = (byte) (n >> 16 & 0xff);
b[0] = (byte) (n >> 24 & 0xff);
return b;
}
public static byte[] shortToBytes(short n) {
byte[] b = new byte[2];
b[1] = (byte) ( n & 0xff);
b[0] = (byte) ((n >> 8) & 0xff);
return b;
}
public static short bytesToShort(byte[] b){
return (short)( b[1] & 0xff
|(b[0] & 0xff) << 8 );
}
static void testShortConvert(){
System.out.println("=================== short convert =============");
System.out.println("byte2Hex(shortToBytes((short)0x11f2))"+byte2Hex(shortToBytes((short)0x11f2)));
System.out.print("println 0x11f2:");
System.out.println((short)0x11f2);
System.out.println("byte2Hex(shortToBytes((short)0xf1f2))"+byte2Hex(shortToBytes((short)0xf1f2)));
System.out.print("println 0xf1f2:");
System.out.println((short)0xf1f2);
System.out.print("println bytesToShort(shortToBytes((short)0x11f2)):");
System.out.println((short)bytesToShort(shortToBytes((short)0x11f2)));
System.out.print("println bytesToShort(shortToBytes((short)0xf1f2)):");
System.out.println((short)bytesToShort(shortToBytes((short)0xf1f2)));
}
public static byte[] ushortToBytes(int n) {
byte[] b = new byte[2];
b[1] = (byte) (n & 0xff);
b[0] = (byte) (n >> 8 & 0xff);
return b;
}
public static int bytesToUshort(byte b[]) {
return b[1] & 0xff
| (b[0] & 0xff) << 8;
}
static void testUshortConvert(){
System.out.println("=================== Ushort convert =============");
System.out.println("byte2Hex(ushortToBytes(0x11f2))"+byte2Hex(ushortToBytes(0x11f2)));
System.out.print("println 0x11f2:");
System.out.println(0x11f2);
System.out.println("byte2Hex(ushortToBytes(0xf1f2))"+byte2Hex(ushortToBytes(0xf1f2)));
System.out.print("println 0xf1f2:");
System.out.println(0xf1f2);
System.out.print("println bytesToUshort(ushortToBytes(0x11f2)):");
System.out.println(bytesToUshort(ushortToBytes(0x11f2)));
System.out.print("println bytesToUshort(ushortToBytes(0xf1f2)):");
System.out.println(bytesToUshort(ushortToBytes(0xf1f2)));
}
public static byte[] ubyteToBytes( int n ){
byte[] b = new byte[1];
b[0] = (byte) (n & 0xff);
return b;
}
public static int bytesToUbyte( byte[] array ){
return array[0] & 0xff;
}
static void testUbyteConvert(){
System.out.println("=================== Ubyte convert =============");
System.out.println("byte2Hex(ubyteToBytes(0x1112))"+byte2Hex(ubyteToBytes(0x1112)));
System.out.print("println 0x1112:");
System.out.println(0x1112);
System.out.println("byte2Hex(ubyteToBytes(0xf2))"+byte2Hex(ubyteToBytes(0xf2)));
System.out.print("println 0xf2:");
System.out.println(0xf2);
System.out.print("println bytesToUbyte(ubyteToBytes(0x1112)):");
System.out.println(bytesToUbyte(ubyteToBytes(0x1112)));
System.out.print("println bytesToUbyte(ubyteToBytes(0xf1f2)):");
System.out.println(bytesToUbyte(ubyteToBytes(0xf1f2)));
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
byte[] array = new byte[4];
array[3] = (byte) 0xF4;
array[2] = 0x13;
array[1] = 0x12;
array[0] = 0x11;
System.out.println("=================== Integer bytes =============");
System.out.println("the bytes is:"+byte2Hex(array) );
System.out.print("println bytesToInt :");
System.out.println( bytesToInt(array));
System.out.printf("printf bytesToInt :%X\n", bytesToInt(array));
System.out.println("=================== long bytes =============");
byte[] longBytes = new byte[8];
longBytes[7] = (byte) 0xf7;
longBytes[6] = (byte) 0x16;
longBytes[5] = (byte) 0xf5;
longBytes[4] = (byte) 0x14;
longBytes[3] = (byte) 0xf3;
longBytes[2] = (byte) 0x12;
longBytes[1] = (byte) 0xf1;
longBytes[0] = (byte) 0x10;
System.out.println( "the bytes is:"+byte2Hex(longBytes) );
System.out.printf("printf bytesToLong:%X\n",bytesToLong(longBytes));
System.out.println("=================byte to long ================");
byte b = (byte)0xf1;
System.out.print("Println the byte:");
System.out.println(b);
System.out.printf("Printf the byte:%X\n",b);
long l = b;
System.out.print("Println byte to long:");
System.out.println(l);
System.out.printf("printf byte to long:%X\n",l);
System.out.println("================= uint Bytes ================");
byte[] uint = new byte[4];
uint[3] = (byte) 0xf3;
uint[2] = (byte) 0x12;
uint[1] = (byte) 0xf1;
uint[0] = (byte) 0xFF;
System.out.println( "the bytes is:"+byte2Hex(uint) );
System.out.printf("printf bytesToUint:%X\n",bytesToUint(uint));
System.out.print("Println bytesToUint:");
System.out.println(bytesToUint(uint));
System.out.println("byte2Hex(uintToBytes(0x11f2f3f4f5f6f7f8l)):"+byte2Hex(uintToBytes(0x11f2f3f4f5f6f7f8l)));
System.out.println("===============Long Integer==============");
System.out.print("println 0x11f2f3f4f5f6f7f8l:");
System.out.println(0x11f2f3f4f5f6f7f8l);
System.out.printf("Printf 0x11f2f3f4f5f6f7f8l:%X\n",0x11f2f3f4f5f6f7f8l);
System.out.println("println byte2Hex(longToBytes(0x11f2f3f4f5f6f7f8l))"+byte2Hex(longToBytes(0x11f2f3f4f5f6f7f8l)));
// 注意，下面的这行，并不能获得正确的uint。
System.out.printf("printf bytesToUint(longToBytes(0x11f2f3f4f5f6f7f8l):%X\n",bytesToUint(longToBytes(0x11f2f3f4f5f6f7f8l)));
System.out.println("===============bytesToLong(longToBytes())==============");
System.out.println(bytesToLong(longToBytes(0x11f2f3f4f5f6f7f8l)));
System.out.printf("%X\n",bytesToLong(longToBytes(0x11f2f3f4f5f6f7f8l)));
testShortConvert();
testUshortConvert();
testUbyteConvert();
}
}
更多关于java相关内容感兴趣的读者可查看本站专题：《Java字符与字符串操作技巧总结》、《Java数学运算技巧总结》、《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》和《Java数组操作技巧总结》
希望本文所述对大家java程序设计有所帮助。
相关推荐
-
java按字节截取带有汉字的字符串的解法(推荐)
由于接口使用的oracle字段长度为固定字节数,然后传进来的字符串估计比数据库字段的总字节数要大,那么截取小于数据库字节数的字符串. 自己参考网上的例子,整了个递归调用就可以了,因为截取的字符字节长度必须小与数据库的字节长度,即如果最后一个字符为汉字,那么只能去掉往前截取. /** * 判断传进来的字符串,是否 * 大于指定的字节,如果大于递归调用 * 直到小于指定字节数 ,一定要指定字符编码,因为各个系统字符编码都不一样,字节数也不一样 * @param s * 原始字符串 * @param
-
Java 字节数组类型(byte[])与int类型互转方法
代码如下: public class CommonUtils { //高位在前,低位在后 public static byte[] int2bytes(int num){ byte[] result = new byte[4]; result[0] = (byte)((num >>> 24) & 0xff);//说明一 result[1] = (byte)((num >>> 16)& 0xff ); result[2] = (byte)((num >
-
java从输入流中获取数据并返回字节数组示例
复制代码 代码如下: import java.io.ByteArrayOutputStream;import java.io.InputStream;//从输入流中获取数据并以字节数组返回public class StreamTool { /** * 从输入流获取数据 * @param inputStream * @return * @throws Exception */ public static byte[] readInputStrea
-
详解Java中字符流与字节流的区别
本文为大家分析了Java中字符流与字节流的区别,供大家参考,具体内容如下 1. 什么是流 Java中的流是对字节序列的抽象,我们可以想象有一个水管,只不过现在流动在水管中的不再是水,而是字节序列.和水流一样,Java中的流也具有一个"流动的方向",通常可以从中读入一个字节序列的对象被称为输入流:能够向其写入一个字节序列的对象被称为输出流. 2. 字节流 Java中的字节流处理的最基本单位为单个字节,它通常用来处理二进制数据.Java中最基本的两个字节流类是InputStream和Out
-
C/C++与Java各数据类型所占字节数的详细比较
C/C++的数据类型: 一,整型 Turbo C: [signed] int 2Byte//有符号数,-32768~32767 unsigned int 2Byte //无符号数,只能表示整数0~65535 [signed] short [int] 2Byte unsigned short [int] 2 Byte long [int] 4 Byte unsigned long [int] 4 Byte Visual C++ 6.0: [signed] int 4Byte unsig
-
Java 将文件转为字节数组知识总结及实例详解
Java将文件转为字节数组 关键字:文件,文件流,字节流,字节数组,二进制 摘要:最近工作中碰到的需求是,利用http传输二进制数据到服务器对应接口,需要传输userId, file(加密后)等一系列混合后的二进制数据.本文旨在记录自己在使用Java将文件转为字节数组的一些知识理解与汇总. FileInputStream 利用FileInputStream读取文件 FileInputStream是InputStream的子类,用于从文件中读取信息,构造器接收一个File类型或表示文件路径的Str
-
计算一个Java对象占用字节数的方法
本文实例讲述了如何计算(或者说,估算)一个Java对象占用的内存数量的方法.分享给大家供大家参考.具体分析如下: 通常,我们谈论的堆内存使用的前提是以"一般情况"为背景的.不包括下面两种情形: 某些情况下,JVM根本就没有把Object放入堆中.例如:原则上讲,一个小的thread-local对象存在于栈中,而不是在堆中. 被Object占用内存的大小依赖于Object的当前状态.例如:Object的同步锁是否生效,或者,Object是否正在被回收. 我们先来看看在堆中单个的Obj
-
详解Java中ByteArray字节数组的输入输出流的用法
ByteArrayInputStream 介绍 ByteArrayInputStream 是字节数组输入流.它继承于InputStream. 它包含一个内部缓冲区,该缓冲区包含从流中读取的字节:通俗点说,它的内部缓冲区就是一个字节数组,而ByteArrayInputStream本质就是通过字节数组来实现的. 我们都知道,InputStream通过read()向外提供接口,供它们来读取字节数据:而ByteArrayInputStream 的内部额外的定义了一个计数器,它被用来跟踪 read() 方
-
Java实现字节数B转化为KB、MB、GB的方法示例【测试可用】
本文实例讲述了Java实现字节数B转化为KB.MB.GB的方法.分享给大家供大家参考,具体如下: 在文件处理的系统中,很容易就能通过一些系统自带的方法取出其大小,问题是这个大小往往只是一个字节数B. 如果要把这个字节数转化为KB.MB.GB的最终呈现给用户,则涉及到整除与取余的算术运算. 方法如下: public static String getPrintSize(long size) { //如果字节数少于1024,则直接以B为单位,否则先除于1024,后3位因太少无意义 if (size
-
Java整型数与网络字节序byte[]数组转换关系详解
本文实例讲述了Java整型数与网络字节序byte[]数组转换关系.分享给大家供大家参考,具体如下: 工作项目需要在java和c/c++之间进行socket通信,socket通信是以字节流或者字节包进行的,socket发送方须将数据转换为字节流或者字节包,而接收方则将字节流和字节包再转换回相应的数据类型.如果发送方和接收方都是同种语言,则一般只涉及到字节序的调整.而对于java和c/c++的通信,则情况就要复杂一些,主要是因为java中没有unsigned类型,并且java和c在某些数据类型上的长
-
浅谈java中集合的由来,以及集合和数组的区别详解
对象多了用集合存,数据多了用数组存. 数组是固定长度的,集合是可变长度的. 集合是:只要是对象就可以存,不管是不是同一种对象 而数组只能存储一种类型的对象 下面是集合的框架: 以上就是小编为大家带来的浅谈java中集合的由来,以及集合和数组的区别详解的全部内容了,希望对大家有所帮助,多多支持我们~
-
Java 中 Date 与 Calendar 之间的编辑与转换实例详解
Java语言的Calendar(日历),Date(日期),和DateFormat(日期格式)组成了Java标准的一个基本但是非常重要的部分.日期是商业逻辑计算一个关键的部分.所有的开发者都应该能够计算未来的日期,定制日期的显示格式,并将文本数据解析成日期对象. 下面通过代码给大家介绍Java 中 Date 与 Calendar 之间的编辑与转换. 具体代码如下所述: /** * 移除 Data 中的时间部分 */ public static Date removeTime(Date date)
-
java 方法泛型入参T和String的重载关系详解
目录 方法泛型入参T和String的重载关系 重载的基本知识不在这里讨论了 重载遇到泛型的问题 反复求证,得出以下结论 方法泛型入参T和String的重载关系 重载的基本知识不在这里讨论了 重载的一个关键理论,如果方法名相同,参数个数.父类型.位置也相同,则调用更加特殊化一个方法. 多余的没写,大家可以运行一下下面的代码,然后理解一下就ok了. public class TestMain { public static void main(String[] args) {
-
基于大端法、小端法以及网络字节序的深入理解
关于字节序(大端法.小端法)的定义<UNXI网络编程>定义:术语"小端"和"大端"表示多字节值的哪一端(小端或大端)存储在该值的起始地址.小端存在起始地址,即是小端字节序:大端存在起始地址,即是大端字节序. 也可以说: 1.小端法(Little-Endian)就是低位字节排放在内存的低地址端即该值的起始地址,高位字节排放在内存的高地址端. 2.大端法(Big-Endian)就是高位字节排放在内存的低地址端即该值的起始地址,低位字节排放在内存的高地址端.举
-
java 整型数与Integer的缓存深入理解
深入理解java 整型数, Integer的缓存 Integer类实质上也是一个普通的java类,即使值相同,也是不同的对象. 例如 Integer a = 148; Integer b = 148; System.out.println(a==b); 这时输出为false. 很容易理解. 但是如果把值换成48. Integer a = 48; Integer b = 48; System.out.println(a==b); 这时就会发现输出变成了true.原因是jdk对128以下的整数作了缓
-
Java IO流之原理分类与节点流文件操作详解
目录 IO流简介 IO流原理 流的分类 IO 流体系 节点流和处理流 节点流操作 IO流简介 I/O是Input/Output的缩写, I/O技术是非常实用的技术,用于处理设备之间的数据传输.如读/写文件,网络通讯等. Java程序中,对于数据的输入/输出操作以"流(stream)" 的方式进行. java.io包下提供了各种"流"类和接口,用以获取不同种类的数据,并通过标准的方法输入或输出数据. IO流原理 输入input:读取外部数据(磁盘.光盘等存储设备的数据
-
java 中同步、异步、阻塞和非阻塞区别详解
java 中同步.异步.阻塞和非阻塞区别详解 简单点说: 阻塞就是干不完不准回来,一直处于等待中,直到事情处理完成才返回: 非阻塞就是你先干,我先看看有其他事没有,一发现事情被卡住,马上报告领导. 我们拿最常用的send和recv两个函数来说吧... 比如你调用send函数发送一定的Byte,在系统内部send做的工作其实只是把数据传输(Copy)到TCP/IP协议栈的输出缓冲区,它执行成功并不代表数据已经成功的发送出去了,如果TCP/IP协议栈没有足够的可用缓冲区来保存你Copy过来的数据的话
-
java 流操作对文件的分割和合并的实例详解
java 流操作对文件的分割和合并的实例详解 学习文件的输入输出流,自己做一个小的示例,对文件进行分割和合并. 下面是代码: package com.dufy.file; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.SequenceInputStream; import java.ut
-
java 中模拟UDP传输的发送端和接收端实例详解
java 中模拟UDP传输的发送端和接收端实例详解 一.创建UDP传输的发送端 1.建立UDP的Socket服务: 2.将要发送的数据封装到数据包中: 3.通过UDP的Socket服务将数据包发送出去: 4.关闭Socket服务. import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; public class