当前位置：首页 » 编程语言 » java操作位

java操作位

发布时间: 2021-03-04 04:11:19

① java:二进制的按位与操作怎么做求助大神！

//先用链接中的方法，把Stringa,b分别转换成byte[]数组data_a和data_b
byte[]data_a=hex2byte(a);
byte[]data_b=hex2byte(b);
byte[]data_c=newbyte[a.length];//结果串
//逐个直接进行位与运算()
for(inti=0;i<a.Length;i++){
data_c[i]=data_a[i]&data_b[i];
}
//此时data_c中就是按位与结果，再转换成字符串
Stringc=byte2hex(data_c);
//c便是结果字符串。

② java中的位运算符及其用法。

位逻辑运算符有“与”（AND）、“或”（OR）、“异或（XOR）”、“非（NOT）”，分别用“&”、“|”、“^”、“~”表示。

下面的例子说明了位逻辑运算符：

// Demonstrate the bitwise logical operators.

class BitLogic {

public static void main(String args[]) {

String binary[] = {

"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111",

"1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"

};

int a = 3; // 0 + 2 + 1 or 0011 in binary

int b = 6; // 4 + 2 + 0 or 0110 in binary

int c = a | b;

int d = a & b;

int e = a ^ b;

int f = (~a & b) | (a & ~b);

int g = ~a & 0x0f;

System.out.println(" a = " + binary[a]);

System.out.println(" b = " + binary[b]);

System.out.println(" a|b = " + binary[c]);

System.out.println(" a&b = " + binary[d]);

System.out.println(" a^b = " + binary[e]);

System.out.println("~a&b|a&~b = " + binary[f]);

System.out.println(" ~a = " + binary[g]);

}

}

在本例中，变量a与b对应位的组合代表了二进制数所有的 4 种组合模式：0-0，0-1，1-0，和1-1。“|”运算符和“&”运算符分别对变量a与b各个对应位的运算得到了变量c和变量d的值。对变量e和f的赋值说明了“^”运算符的功能。字符串数组binary代表了0到15对应的二进制的值。在本例中，数组各元素的排列顺序显示了变量对应值的二进制代码。数组之所以这样构造是因为变量的值n对应的二进制代码可以被正确的存储在数组对应元素binary[n]中。例如变量a的值为3，则它的二进制代码对应地存储在数组元素binary[3]中。~a的值与数字0x0f （对应二进制为0000 1111）进行按位与运算的目的是减小~a的值，保证变量g的结果小于16。因此该程序的运行结果可以用数组binary对应的元素来表示。该程序的输出如下：

a = 0011

b = 0110

a|b = 0111

a&b = 0010

a^b = 0101

~a&b|a&~b = 0101

~a = 1100

左移运算符

左移运算符<<使指定值的所有位都左移规定的次数。它的通用格式如下所示：

value << num

这里，num指定要移位值value移动的位数。也就是，左移运算符<<使指定值的所有位都左移num位。每左移一个位，高阶位都被移出（并且丢弃），并用0填充右边。这意味着当左移的运算数是int类型时，每移动1位它的第31位就要被移出并且丢弃；当左移的运算数是long类型时，每移动1位它的第63位就要被移出并且丢弃。

在对byte和short类型的值进行移位运算时，你必须小心。因为你知道Java在对表达式求值时，将自动把这些类型扩大为 int型，而且，表达式的值也是int型。对byte和short类型的值进行移位运算的结果是int型，而且如果左移不超过31位，原来对应各位的值也不会丢弃。但是，如果你对一个负的byte或者short类型的值进行移位运算，它被扩大为int型后，它的符号也被扩展。这样，整数值结果的高位就会被1填充。因此，为了得到正确的结果，你就要舍弃得到结果的高位。这样做的最简单办法是将结果转换为byte型。下面的程序说明了这一点：

// Left shifting a byte value.

class ByteShift {

public static void main(String args[]) {

byte a = 64, b;

int i;

i = a << 2;

b = (byte) (a << 2);

System.out.println("Original value of a: " + a);

System.out.println("i and b: " + i + " " + b);

}

}

该程序产生的输出下所示：

Original value of a: 64

i and b: 256 0

因变量a在赋值表达式中，故被扩大为int型，64（0100 0000）被左移两次生成值256（10000 0000）被赋给变量i。然而，经过左移后，变量b中惟一的1被移出，低位全部成了0，因此b的值也变成了0。

既然每次左移都可以使原来的操作数翻倍，程序员们经常使用这个办法来进行快速的2的乘法。但是你要小心，如果你将1移进高阶位（31或63位），那么该值将变为负值。下面的程序说明了这一点：

// Left shifting as a quick way to multiply by 2.

class MultByTwo {

public static void main(String args[]) {

int i;

int num = 0xFFFFFFE;

for(i=0; i<4; i++) {

num = num << 1;

System.out.println(num);

}

}

}

该程序的输出如下所示：

536870908

1073741816

2147483632

-32

初值经过仔细选择，以便在左移 4 位后，它会产生-32。正如你看到的，当1被移进31位时，数字被解释为负值。

右移运算符

右移运算符>>使指定值的所有位都右移规定的次数。它的通用格式如下所示：

value >> num

这里，num指定要移位值value移动的位数。也就是，右移运算符>>使指定值的所有位都右移num位。

下面的程序片段将值32右移2次，将结果8赋给变量a:

int a = 32;

a = a >> 2; // a now contains 8

当值中的某些位被“移出”时，这些位的值将丢弃。例如，下面的程序片段将35右移2次，它的2个低位被移出丢弃，也将结果8赋给变量a:

int a = 35;

a = a >> 2; // a still contains 8

用二进制表示该过程可以更清楚地看到程序的运行过程：

00100011 35

>> 2

00001000 8

将值每右移一次，就相当于将该值除以2并且舍弃了余数。你可以利用这个特点将一个整数进行快速的2的除法。当然，你一定要确保你不会将该数原有的任何一位移出。

右移时，被移走的最高位（最左边的位）由原来最高位的数字补充。例如，如果要移走的值为负数，每一次右移都在左边补1，如果要移走的值为正数，每一次右移都在左边补0，这叫做符号位扩展（保留符号位）（sign extension），在进行右移操作时用来保持负数的符号。例如，–8 >> 1 是–4，用二进制表示如下：

11111000 –8

>>1

11111100 –4

一个要注意的有趣问题是，由于符号位扩展（保留符号位）每次都会在高位补1，因此-1右移的结果总是–1。有时你不希望在右移时保留符号。例如，下面的例子将一个byte型的值转换为用十六进制表示。注意右移后的值与0x0f进行按位与运算，这样可以舍弃任何的符号位扩展，以便得到的值可以作为定义数组的下标，从而得到对应数组元素代表的十六进制字符。

// Masking sign extension.

class HexByte {

static public void main(String args[]) {

char hex[] = {

'0', '1', '2', '3', '4', '5', '6', '7',

'8', '9', 'a', 'b', 'c', 'd', 'e', 'f''

};

byte b = (byte) 0xf1;

System.out.println("b = 0x" + hex[(b >> 4) & 0x0f] + hex[b & 0x0f]);

}

}

该程序的输出如下：

b = 0xf1

无符号右移

正如上面刚刚看到的，每一次右移，>>运算符总是自动地用它的先前最高位的内容补它的最高位。这样做保留了原值的符号。但有时这并不是我们想要的。例如，如果你进行移位操作的运算数不是数字值，你就不希望进行符号位扩展（保留符号位）。当你处理像素值或图形时，这种情况是相当普遍的。在这种情况下，不管运算数的初值是什么，你希望移位后总是在高位（最左边）补0。这就是人们所说的无符号移动（unsigned shift）。这时你可以使用Java的无符号右移运算符>>>，它总是在左边补0。下面的程序段说明了无符号右移运算符>>>。在本例中，变量a被赋值为-1，用二进制表示就是32位全是1。这个值然后被无符号右移24位，当然它忽略了符号位扩展，在它的左边总是补0。这样得到的值255被赋给变量a。

int a = -1;

a = a >>> 24;

下面用二进制形式进一步说明该操作：

11111111 11111111 11111111 11111111 int型- 1的二进制代码

>>> 24 无符号右移24位

00000000 00000000 00000000 11111111 int型255的二进制代码由于无符号右移运算符>>>只是对32位和64位的值有意义，所以它并不像你想象的那样有用。因为你要记住，在表达式中过小的值总是被自动扩大为int型。这意味着符号位扩展和移动总是发生在32位而不是8位或16位。这样，对第7位以0开始的byte型的值进行无符号移动是不可能的，因为在实际移动运算时，是对扩大后的32位值进行操作。下面的例子说明了这一点：

// Unsigned shifting a byte value.

class ByteUShift {

static public void main(String args[]) {

char hex[] = {

'0', '1', '2', '3', '4', '5', '6', '7',

'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'

};

byte b = (byte) 0xf1;

byte c = (byte) (b >> 4);

byte d = (byte) (b >>> 4);

byte e = (byte) ((b & 0xff) >> 4);

System.out.println(" b = 0x"

+ hex[(b >> 4) & 0x0f] + hex[b & 0x0f]);

System.out.println(" b >> 4 = 0x"

+ hex[(c >> 4) & 0x0f] + hex[c & 0x0f]);

System.out.println(" b >>> 4 = 0x"

+ hex[(d >> 4) & 0x0f] + hex[d & 0x0f]);

System.out.println("( b & 0xff) >> 4 = 0x"

+ hex[(e >> 4) & 0x0f] + hex[e & 0x0f]);

}

}

该程序的输出显示了无符号右移运算符>>>对byte型值处理时，实际上不是对byte型值直接操作，而是将其扩大到int型后再处理。在本例中变量b被赋为任意的负byte型值。对变量b右移4位后转换为byte型，将得到的值赋给变量c，因为有符号位扩展，所以该值为0xff。对变量b进行无符号右移4位操作后转换为byte型，将得到的值赋给变量d，你可能期望该值是0x0f，但实际上它是0xff，因为在移动之前变量b就被扩展为int型，已经有符号扩展位。最后一个表达式将变量b的值通过按位与运算将其变为8位，然后右移4位，然后将得到的值赋给变量e，这次得到了预想的结果0x0f。由于对变量d（它的值已经是0xff）进行按位与运算后的符号位的状态已经明了，所以注意，对变量d再没有进行无符号右移运算。

B = 0xf1

b >> 4 = 0xff

b >>> 4 = 0xff

(b & 0xff) >> 4 = 0x0f

位运算符赋值

所有的二进制位运算符都有一种将赋值与位运算组合在一起的简写形式。例如，下面两个语句都是将变量a右移4位后赋给a：

a = a >> 4;

a >>= 4;

同样，下面两个语句都是将表达式a OR b运算后的结果赋给a：

a = a | b;

a |= b;

下面的程序定义了几个int型变量，然后运用位赋值简写的形式将运算后的值赋给相应的变量：

class OpBitEquals {

public static void main(String args[]) {

int a = 1;

int b = 2;

int c = 3;

a |= 4;

b >>= 1;

c <<= 1;

a ^= c;

System.out.println("a = " + a);

System.out.println("b = " + b);

System.out.println("c = " + c);

}

}

该程序的输出如下所示：

a = 3

b = 1

c = 6

③ java里怎么对Byte进行位操作

//byte buf[]=为数组 for(byte b:buf){ System.out.print(b&15);//打印每个节的低四位 System.out.println(b>>>4);//打印每个节的高四位 }

④ java，位操作区别

>>是无符号数的右移
>>>是有符号的右移
这个符号只得是+ -号
如果你用 >>和-1 这样的负数去移位的话的出的结果就会完全出错

⑤ JAVA位运算符。。

~ 按位非（NOT） b = ~a
& 按位与（AND） c = a & b
| 按位或（OR） c = a | b
^ 按位异或（XOR） c = a ^ b
>> 右移 b = a >> 2
>>> 右移，左边空出的位以0填充 b = a >>> 2
<< 左移 b = a << 1

当然同样有 &=，|=，^=，>>=，>>>=，<<=。

有关这些操作的细节可以参看

http://www.pcvc.net/category/content.asp?sendid=247

位运算

前面介绍的各种运算都是以字节作为最基本位进行的。但在很多系统程序中常要求在位(bit)一级进行运算或处理。C语言提供了位运算的功能，这使得C语言也能像汇编语言一样用来编写系统程序。
一、位运算符C语言提供了六种位运算符：
& 按位与
| 按位或
^ 按位异或
~ 取反
<< 左移
>> 右移

1. 按位与运算按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。
例如：9&5可写算式如下： 00001001 (9的二进制补码)&00000101 (5的二进制补码) 00000001 (1的二进制补码)可见9&5=1。

按位与运算通常用来对某些位清0或保留某些位。例如把a 的高八位清 0 ，保留低八位，可作 a&255 运算 ( 255 的二进制数为0000000011111111)。
main(){
int a=9,b=5,c;
c=a&b;
printf("a=%d\nb=%d\nc=%d\n",a,b,c);
}

2. 按位或运算按位或运算符“|”是双目运算符。其功能是参与运算的两数各对应的二进位相或。只要对应的二个二进位有一个为1时，结果位就为1。参与运算的两个数均以补码出现。
例如：9|5可写算式如下： 00001001|00000101
00001101 (十进制为13)可见9|5=13
main(){
int a=9,b=5,c;
c=a|b;
printf("a=%d\nb=%d\nc=%d\n",a,b,c);
}

3. 按位异或运算按位异或运算符“^”是双目运算符。其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。参与运算数仍以补码出现，例如 9^5可写成算式如下： 00001001^00000101 00001100 (十进制为12)
main(){
int a=9;
a=a^15;
printf("a=%d\n",a);
}

4. 求反运算求反运算符～为单目运算符，具有右结合性。其功能是对参与运算的数的各二进位按位求反。例如～9的运算为： ~(0000000000001001)结果为：1111111111110110

5. 左移运算左移运算符“<<”是双目运算符。其功能把“<< ”左边的运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，
高位丢弃，低位补0。例如： a<<4 指把a的各二进位向左移动4位。如a=00000011(十进制3)，左移4位后为00110000(十进制48)。6. 右移运算右移运算符“>>”是双目运算符。其功能是把“>> ”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数。
例如：设 a=15，a>>2 表示把000001111右移为00000011(十进制3)。应该说明的是，对于有符号数，在右移时，符号位将随同移动。当为正数时，最高位补0，而为负数时，符号位为1，最高位是补0或是补1 取决于编译系统的规定。Turbo C和很多系统规定为补1。

⑥ java中按位与和按位或的问题

按位与 &
按位或 |

转为二进制操作即可

&: 两位同时为“1”，结果才为“1”，否则为0
|: 参加运算的两个对象只要有一个为1，其值为1。

按位与：

5: 0000 0101
9: 0000 1001
1: 0000 0001

按位或：

5: 0000 0101
9: 0000 1001
13: 0000 1101

⑦ JAVA中字符的位操作

这个地址也由参考的可以去下了看看 http://download.csdn.net/source/1282762

这是C的仅供参考

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define MAX_SINGLECODE_LEN 10 //单个字符最大码长
#define MAX_STRING_LEN 1000 //要编码的字符串的最大长度
#define MAX_CODESTRING_LEN 10000 //产生的二进制码的最大长度
#define MAX_WORDS 1000 //要编码的字符串中字符种数最大值
#define END_TREE 30000 //树部分存储的结束符
#define PATH_LEN 50 //路径串最大长度

/*****哈夫曼树结构定义*****/
typedef struct Huffmantree
{
char ch; //字符部分
int weight; //结点权值
int mark; //标记是否加入树中
struct Huffmantree *parent,*lchild,*rchild,*next;
}HTNode,*LinkTree;

/*****编码字典结构定义*****/
typedef struct
{
char ch; //字符部分
char code[MAX_SINGLECODE_LEN]; //编码部分
}CodeDictionary;

/*********函数声明*********/
LinkTree setWeight(char *);
LinkTree sortNode(LinkTree);
LinkTree createHTree(LinkTree);
void codeHTree(LinkTree,CodeDictionary *);
void decodeHTree(LinkTree,char *,char *);
void deleteNode(LinkTree);
void compressString(char *s,CodeDictionary *,char *);
void readFile(char *);
void writeFile(char *);
void readCode(LinkTree,char *);
void writeCode(LinkTree,char *);
void menu();

/**
*主函数
*输入：空
*返回：空
*/
void main(void)
{
char choice; //菜单选择变量
char string[MAX_STRING_LEN]; //保存从文件中读取的内容
LinkTree temp; //保存赋了权值的表
LinkTree ht; //保存排序后的表
LinkTree ht,temp; //表备份
LinkTree htree; //保存哈夫曼树
LinkTree ptr=NULL;
CodeDictionary codedictionary[MAX_WORDS];//编码字典
char codestring[MAX_CODESTRING_LEN]; //保存0-1形的代码串
char codestring2[MAX_CODESTRING_LEN];//保存0-1形的代码串
LinkTree ht2; //保存读取的树
LinkTree htree2; //保存排序后的表
char filestring[MAX_STRING_LEN]; //解码后要写入文件中的内容

if((ht2=(LinkTree)malloc(sizeof(HTNode)))==NULL)//创建链表的头结点
{
printf("内存不足！");
getch();
exit(0);
}
ht2->next=NULL;

while(1)
{
menu(); //调入主菜单
choice=getch(); //读入用户选项
switch(choice) //判断用户选择
{
case 'c':
case 'C':
printf("\n您选择了压缩文件模式:\n\n");
readFile(string); //读取要编码的文件（字符串）
temp=setWeight(string); //得到有权值的表
temp=setWeight(string);
ht=sortNode(temp); //按权值排序后的表
ht=sortNode(temp); //用于记录解码树
htree=createHTree(ht); //得到哈夫曼树
codeHTree(htree,codedictionary);//哈夫曼编码
compressString(string,codedictionary,codestring);//压缩为0-1码
writeCode(ht,codestring); //将解码树和0-1码保存
deleteNode(htree); //释放空间*/
break;
case 'u':
case 'U':
printf("您选择了解压缩文件模式:\n\n");
readCode(ht2,codestring2); //读取要解码的0-1码
htree2=createHTree(ht2); //得到哈夫曼树
codeHTree(htree2,codedictionary);//哈夫曼编码
decodeHTree(htree2,codestring2,filestring); //解码
writeFile(filestring); //将解码文件保存
deleteNode(htree2); //释放空间
break;
case 'e':
case 'E':
exit(0); //退出程序
}
}
}/**
*整理输入的字符串，求出每个字符在数组中出现的次数，作为权值
*输入：（字符型指针）字符串的地址
*返回：（哈夫曼结点指针）含权链表的首地址
*/
LinkTree setWeight(char *string)
{
int i=0; //文件字符串下标
LinkTree tree; //头指针
LinkTree ptr,beforeptr; //创建指针与其前驱
HTNode *node;

if((tree=(LinkTree)malloc(sizeof(HTNode)))==NULL)//创建链表的头结点
return NULL;
tree->next=NULL;

for(i=0;string[i]!='\0';i++)
{
ptr=tree;
beforeptr=tree;

if((node=(HTNode *)malloc(sizeof(HTNode)))==NULL)
return NULL;
node->next=NULL;
node->parent=NULL;
node->lchild=NULL;
node->rchild=NULL;
node->mark=0;
node->ch=string[i];
node->weight=1;

if(tree->next==NULL) //如果是第一个非头结点
tree->next=node;
else
{
ptr=tree->next;
while(ptr&&ptr->ch!=node->ch) //查找相同字符
{
ptr=ptr->next;
beforeptr=beforeptr->next;
}
if(ptr&&ptr->ch==node->ch) //如果链表中某结点的字符与新结点的字符相同
{
ptr->weight++; //将该结点的权加一
free(node);
}
else //将新结点插入链表后
{
node->next=beforeptr->next;
beforeptr->next=node;
}
}
}
return tree; //返回头指针
}

/**
*将整理完的字符串（带权链表）按出现次数从小到大的顺序排列
*输入：（哈夫曼结点指针）要排序的表头地址
*返回：（哈夫曼结点指针）排序后的表头地址
*/
LinkTree sortNode(LinkTree tree)
{
LinkTree head; //头指针
LinkTree ph,beforeph; //创建指针及其前驱
LinkTree pt;

if((head=(LinkTree)malloc(sizeof(HTNode)))==NULL)//创建新链表的头结点
return NULL;
head->next=NULL;

ph=head;
beforeph=head;

while(tree->next)
{
pt=tree->next; //取被*作链表的头结点
tree->next=pt->next;
pt->next=NULL;

ph=head->next;
beforeph=head;

if(head->next==NULL)
head->next=pt; //创建当前*作链表头结点
else
{
while(ph&&ph->weight<pt->weight) //将被*作结点插入相应位置
{
ph=ph->next;
beforeph=beforeph->next;
}
pt->next=beforeph->next;
beforeph->next=pt;
}
}
free(tree);
return head; //返回排序后的头指针
}

/**
*用排完序的字符串建立哈夫曼树
*输入：（哈夫曼结点指针）要建立哈夫曼树的地址
*返回：（哈夫曼结点指针）建立后的哈夫曼树地址
*/
LinkTree createHTree(LinkTree tree)
{
LinkTree p,q,beforep;
HTNode *newnode;

for(p=tree->next,q=p->next;p!=NULL&&q!=NULL;p=tree->next,q=p->next)
//p、q初值为头结点后的两个结点，即最小权结点
{
tree->next=q->next;
q->next=NULL;
p->next=NULL;

if((newnode=(HTNode *)malloc(sizeof(HTNode)))==NULL)
//申请新结点作为哈夫曼树的中间结点
return NULL;
newnode->next=NULL;
newnode->mark=0;

newnode->lchild=p; //取链表头结点后的两个结点作为新结点的左、右孩子
newnode->rchild=q;
p->parent=newnode;
q->parent=newnode;
newnode->weight=p->weight+q->weight; //权值相加

p=tree->next;
beforep=tree;

if(p!=NULL&&p->weight>=newnode->weight)
{
newnode->next=beforep->next; //将新结点插入原链表的相应位置
beforep->next=newnode;
}
else
{
while(p!=NULL&&p->weight<newnode->weight)
{
p=p->next;
beforep=beforep->next;
}
newnode->next=beforep->next;
beforep->next=newnode;
}
}
return (tree->next);
}

/**
*对哈夫曼树进行编码
*输入：（哈夫曼结点指针）要编码的哈夫曼树地址
* （编码字典类型指针）存放字典的首地址
*返回：空
*/
void codeHTree(LinkTree tree,CodeDictionary *codedictionary)
{
int index=0,k=0;
char code[MAX_SINGLECODE_LEN]; //用于统计每个字符的哈夫曼编码
LinkTree ptr=tree; //从树的根结点开始

if(ptr==NULL)
{
printf("要压缩的文件是空的!\n");
exit(0);
}
else
{
while(ptr->lchild&&ptr->rchild&&ptr->mark==0)
{
while(ptr->lchild&&ptr->lchild->mark==0)
{
code[index++]='0'; //左支路编码为0
ptr=ptr->lchild;
if(!ptr->lchild&&!ptr->rchild) //如果没有左右孩子，即叶子结点
{
ptr->mark=1; //作标记，表明该字符已被编码
code[index]='\0'; //编码0-1字符串结束
codedictionary[k].ch=ptr->ch;//给字典赋字符值
for(index=0;code[index]!='\0';index++)
codedictionary[k].code[index]=code[index];//给字典赋码值
codedictionary[k].code[index]='\0';
k++;
ptr=tree; //指针复位
index=0;
}
}
if(ptr->rchild&&ptr->rchild->mark==0)
{
ptr=ptr->rchild;
code[index++]='1'; //右支路编码为1
}
if(!ptr->lchild&&!ptr->rchild) //如果没有左右孩子，即叶子结点
{
ptr->mark=1;
code[index++]='\0';
codedictionary[k].ch=ptr->ch; //给字典赋字符值
for(index=0;code[index]!='\0';index++)
codedictionary[k].code[index]=code[index];//给字典赋码值
codedictionary[k].code[index]='\0';
k++;
ptr=tree;
index=0;
}
if(ptr->lchild->mark==1&&ptr->rchild->mark==1)//如果左右孩子都已标记
{
ptr->mark=1;
ptr=tree;
index=0;
}
}
}
printf("\n");
}

/**
*解码，即将0-1码转化为字符串
*输入：（哈夫曼结点指针）编码树的地址
* （字符型指针）要解码的0-1字符串地址
* （字符型指针）解码后的字符串地址
*返回：空
*/
void decodeHTree(LinkTree tree,char *code,char *filestring)
{
int i=0,j=0,k=0;
char *char0_1;
LinkTree ptr=tree;
char0_1=(char *)malloc(MAX_SINGLECODE_LEN); //此数组用于统计输入的0-1序列

printf("预览解压后的字符：\n");
for(j=0,ptr=tree;code[i]!='\0'&&ptr->lchild&&ptr->rchild;j=0,ptr=tree)
{
for(j=0;code[i]!='\0'&&ptr->lchild&&ptr->rchild;j++,i++)
{
if(code[i]=='0')
{
ptr=ptr->lchild;
char0_1[j]='0';
}
if(code[i]=='1')
{
ptr=ptr->rchild;
char0_1[j]='1';
}
}
if(!ptr->lchild&&!ptr->rchild)
{
printf("%c",ptr->ch); //显示解压后的字符
filestring[k++]=ptr->ch; //将字符逐一保存到字符串里
}
if(code[i]=='\0'&&ptr->lchild&&ptr->rchild)
{
char0_1[j]='\0';
printf("\n没有与最后的几个0-1序列：%s相匹配的字符!\n",char0_1);
return;
}
}
printf("\n\n");
filestring[k]='\0';
free(char0_1);
}

⑧ java 里面位操作符有哪些

java ~ 操作符，对每个二进制位的内容求反，即1变成0，0变成1
java & 操作符，对应的二内进制位进行容与操作，两个都为1才为1，其他情况均为0
java | 操作符，对应的二进制位进行或操作，两个都为0才为0，其他情况均为1
java ^ 操作符当对应二进制位值相同，该位为0 否则为1
java << 操作符，左边移动，右面填充0
java >> 操作符，左边移动，右面填充0

⑨ java，位操作

减一啊~
反向操作嘛~
参考我以前回答过的问题

阅读全文

java操作位

与java操作位相关的阅读推荐