inputStream和String,Byte之间的转换
1.import java.io.ByteArrayInputStream;
2.import java.io.ByteArrayOutputStream;
3.import java.io.IOException;
4.import java.io.InputStream;
5.
6./**
7. *
8. * @author Andy.Chen
9. * @mail Chenjunjun.ZJ@https://www.360docs.net/doc/217508458.html,
10. *
11. */
12.public class InputStreamUtils {
13.
14. final static int BUFFER_SIZE = 4096;
15.
16. /**
17. * 将InputStream转换成String
18. * @param in InputStream
19. * @return String
20. * @throws Exception
21. *
22. */
23. public static String InputStreamTOString(InputStream in) throws Ex
ception{
24.
25. ByteArrayOutputStream outStream = new ByteArrayOutputStream();
26. byte[] data = new byte[BUFFER_SIZE];
27. int count = -1;
28. while((count = in.read(data,0,BUFFER_SIZE)) != -1)
29. outStream.write(data, 0, count);
30.
31.data = null;
32. return new String(outStream.toByteArray(),"ISO-8859-1");
33. }
34.
35. /**
36. * 将InputStream转换成某种字符编码的String
37. * @param in
38. * @param encoding
39. * @return
40. * @throws Exception
41. */
42. public static String InputStreamTOString(InputStream in,Strin
g encoding) throws Exception{
43.
44. ByteArrayOutputStream outStream = new ByteArrayOutputStream();
45. byte[] data = new byte[BUFFER_SIZE];
46. int count = -1;
47. while((count = in.read(data,0,BUFFER_SIZE)) != -1)
48. outStream.write(data, 0, count);
49.
50.data = null;
51. return new String(outStream.toByteArray(),"ISO-8859-1");
52. }
53.
54. /**
55. * 将String转换成InputStream
56. * @param in
57. * @return
58. * @throws Exception
59. */
60. public static InputStream StringTOInputStream(String in) throws Ex
ception{
61.
62. ByteArrayInputStream is = new ByteArrayInputStream(in.getBytes
("ISO-8859-1"));
63. return is;
64. }
65.
66. /**
67. * 将InputStream转换成byte数组
68. * @param in InputStream
69. * @return byte[]
70. * @throws IOException
71. */
72. public static byte[] InputStreamTOByte(InputStream in) throws IOEx
ception{
73.
74. ByteArrayOutputStream outStream = new ByteArrayOutputStream();
75. byte[] data = new byte[BUFFER_SIZE];
76. int count = -1;
77. while((count = in.read(data,0,BUFFER_SIZE)) != -1)
78. outStream.write(data, 0, count);
79.
80.data = null;
81. return outStream.toByteArray();
82. }
83.
84. /**
85. * 将byte数组转换成InputStream
86. * @param in
87. * @return
88. * @throws Exception
89. */
90. public static InputStream byteTOInputStream(byte[] in) throws Exce
ption{
91.
92. ByteArrayInputStream is = new ByteArrayInputStream(in);
93. return is;
94. }
95.
96. /**
97. * 将byte数组转换成String
98. * @param in
99. * @return
100. * @throws Exception
101. */
102. public static String byteTOString(byte[] in) throws Exception{ 103.
104. InputStream is = byteTOInputStream(in);
105. return InputStreamTOString(is);
106. }
107.
108.}
位、字节、字、字长的关系
位、字节、字、字长的关系 我们来看看这几个让人纠结的概念，它们存在着密不可分的关系。 休闲时光，你们喜欢看电影吗？我们每个人去看电影都要买电影票，每个票对应一个座位，但是平时我们都喜欢和自己最爱的人在一起看电影，所以要组团看电影(*^__^*)。 一、位 首先我们要搞清楚一点：在计算机中所有数据都是以二进制数字存储的。这意味着计算机中数据存储的值只能是0或1。 因此，可以把我们每个人都看作这两个数字中的一个，我们每一个人对应电影院的一个座位。在计算机中，一个“位”（bit，简单记为b，也称比特）就是这样一个座位，可以存放0或者1。 一个位不能存放更多的信息。位是计算机数据运输的基本单位（最小的不可再分割的单位）。 一个二进制位只可以表示0和1两种状态，两个位可以表示00, 01, 10, 11，4=22种状态，三个位可以表示8=23种状态……以此类推，32位可以表示232种状态，64位可以表示264种状态。 计算机对数据有几种处理，其中数据存储和数据传输是两个重要的环节。 二、字节 在计算机这个大电影院中，有一条规则是现实中的电影院所不需要的：每个组团看电影的单位和团体的人数必须是8或者8的正整数倍。因此，2个，4个人组成一个团去看电影可是要被拒之门外的哦。
我们不妨给这样的8个成员的一个组起一个名字，对于计算机而言，8个位就是一个字节（Byte，简称B。位和字节都是数据单位）。28=256，所以一个字节单位的数据可以有256种组合方式（状态）。一个字节的二进制数最小为00000000，最大为11111111。 字节是计算机存储单元的基本计量单位，是计算机数据存储的基本单位。也就是说，计算机在进行数据传输的时候，允许传输的一个最小的数据块就是一个字节的数据。 一个字节可以存放一个英文字母（代表一个英文字母的二进制编码）、一个阿拉伯数字（同样是代表一个阿拉伯数字的二进制代码）以及半个汉字（二进制代码，一个完整的汉字需要两个字节长度的空间来存储）。 在微型计算机中，通常用多少字节来表示数据传输的数量： 1KB=1024B；1MB=1024KB=1024×1024B。其中1024=210。 1B（byte，字节）= 8 bit； 1KB（Kibibyte，千字节）=1024B= 210 B； 1MB（Mebibyte，兆字节，百万字节，简称“兆”）=1024KB= 220 B； 1GB（Gigabyte，吉字节，十亿字节，又称“千兆”）=1024MB= 230 B； 1TB（Terabyte，万亿字节，太字节）=1024GB= 240 B； 1PB（Petabyte，千万亿字节，拍字节）=1024TB= 250 B； 1EB（Exabyte，百亿亿字节，艾字节）=1024PB= 260 B； 1ZB（Zettabyte，十万亿亿字节，泽字节）= 1024EB= 270 B；
图片与字节数组相互转换的方法
图片与字节数组相互转换的方法 图片与字节数组相互转换的方法 aspx.cs using System;using System.IO; using System.Drawing; using System.Drawing.Imaging;public partial class _2Stream : System.Web.UI.Page { protected void Page_Load(object sender, EventArgs e) {}protected void FileToStream(object sender, EventArgs e) { //将JPG图片转化成字节数组 Image image = Image.FromFile("E:/1.jpg"); //或者使用Server.MapPath MemoryStream ms =
new MemoryStream(); image.Save(ms, ImageFormat.Jpeg); ms.Flush(); ms.Seek(0, SeekOrigin.Begin); byte[] buffer = new byte[ms.Length]; ms.Read(buffer, 0, (int)ms.Length);//遍历字节数组 for (int i = 0; i < buffer.LongLength; i++) { message.Text += buffer[i].ToString(); }//将字节数组转化成图像文件（自定义格式）并保存MemoryStream ms2 = new MemoryStream(buffer, 0, buffer.Length); ms2.Seek(0, SeekOrigin.Begin); Image image2 = Image.FromStream(ms2); image2.Save("E:\\2.gif", ImageFormat.Gif);
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 longT oBytes( 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)
plc编程中的字节 字 双字 整数 双整数 实数 之间的关系
字word 字节byte 位bit 整数分：1、int 带符号16位整数 2、dint 带符号32位整数双整数 real 浮点数实数32位 继续追问：它们之间有什么关系吗 补充回答：（1000位）1kb=1024字节，1字=2字节，1双字=2字=4字节，1字节=8位 整数有符号型与无符号型。 整数分 32位平台： short 在内存中占两个字节，范围为-2^15~（2^15-1) int 在内存中占四个字节，范围为-2^31~（2^31-1） long在内存中占四个字节，范围为-2^31~2^31-1 无符号型：最高位不表示符号位 unsigned short 在内存中占两个字节，范围为0~2^16-1 unsigned int 在内存中占四个字节，范围为0~2^32-1 unsigned long在内存中占四个字节，范围为0~2^32-1 实型变量: 分单精度float 和双精度double 两种形式： float:占四个字节，提供7~8位有效数字。 double: 占八个字节，提供15~16位有效数字。 （二）16位平台: 1)整型(基本型)：类型说明符为int，在内存中占2个字节。 2)短整型：类型说明符为short int或short。所占字节和取值范围均与整型(基本型)相同。 3)长整型：类型说明符为long int或long，在内存中占4个字节。 无符号型：类型说明符为unsigned。 无符号型又可与上述三种类型匹配而构成： 各种无符号类型量所占的内存空间字节数与相应的有符号类型量相同。但由于省去了符号位，故不能表示负数。 实型变量: 分为单精度（float型）、双精度（double型）和长双精度（long double型）三类。 单精度型占4个字节（32位）内存空间，其数值范围为3.4E-38～3.4E+38，只能提供七位有效数字。 双精度型占8 个字节（64位）内存空间，其数值范围为1.7E-308～1.7E+308，可提供16位有效数字。 长双精度型16 个字节（128位）内存空间，可提供18-19位有效数字。
C#数组、字节数组、转换等
C#数组、字节数组、转换等 在System名称空间里面有许多跟Array操作相关的类。其中System.Array 类里面就提供了以下常用的方法： BinarySearch： 使用二进制搜索算法在一维的排序Array中搜索值。 Copy： 将一个Array的一部分元素复制到另一个Array中，并根据需要执行类型强制转换和装箱。 CopyTo： 将当前一维Array的所有元素复制到指定的一维Array中。 Resize： 将数组的大小更改为指定的新大小。 Sort： 对一维Array对象中的元素进行排序。 与大多数类不同，Array提供CreateInstance方法，以便允许后期绑定访问，而不是提供公共构造函数。 Array.Copy方法不仅可在同一类型的数组之间复制元素，而且可在不同类型的标准数组之间复制元素；它会自动处理强制类型转换。有些方法，如CreateInstance、Copy、CopyTo、GetValue和SetValue，提供重载（接受64位整数作为参数），以适应大容量数组。LongLength和GetLongLength返回指示数组长度的64位整数。在执行需要对Array进行排序的操作（如BinarySearch）之前，必须对Array进行排序。
ArrayList跟Array不同，前者是集合对象，ArrayList的ToArray方法可以直接将ArrayList里面的全部元素导出到一个数组里，而不需用循环逐个元素地复制到一个数组。 ToArray的使用方法如下： ArrayList ay = new ArrayList(); ay.Add("sheep"); ay.Add("cat"); ay.Add("dog"); string[] al= (string[])ay.ToArray(typeof(string)); Console.WriteLine(al[0]); 关键的地方在于ToArray的参数，这里应该用反射中的typeof获取arraylist 里面元素的原始数据类型。 在数组中有一种比较特殊的： 字节数组，即byte[]。内存、文件中的数据都是以字节数组的形式储存的，如果程序需要对数据进行操作的话，或多或少都会使用到byte[]。 对于byte[]跟其他类型的相互转换问题，在C++中，使用Memorycopy函数即可完成，虽然在C#里面也有类似MemoryCopy的函数： Buffer.BlockCopy，但由于强类型的特性，在C#里它并实现不了字节数组跟其他类型转换的功能。 为了解决这个问题，需要手工写将其他类型的数据通过位运算和逻辑运算而得到字节数组。如下面的代码： //整型转换为字节数组 int i = ; //对应的十六进制是：0012D687
位、字节、帧各自的定义和关系(精)
“位”也称“比特”或“信息量” ------ bps(bits per second每秒比特数 bps 是网络传输中一个最基本的网速单位,而比特流常用于拨号上网时代,最快的网速也就几十 kbps(1024bps,常指在网络中传输的数据流,也就是说上网比特流 两个概念: 1 计算机专业术语, 是信息量单位, 是由英文 BIT 音译而来。二进制数的一位所包含的信息就是一比特,如二进制数 0101就是 4比特。 2 二进制数字中的位,信息量的度量单位,为信息量的最小单位。数字化音响中用电脉冲表达音频信号,“ 1”代表有脉冲,“ 0”代表脉冲间隔。如果波形上每个点的信息用四位一组的代码表示,则称 4比特,比特数越高,表达模拟信号就越精确,对音频信号信号还原能力越强。 计算机中的位 二进制数系统中, 每个 0或 1就是一个位 (bit, 位是数据存储的最小单位。其 中 8bit 就称为一个字节 (Byte 。计算机中的 CPU 位数指的是 CPU 一次能处理的最大位数。例如 32位计算机的 CPU 一次最多能处理 32位数据。 Bit ,乃 BInary digit(二进制数位的缩写,是数学家 John Wilder Tukey提议的术语(可能是 1946年提出,但有资料称 1943年就提出的 字节 字节(Byte :字节是通过网络传输信息(或在硬盘或内存中存储信息的单位。 字节是计算机信息技术用于计量存储容量和传输容量的一种计量单位, 1个字节等于 8位二进制。
帧 帧的传输 -----在网络中,网络设备将“位”组成一个个的字节,然后这些字节“封装” 成帧,在网络上传输。为什么要把数据“封装”成帧呢?因为用户数据一般都比较大, 有的可以达到 MB 字节, 一下子发送出去十分困难, 于是就需要把数据分成许多小份,再按照一定的次序发送出去。 在网络中,网络设备将“位”组成一个个的字节,然后这些字节“封装”成帧,在网络上传输。为什么要把数据“封装”成帧呢?因为用户数据一般都比较大,有的可以达到MB 字节, 一下子发送出去十分困难, 于是就需要把数据分成许多小份, 再按照一定的次序发送出去。 以太网的帧值总是在一定范围内浮动,最大的帧值是 1518字节,最小的帧值是64字节。在实际应用中,帧的大小是由设备的 MTU (最大传输单位即设备每次能够传输的最大字节数自动来确定的。 帧是当计算机发送数据时产生的,确切地说,是由计算机中安装的网卡产生的。帧只对于能够识别它的设备才有意义。对于集线器来说,帧是没有意义的,因为它是物理层设备,只认识脉冲电流。有许多人对帧不理解,所以不能很好地理解交换机与集线器的区别。 看了以上这么多, 也许你还是不明白, 其实, 二进制并不是网管员要打交道的东西, 而帧才是网管员真正要注意的东西, 所以在 Windows 2000的“网络监视器” 中, “帧” 才是被监视的对象。但我们究竟怎样监视帧呢? 网络上的帧 ---数据在网络上是以很小的称为帧(Frame 的单位传输的,帧由几部分组成, 不同的部分执行不同的功能。帧通过特定的称为网络驱动程序的软件进行成型,然后通过网卡发送到网线上,通过网线到达它们的目的机器,在目的机器的一端执行相反的
byte数组转化成16进制字符串用法分析
byte数组转化成16进制字符串,C#中的overload,overwrite,override的区别 C++ 实现Single Sever Simulation AFNetworking 更改请求时间iOS chrome插件，二维码自动生成,C编程方式进行控制台输入 maven jar shade assembly配置[XML] Maven pom.xml public: double angle; QPen ang_info_pen; }; #endif [文件] MainWindow.cpp ~ 28KB [文件] MainWindow.h ~ 3KB //AngularJS 绑定鼠标左键、右键单击事件 //API权限设计总结系统sign验证规则 //Apriopri算法的简单实现 #ifndef __MAINWINDOW_H__ #define __MAINWINDOW_H__ #include "ui_MainWindow.h" #include "Shape.h" #include
bit与byte的区别,字节与字长的区别
Bit意为“位”或“比特”，是计算机运算的基础，属于二进制的范筹； Byte意为“字节”，是计算机文件大小的基本计算单位； 这两者应用的场合不同。通常用bit来作数据传输的单位，因为物理层，数据链路层的传输对于用户是透明的，而这种通信传输是基于二进制的传输。在应用层通常是用byte来作单位，表示文件的大小，在用户看来就是可见的数据大小。比如一个字符就是1byte,如果是汉字，则是2byte。 下面是2个具体应用实例： Mbps=mega bits per second(兆位/秒)是速率单位， MB=mega bytes(兆比、兆字节)是量单位，1MB/S（兆字节/秒）=8MBPS（兆位/秒）。 我们所说的硬盘容量是40GB、80GB、100GB，这里的B指是的Byte也就是“字节”。(与容量相关，应用层） 1 bit = 1 二进制数据 1 byte = 8 bit 1 字母= 1 byte = 8 bit 1 汉字= 2 byte = 16 bit 1Byte=8Bit=1字节 1字=2字节 1. bit：位 一个二进制数据0或1，是1bit； 2. byte：字节 存储空间的基本计量单位，如：MySQL中定义 VARCHAR(45) 即是指45个字节； 1 byte = 8 bit1. bit：位 一个二进制数据0或1，是1bit； 1 KB = 1024 bytes =2^10 bytes 1 MB = 1024 KB = 2^20 bytes 1 GB = 1024 MB = 2^30 bytes USB2.0标准接口传输速率是480兆位/秒,即480MBps。这里的B指是的Bit也就是“位”。（与传输相关，底层） 注：另外，Byte通常简写为B(大写），而bit通常简写为b（小写）。可以这么记忆，用大写的就是数据值比较大的位，而小字的就是数据值比较小的字节，1B=8b。 位：在数字电路和电脑技术中采用二进制，代码只有“0”和“1”，其中无论是“0”或是“1”在CPU中都是一“位”。 字长：电脑技术中对CPU在单位时间内(同一时间)能一次处理的二进制数的位数叫字长。所以能处理字长为8位数据的CPU通常就叫8位的CPU。同理32
字符串和字符数组之间的转换
字符串和字符数组之间的转换 2010-11-02 16:53:00| 分类： |举报|字号订阅 字符串类提供了一个void ToCharArray() 方法，该方法可以实现字符串到字符数组的转换。如下例： private void TestStringChars() { string str = "mytest"; char[] chars = (); = ""; "Length of \"mytest\" is " + + "\n"); "Length of char array is " + + "\n"); "char[2] = " + chars[2] + "\n"); } 例中以对转换转换到的字符数组长度和它的一个元素进行了测试，结果如下： Length of "mytest" is 6 Length of char array is 6 char[2] = t 可以看出，结果完全正确，这说明转换成功。那么反过来，要把字符数组转换成字符串又该如何呢？ 我们可以使用类的构造函数来解决这个问题。类有两个构造函数是通过字符数组来构造的，即 String(char[]) 和String[char[], int, int)。后者之所以多两个参数，是因为可以指定用字符数组中的哪一部分来构造字符串。而前者则是用字符数组的全部元素来构造字符串。我们以前者为例， 在 TestStringChars() 函数中输入如下语句： char[] tcs = {'t', 'e', 's', 't', ' ', 'm', 'e'}; string tstr = new String(tcs); "tstr = \"" + tstr + "\"\n"); 运行结果输入 tstr = "test me"，测试说明转换成功。 实际上，我们在很多时候需要把字符串转换成字符数组只是为了得到该字符串中的某个字符。如果只是为了这个目的，那大可不必兴师动众的去进行转换，我们
双字、字、字节和位的关系总结
双字、字、字节和位的关系总结 一、资料查询： 相信从网上搜一下西门子数据类型方面的资料，会有一大堆，最常见的就是解释双字和字节之间的组成关系，如下图： 就以这个资料为基础，进行试验验证； 二、程序准备 由于资料上大部分都是以M区介绍双字和字节等关系，但是实际情况是DB块中的数据居多，故在此实验中，将M区和DB区的内容进行对比，以方便观察，进行如下准备： 1、新建DB块，里面创建需要的变量： 2、创建M区变量，以方便做比较，这里取MD24,然后将其拆成字、字节、位，以方便观察： 3、创建FC程序：主要是将双字拆成字、双字，并将双字传送给单字、单字传送给双字，为了方便置位双字中的位，特意用数组逐位传送给双字中的位：
三、程序验证： 省略掉程序的下载啊、仿真啊的操作步骤，因为那个不是重点，直接展示测试结果：从数组中，分别置位不同的位，则相当于分别对双字中的位进行置位，可以分别观察结果，现在取比较有代表性的两个位，即将第0位和第16位置1，结果如下两图所示： 通过测试可以发现如下规律： 1、西门子双字中位的排列，是从右向左排的，这点和平时写字顺序正好相反，但是我觉得可以从进制的位数去记忆一下，比如我们十进制，从右往左分别是个、十、百、千、万等位，这个正好类似于那个； 2、可以看下双字传给单字的情况，对于截取数据时候比较有帮助，具体不总结，可以体会一下； 3、第三条也是我一开始比较迷糊的地方，观察双字的四个字节，和位的排序是一样的，即0位在右，依次往左增大，但是M区其实按照这个方向排列，但是让人很迷糊，上图为例，我们置位0位的时候，在DB中是第0个字节有变化，但是在M区中对应的是MB27变化，虽然按照一开始资料所示，MB27是在
inputStream和String,Byte之间的转换
1.import java.io.ByteArrayInputStream; 2.import java.io.ByteArrayOutputStream; 3.import java.io.IOException; 4.import java.io.InputStream; 5. 6./** 7. * 8. * @author Andy.Chen 9. * @mail Chenjunjun.ZJ@https://www.360docs.net/doc/217508458.html, 10. * 11. */ 12.public class InputStreamUtils { 13. 14. final static int BUFFER_SIZE = 4096; 15. 16. /** 17. * 将InputStream转换成String 18. * @param in InputStream 19. * @return String 20. * @throws Exception 21. * 22. */ 23. public static String InputStreamTOString(InputStream in) throws Ex ception{ 24. 25. ByteArrayOutputStream outStream = new ByteArrayOutputStream(); 26. byte[] data = new byte[BUFFER_SIZE]; 27. int count = -1; 28. while((count = in.read(data,0,BUFFER_SIZE)) != -1) 29. outStream.write(data, 0, count); 30. 31.data = null; 32. return new String(outStream.toByteArray(),"ISO-8859-1"); 33. } 34. 35. /** 36. * 将InputStream转换成某种字符编码的String 37. * @param in 38. * @param encoding 39. * @return 40. * @throws Exception 41. */
字和字节和位的关系
1、位（bit） 来自英文bit，音译为“比特”，表示二进制位。位是计算机内部数据储存的最小单位，是一个8位二进制数。一个二进制位只可以表示0和1两种状态（21）；两个二进制位可以表示00、01、10、11四种（22）状态；三位二进制数可表示八种状态（23）……。 2、字节（byte） 字节来自英文Byte，音译为“拜特”，习惯上用大写的“B”表示。 字节是计算机中数据处理的基本单位。计算机中以字节为单位存储和解释信息，规定一个字节由八个二进制位构成，即1个字节等于8个比特（1Byte=8bit）。八位二进制数最小为00000000，最大为；通常1个字节可以存入一个ASCII码，2个字节可以存放一个汉字国标码。 3、字 计算机进行数据处理时，一次存取、加工和传送的数据长度称为字（word）。一个字通常由一个或多个（一般是字节的整数位）字节构成。例如286微机的字由2个字节组成，它的字长为16；486微机的字由4个字节组成，它的字长为32位机。 计算机的字长决定了其CPU一次操作处理实际位数的多少，由此可见计算机的字长越大，其性能越优越。 另一种说法: 字 在计算机中，一串数码作为一个整体来处理或运算的，称为一个计算机字，简称宇。字通常分为若干个字节(每个字节一般是8位)。在存储器中，通常每个单元存储一个字，因此每个字都是可以寻址的。字的长度用位数来表示。 在计算机的运算器、控制器中，通常都是以字为单位进行传送的。宇出现在不问的地址其含义是不相同。例如，送往控制器去的字是指令，而送往运算器去的字就是一个数。 在计算机中作为一个整体被存取、传送、处理的二进制数字符串叫做一个字或单元，每个字中二进制位数的长度，称为字长。一个字由若干个字节组成，不同的计算机系统的字长是不同的，常见的有8位、16位、32位、64位等，字长越长，计算机一次处理的信息位就越多，精度就越高，字长是计算机性能的一个重要指标。目前主流微机都是32位机。 注意字与字长的区别，字是单位，而字长是指标，指标需要用单位去衡量。正象生活中重量与公斤的关系，公斤是单位，重量是指标，重量需要用公斤加以衡量。 字长 计算机的每个字所包含的位数称为字长。根据计算机的不同，字长有固定的和可变的两种。固定字长，即字长度不论什么情况都是固定不变的；可变字长，则在一定范围内，其长度是可变的。 计算的字长是指它一次可处理的二进创数字的数目。计算机处理数据的速率，自然和它一次能加工的位数以及进行运算的快慢有关。如果一台计算机的字长是另一台计算机的两倍，即使两台计算机的速度相同，在相同的时间内，前者能做的工作是后者的两倍。
short,int,long与byte数组之间的转换
1. 2.package com.test; 3. 4.import java.nio.ByteBuffer; 5. 6.public class ByteUtil { 7. 8./** 9. * @param args 10. */ 11. public static void main(String[] args) { 12. test2(); 13. } 14. public static void test2() 15. { 16. short s = -20; 17. byte[] b = new byte[2]; 18. putReverseBytesShort(b, s, 0); 19. ByteBuffer buf = ByteBuffer.allocate(2); 20. buf.put(b); 21. buf.flip(); 22. System.out.println(getReverseBytesShort(b, 0)); 23. System.out.println(Short.reverseBytes(buf.getShort())); 24. System.out.println("***************************"); 25. int i = -40; 26. b = new byte[4]; 27. putReverseBytesInt(b, i, 0); 28. buf = ByteBuffer.allocate(4); 29. buf.put(b); 30. buf.flip(); 31. System.out.println(getReverseBytesInt(b, 0)); 32. System.out.println(Integer.reverseBytes(buf.getInt())); 33. System.out.println("***************************"); 34. long l = -50; 35. b = new byte[8]; 36. putReverseBytesLong(b, l, 0); 37. buf = ByteBuffer.allocate(8); 38. buf.put(b); 39. buf.flip(); 40. System.out.println(getReverseBytesLong(b, 0)); 41. System.out.println(Long.reverseBytes(buf.getLong())); 42. System.out.println("***************************"); 43. } 44. public static void test1()
bit、byte、位、字节、汉字的关系
bit、byte、位、字节、汉字的关系 1 bit = 1 二进制数据 1 byte = 8 bit 1 字母= 1 byte = 8 bit 1 汉字= 2 byte = 16 bit 1. bit：位 一个二进制数据0或1，是1bit； 2. byte：字节 存储空间的基本计量单位，如：MySQL中定义 VARCHAR(45) 即是指45个字节； 1 byte = 8 bit 3. 一个英文字符占一个字节； 1 字母= 1 byte = 8 bit 4. 一个汉字占2个字节； 1 汉字= 2 byte = 16 bit 5. 标点符号 A>. 汉字输入状态下，默认为全角输入方式； B>. 英文输入状态下，默认为半角输入方式； C>. 全角输入方式下，标点符号占2字节； D>. 半角输入方式下，标点符号占1字节； 故：汉字输入状态下的字符，占2个字节(但不排除，自己更改了默认设置)； 英文输入状态下的字符，占1个字节(但不排除，自己更改了默认设置)； 老美在发明电脑时，肯定以自己的英文字母--即他们自认为的字符为最小的存储计量单位，于是也就有了不规范的1字符=1byte，岂不知还有我们伟大的汉字计量单位，NND，一个汉字也是一个字符，我们的1汉字字符就等于2byte，后来，他们可能意识到这个尴尬的问题，于是又标榜为：一个字母为一个标准字符，去球吧，谁整天没事说个字符还“标准字符”，所以啊，个人认为：字符，不能用于标准的计量单位。 -------------------------------- 补充： 计算机对各国语言的支持度，可分为以下三个阶段，如图：
转载：https://www.360docs.net/doc/217508458.html,/Zevin/article/details/5772670 Byte（字节）与bit的区别： 在计算机科学中，bit是表示信息的最小单位，叫做二进制位；一般用0和1表示。Byte叫做字节，由8个位（8bit）组成一个字节(1Byte)，用于表示计算机中的一个字符。bit与Byte 之间可以进行换算，其换算关系为：1Byte=8bit（或简写为：1B=8b）；在实际应用中一般用简称，即1bit简写为1b(注意是小写英文字母b)，1Byte简写为1B（注意是大写英文字母B）。 我们所说的硬盘容量是40GB、80GB、100GB，这里的B指是的Byte也就是“字节”。 1 KB = 1024 Bytes =2^10 Bytes 1 MB = 1024 KB = 2^20 Bytes 1 GB = 1024 MB = 2^30 Bytes
JAVA二进制字节数组字符十六进制BCD编码转换
JAVA二进制字节数组字符十六进制BCD编码转换; import java.io.*; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; public class DataConverter { /* 把16进制字符串转换成字节数组 * @param hex * @return */ public static byte[] hexStringToByte(String hex) { int len = (hex.length() / 2); byte[] result = new byte[len]; char[] achar = hex.toCharArray(); for (int i = 0; i < len; i++) { int pos = i * 2; result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1])); } return result; } private static byte toByte(char c) { byte b = (byte) "0123456789ABCDEF".indexOf(c); return b; } /** *//** * 把字节数组转换成16进制字符串 * @param bArray * @return */ public static final String bytesToHexString(byte[] bArray) { StringBuffer sb = new StringBuffer(bArray.length); String sTemp; for (int i = 0; i < bArray.length; i++) { sTemp = Integer.toHexString(0xFF & bArray[i]); if (sTemp.length() < 2) sb.append(0); sb.append(sTemp.toUpperCase()); }
C语言编程常见问题解答之位(bit)和字节(byte)
C语言编程常见问题解答之位(bit)和字节(byte) 位指的是二进制系统中的一位，它是最小的信息单位。位的用处可以从两方面去分析：第一，计算机对位的值可以有任意多种解释，例如表示"yes''或"no"，或者表示磁盘是否已插入驱动器，或者表示某个鼠标键是否被按下；第二，将若干位的值连接起来后，就可以表示更复杂的数据，而且每增加一位，可以表示的可能的值的数目就会增加一倍。 换句话说，一位可以表示两种可能的值，即"O"和"1"；两位可以表示2×2或4种可能的值，即"00"，"01"，"10"和"11"；类似地，三位可以表示2×2×2或8种可能的值......。对计算机来说，位的这种特性既是最有力的支持--因为很复杂的数据(例如本书内容)可以被分解为位的表示后存储起来，又是的限制--因为在现实生活中许多事物的值是不精确的，这样的值无法用数目有限的若干位来表示。 程序员始终必须清楚每一项数据需要用多少位来表示。因为位作为单位太小，所以为了方便起见，大多数计算机所处理的信息单位是被称为字节的位块。字节是大多数计算机中最小的可寻址的信息单位，这意味着计算机给每一个字节的信息都赋予一个地址，并且一次只能存取一个字节的信息。一个字节中的位的数目可以是任意的，并且在不同的计算机中可以不同。最常见的情况是每个字节中有8位，即可以存放256个不同的值。8位这样的长度非常适合于存放表示ASCII(the American Standard Code for Information Interchange)字符的数据。 下述程序可以显示空格符以后的ASCII字符和PC机的图形字符集： # include void main (void); void main() { /" Display ASCII char set " / unsigned char space = '' ; /* Start with SPACE char = 8 bits only * / int ctr = 0; printf(" ASCII Characters\n" )"
JAVA里面关于byte数组和String之间的转换问题
JAVA里面关于byte数组和String之间的转换问题把byte转化成string，必须经过编码。 例如下面一个例子: import java.io.UnsupportedEncodingException; public class test{ public static void main(String g[]) { String s = "12345abcd"; byte b[] = s.getBytes(); String t = b.toString(); System.out.println(t); } } 输出字符串的结果和字符串s不一样了. 经过以下方式转码就可以正确转换了: public class test{ public static void main(String g[]) { String s = "12345abcd"; byte b[] = s.getBytes(); try { String t = new String(b); System.out.print(t); } catch (Exception e) { e.printStackTrace(); } } } String str = "String"; byte[] byte1 = str.getBytes(); String str1 = new String(byte1); byte[] byte2 = str1.getBytes(); String str2 = new String(byte2); System.out.println("str<<<" + str); System.out.println("byte1<<<" + byte1); System.out.println("str1<<<" + str1); System.out.println("byte2<<<" + byte2); System.out.println("str2<<<" + str2); ------------------------------------- 输出结果 str<< 类似的文章在网上可以看到不少，但多多少少都存在一些问题。这两天做实验室的项目用到这个功能，我从头把它整理了一遍。 在看代码之前，首先解释几个问题。 byte数组存放的是图像每个像素的灰度值，byte类型正好是从0~255，存放8bit灰度图像的时候，一个数组元素就是一个像素的灰度值。仅有这个数组还不足以恢复出原来的图像，还必须事先知道图像的长、宽值； 创建Bitmap类的时候必须指定PixelFormat为Format8bppIndexed，这样才最符合图像本身的特性； Bitmap类虽然提供了GetPixel()、SetPixel()这样的方法，但我们绝对不能用这两个方法来进行大规模的像素读写，因为它们的性能实在很囧； 托管代码中，能不用unsafe就尽量不用。在.NET 2.0中已经提供了BitmapData类及其LockBits()、UnLockBits()操作，能够安全地进行内存读写； 图像的width和它存储时的stride是不一样的。位图的扫描线宽度一定是4的倍数，因此图像在内存中的大小并不是它的显示大小； Format8bppIndexed类型的PixelFormat是索引格式，其调色板并不是灰度的而是伪彩，因此需要我们对其加以修改。 代码如下，解说写在注释里了： 1 /// C#中将byte数组转换为8bit灰度图像