「java处理bit」java处理并发请求

博主：adminadmin 2022-11-27 23:23:10 55

本篇文章给大家谈谈java处理bit，以及java处理并发请求对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

java,一道关于bit操作的题

楼上匿名仁兄最大的错误就是，前提并不知道应该把第几位的1变成0。

最后的算法应该是这种：

public int[] changeBit(int input); // 仅输入操作数即得到结果

算法：

用按位与操作

public class ChangeBit {

private static int[] ints = new int[13];

/**

* 初始化

*/

public ChangeBit() {

// initInts[0] = Integer.parseInt("1111111111110", 2);

// initInts[1] = Integer.parseInt("1111111111101", 2);

// initInts[2] = Integer.parseInt("1111111111011", 2);

// initInts[3] = Integer.parseInt("1111111110111", 2);

// initInts[5] = Integer.parseInt("1111111011111", 2);

// ......

// 下面的循环代替以上，实现了初始化，但以上看起来直观些

char[] full = {'1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1'};

for (int i = 0; i 13; i++) {

char[] temp = full.clone();

temp[i] = '0';

ints[i] = Integer.parseInt(String.valueOf(temp), 2);

}

}

/**

* 主方法

*/

public static void main(String[] args) {

new ChangeBit().doBit(13); // 输入

}

/**

* 算法

*/

public static void doBit(int input) {

for (int i = 0; i 13; i++) {

int result = input ints[i]; // 关键

if (result != input) {

System.out.println(result); // 输出

}

}

}

}

如果存在效率问题，会是初始化部分，因为涉及字符数组和字符串操作。

一旦new一次后，连续使用n次doBit方法（比特位操作），几乎就不存在效率问题了。

是acm上的题吗？time out?

java 16进制字符串转为二进制bit数组？

应该用byte型数组

public static String stringToHexString(String strPart) {

String hexString = "";

for (int i = 0; i strPart.length(); i++) {

int ch = (int) strPart.charAt(i);

String strHex = Integer.toHexString(ch);

hexString = hexString + strHex;

}

return hexString;

}

private static String hexString="0123456789ABCDEF";

/*

* 将字符串编码成16进制数字,适用于所有字符（包括中文）

*/

public static String encode(String str)

{

// 根据默认编码获取字节数组

byte[] bytes=str.getBytes();

StringBuilder sb=new StringBuilder(bytes.length*2);

// 将字节数组中每个字节拆解成2位16进制整数

for(int i=0;ibytes.length;i++)

{

sb.append(hexString.charAt((bytes[i]0xf0)4));

sb.append(hexString.charAt((bytes[i]0x0f)0));

}

return sb.toString();

}

/*

* 将16进制数字解码成字符串,适用于所有字符（包括中文）

*/

public static String decode(String bytes)

{

ByteArrayOutputStream baos=new ByteArrayOutputStream(bytes.length()/2);

// 将每2位16进制整数组装成一个字节

for(int i=0;ibytes.length();i+=2)

baos.write((hexString.indexOf(bytes.charAt(i))4 |hexString.indexOf(bytes.charAt(i+1))));

return new String(baos.toByteArray());

}

private static byte uniteBytes(byte src0, byte src1) {

byte _b0 = Byte.decode("0x" + new String(new byte[] {src0})).byteValue();

_b0 = (byte) (_b0 4);

byte _b1 = Byte.decode("0x" + new String(new byte[] {src1})).byteValue();

byte ret = (byte) (_b0 | _b1);

return ret;

public static byte[] HexString2Bytes(String src)

{

byte[] ret = new byte[6];

byte[] tmp = src.getBytes();

for(int i=0; i6; ++i )

{

ret[i] = uniteBytes(tmp[i*2], tmp[i*2+1]);

}

return ret;

}

Java能否将字节流转换为bit流：

解析一下

10101000

10100111

----------------

10100000

//将最后一个1消去

所以执行多少次就是多少个1

JAVA位运算符

位操作符（bitwise operator）

位操作符允许我们操作一个基本数据类型中的整数型值的单个“比特（bit）”，即二进制位。

位操作符会对两个参数对应的位执行布尔代数运算，并最终生成一个结果。

位操作符来源于 C 语言面向底层的操作，那时我们经常需要直接操纵硬件，设置硬件寄存

器内的二进制位。Java的设计初衷是嵌入电视机顶盒内，所以这种低级操作仍被保留了下来。

但是，我们可能不会过多地使用到位运算符。

如果两个输入位都是 1，则按位“与”操作符（）生成一个输出位 1；否则生成一个输出

位0。如果两个输入位里只要有一个是1，则按位“或”操作符（|）生成一个输出位1；只

有在两个输入位都是0的情况下，它才会生成一个输出位0。如果两个输入位的某一个是1，

但不全都是1，那么“异或”操作（^）生成一个输出位1。按位“非”（~ ，也称为取补运

算，ones compliement operator ）属于一元操作符；它只对一个操作数进行操作（其他位操

作是二元运算）。按位“非”生成与输入位相反的值——若输入0，则输出1；输入1，则输

出0。

位操作符和逻辑操作符都使用了同样的符号。因此，我们能方便地记住它们的含义：由于“位”

是非常“小”的，所以位操作符仅使用了一位符号。

位操作符可与等号（=）联合使用，以便合并运算操作和赋值操作：=，|=和^=都是合法

的（由于~是一元操作符，所以不可与=联合使用）。

我们将布尔类型（boolean）作为一种“单比特”值对待，所以它多少有些独特的地方。我们

可对它执行按位“与”、“或”和“异或”运算，但不能执行按位“非”（大概是为了避免与

逻辑 NOT 混淆）。对于布尔值，位操作符具有与逻辑操作符相同的效果，只是它们不会中

途“短路”。此外，针对布尔值进行的按位运算为我们新增了一个“异或”逻辑操作符，它并

未包括在“逻辑”操作符的列表中。在移位表达式中，我们被禁止使用布尔运算，原因将在下

面解释。

移位操作符（shift operator）

移位操作符操作的运算对象也是二进制的“位”，但是它们只可以被用来处理整数类型（基本

类型的一种）。左移位操作符（）能将操作符左边的运算对象向左移动操作符右侧指定的

位数（在低位补 0）。“有符号”右移位操作符（）则将操作符左边的运算对象向右移动操

作符右侧指定的位数。“有符号”右移位操作符使用了“符号扩展”：若符号为正，则在高位插

入0；若符号为负，则在高位插入1。Java中增加了一种“无符号”右移位操作符（），它

使用了“零扩展”：无论正负，都在高位插入0。这一操作符是C或C++没有的。

如果对char、byte或者short类型的数值进行移位处理，那么在移位进行之前，它们会自动

转换为int，并且得到的结果也是一个int类型的值。而右侧操作数，作为真正移位的位数，

只有其二进制表示中的低5位才有用。这样可防止我们移位超过int型值所具有的位数。（译

注：因为2的5次方为32，而int型值只有32位）。若对一个long类型的数值进行处理，

最后得到的结果也是long。此时只会用到右侧操作数的低6位，以防止移位超过long型数

值具有的位数。

移位可与等号（=或=或=）组合使用。此时，操作符左边的值会移动由右边的值指

定的位数，再将得到的结果赋回左边的变量。但在进行“无符号”右移结合赋值操作时，可能

会遇到一个问题：如果对byte或short值进行这样的移位运算，得到的可能不是正确的结果。

它们会先被转换成int类型，再进行右移操作。然后被截断，赋值给原来的类型，在这种情

况下可能得到-1的结果。下面这个例子演示了这种情况：

//: c03:URShift.java

// Test of unsigned right shift.

import com.bruceeckel.simpletest.*;

public class URShift {

static Test monitor = new Test();

public static void main(String[] args) {

int i = -1;

System.out.println(i = 10);

long l = -1;

System.out.println(l = 10);

short s = -1;

System.out.println(s = 10);

byte b = -1;

System.out.println(b = 10);

b = -1;

System.out.println(b10);

monitor.expect(new String[] {

"4194303",

"18014398509481983",

"-1",

"-1",

"4194303"

});

}

} ///:~

在最后一个移位运算中，结果没有赋回给b，而是直接打印出来，所以其结果是正确的。

下面这个例子向大家阐示了如何应用涉及“按位”操作的所有操作符：

//: c03:BitManipulation.java

// Using the bitwise operators.

import com.bruceeckel.simpletest.*;

import java.util.*;

public class BitManipulation {

static Test monitor = new Test();

public static void main(String[] args) {

Random rand = new Random();

int i = rand.nextInt();

int j = rand.nextInt();

printBinaryInt("-1", -1);

printBinaryInt("+1", +1);

int maxpos = 2147483647;

printBinaryInt("maxpos", maxpos);

int maxneg = -2147483648;

printBinaryInt("maxneg", maxneg);

printBinaryInt("i", i);

printBinaryInt("~i", ~i);

printBinaryInt("-i", -i);

printBinaryInt("j", j);

printBinaryInt("i j", i j);

printBinaryInt("i | j", i | j);

printBinaryInt("i ^ j", i ^ j);

printBinaryInt("i 5", i 5);

printBinaryInt("i 5", i 5);

printBinaryInt("(~i) 5", (~i) 5);

printBinaryInt("i 5", i 5);

printBinaryInt("(~i) 5", (~i) 5);

long l = rand.nextLong();

long m = rand.nextLong();

printBinaryLong("-1L", -1L);

printBinaryLong("+1L", +1L);

long ll = 9223372036854775807L;

printBinaryLong("maxpos", ll);

long lln = -9223372036854775808L;

printBinaryLong("maxneg", lln);

printBinaryLong("l", l);

printBinaryLong("~l", ~l);

printBinaryLong("-l", -l);

printBinaryLong("m", m);

printBinaryLong("l m", l m);

printBinaryLong("l | m", l | m);

printBinaryLong("l ^ m", l ^ m);

printBinaryLong("l 5", l 5);

printBinaryLong("l 5", l 5);

printBinaryLong("(~l) 5", (~l) 5);

printBinaryLong("l 5", l 5);

printBinaryLong("(~l) 5", (~l) 5);

monitor.expect("BitManipulation.out");

}

static void printBinaryInt(String s, int i) {

System.out.println(

s + ", int: " + i + ", binary: ");

System.out.print(" ");

for(int j = 31; j = 0; j--)

if(((1 j) i) != 0)

System.out.print("1");

else

System.out.print("0");

System.out.println();

}

static void printBinaryLong(String s, long l) {

System.out.println(

s + ", long: " + l + ", binary: ");

System.out.print(" ");

for(int i = 63; i = 0; i--)

if(((1L i) l) != 0)

System.out.print("1");

else

System.out.print("0");

System.out.println();

}

} ///:~

程序末尾调用了两个方法：printBinaryInt()和printBinaryLong()。它们分别接受

一个 int 或 long 值的参数，并用二进制格式输出，同时附有简要的说明文字。你可以暂

时忽略它们具体是如何实现的。

请注意这里是用 System.out.print()，而不是 System.out.println()。print()方法不自动换行，所

以我们能在同一行里输出多个信息。

上面的例子中，expect() 以一个文件名作参数，它会从这个文件中读取预期的行（其中

可以有，也可以没有正则表达式）。对于那些太长，不适宜列在书里的输出，这种做法很有

用。这个文件的扩展名是“.out”，是所发布的代码的一部分，可以从下

载。如果有兴趣的话，可以打开这个文件，看看正确的输出应该是什么（或者你自己直接运

行一下前面这个程序）。

上面的例子展示了对int和long的所有按位运算的效果，还展示了int和long的最小值、最

大值、+1和-1值，以及它们的二进制形式，以使大家了解它们在机器中的具体形式。注意，

最高位表示符号：0为正，1为负。下面列出例子中关于int部分的输出：

-1, int: -1, binary:

11111111111111111111111111111111

+1, int: 1, binary:

00000000000000000000000000000001

maxpos, int: 2147483647, binary:

01111111111111111111111111111111

maxneg, int: -2147483648, binary:

10000000000000000000000000000000

i, int: 59081716, binary:

00000011100001011000001111110100

~i, int: -59081717, binary:

11111100011110100111110000001011

-i, int: -59081716, binary:

11111100011110100111110000001100

j, int: 198850956, binary:

00001011110110100011100110001100

i j, int: 58720644, binary:

00000011100000000000000110000100

i | j, int: 199212028, binary:

00001011110111111011101111111100

i ^ j, int: 140491384, binary:

00001000010111111011101001111000

i 5, int: 1890614912, binary:

01110000101100000111111010000000

i 5, int: 1846303, binary:

00000000000111000010110000011111

(~i) 5, int: -1846304, binary:

11111111111000111101001111100000

i 5, int: 1846303, binary:

00000000000111000010110000011111

(~i) 5, int: 132371424, binary:

00000111111000111101001111100000

数字的二进制表示形式被称为“有符号的2的补码”。

JAVA基本数据类型所占字节数是多少？

在Java中一共有8种基本数据类型，其中有4种整型，2种浮点类型，1种用于表示Unicode编码的字符单元的字符类型和1种用于表示真值的boolean类型。

一个字节等于8个bit，java是跟平台无关的。

（1）整型：

其中byte、short、int、long都是表示整数的，只不过他们的取值范围不一样

byte的取值范围为-128~127，占用1个字节（-2的7次方到2的7次方-1）

short的取值范围为-32768~32767，占用2个字节（-2的15次方到2的15次方-1）

int的取值范围为（-2147483648~2147483647），占用4个字节（-2的31次方到2的31次方-1）

long的取值范围为（-9223372036854774808~9223372036854774807），占用8个字节（-2的63次方到2的63次方-1）。

可以看到byte和short的取值范围比较小，而long的取值范围太大，占用的空间多，基本上int可以满足我们的日常的计算了，而且int也是使用的最多的整型类型了。

在通常情况下，如果JAVA中出现了一个整数数字比如35，那么这个数字就是int型的，如果我们希望它是byte型的，可以在数据后加上大写的 B：35B，表示它是byte型的。

同样的35S表示short型，35L表示long型的，表示int我们可以什么都不用加，但是如果要表示long型的，就一定要在数据后面加“L”。

（2）浮点型：

float和double是表示浮点型的数据类型，他们之间的区别在于他们的精确度不同

float 3.402823e+38 ~ 1.401298e-45（e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方）占用4个字节

double 1.797693e+308~ 4.9000000e-324 占用8个字节

double型比float型存储范围更大，精度更高，所以通常的浮点型的数据在不声明的情况下都是double型的，如果要表示一个数据是float型的，可以在数据后面加上“F”。

浮点型的数据是不能完全精确的，所以有的时候在计算的时候可能会在小数点最后几位出现浮动，这是正常的。

（3）boolean型（布尔型）：

这个类型只有两个值，true和false（真和非真）

boolean t = true；

boolean f = false；

（4）char型（文本型） ：

用于存放字符的数据类型，占用2个字节，采用unicode编码，它的前128字节编码与ASCII兼容

字符的存储范围在\u0000~\uFFFF，在定义字符型的数据时候要注意加' '，比如 '1'表示字符'1'而不是数值1，

char c = ' 1 ';

我们试着输出c看看，System.out.println(c);结果就是1，而如果我们这样输出呢System.out.println(c+0);

结果却变成了49。

扩展资料

基本类型之间的转换

将一种类型的值赋值给另一种类型是很常见的。在Java中，boolean 类型与其他7中类型的数据都不能进行转换，这一点很明确。

但对于其他7种数据类型，它们之间都可以进行转换，只是可能会存在精度损失或其他一些变化。

转换分为自动转换和强制转换：

自动转换（隐式）：无需任何操作。

强制转换（显式）：需使用转换操作符（type）。

将6种数据类型按下面顺序排列一下：

double float long int short byte

如果从小转换到大，那么可以直接转换，而从大到小，或char 和其他6种数据类型转换，则必须使用强制转换。

java bit怎么调

能够只使用 1 个 bit 存储信息的就只有 boolean 型的布尔真假值类型，但是它的值就只有 true 或者 false，强制性转换成数字也就只有 0 和 1，你不可能写出其他数字的，而且这样写数字比你轻松地定义一个 int 型的数据要麻烦地多。

顺便附上一个数据类型占用存储空间大小的表格：

类型 占用 bit（位）

byte（字节） 8

short（短整型） 16

int（整型） 32

long（长整型） 64

float（单精度浮点型） 32

double（双精度浮点型） 64

char（字符） 16

boolean（布尔型） 1

另外如果你是要计算的话，所有参与计算的整数都会被转换成 int 类型，所有参与计算的小数都会被转换成 double 类型，所以真的没有必要，也没有办法一个位一个位地写数字。

java处理bit的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java处理并发请求、java处理bit的信息别忘了在本站进行查找喔。

The End

发布于：2022-11-27，除非注明，否则均为首码项目网原创文章，转载请注明出处。

标签：