java中的位移运算测试

最新推荐文章于 2022-12-27 17:20:51 发布
最新推荐文章于 2022-12-27 17:20:51 发布
阅读量202 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010540913/article/details/84925997
版权

 

参考链接：https://blog.csdn.net/sxhlovehmm/article/details/44244195

                  https://blog.csdn.net/qq_35114086/article/details/70173329

 

1、左移运算 <<

丢弃最高位(符号位同样丢弃)，0补最低位

 

正数左位移：

/**
	 * 左位移测试。 丢弃最高位(符号位同样丢弃)，0补最低位 如果移动的位数超过了该类型的最大位数，那么编译器会对移动的位数取模。
	 * 如对int型移动33位，实际上只移动了33%32=1位。
	 */
	@Test
	public void test3() {
		int temp = 33;
		String as = "01000000101001010101001101100101";
		// 使用Integer.parseInt方法，将as转整型时，符号位不能为1，如果要表示负数，在as左测最高位添加“-”,而符号位右侧的数值位则表示负数的绝对值原码。
		int an = Integer.parseInt(as, 2);
		System.out.println("原值：" + an + "-->" + Integer.toBinaryString(an));
		System.out.println("<<" + temp);
		int bn = an << temp;
		System.out.println("运算后：" + bn + "-->" + Integer.toBinaryString(bn));
	}

	/**
	 * temp=1，打印结果：
	 * 原值：1084576613-->100 0000 1010 0101 0101 0011 0110 0101 
	 * <<1
	 * 运算后：-2125814070-->1000 0001 0100 1010 1010 0110 1100 1010
	 * 
	 * temp=2，打印结果：
	 * 原值：1084576613-->100 0000 1010 0101 0101 0011 0110 0101  
	 * <<2
	 * 运算后：43339156-->10 1001 0101 0100 1101 1001 0100
	 * 
	 * temp=31，打印结果：
	 * 
	 * 原值：1084576613-->100 0000 1010 0101 0101 0011 0110 0101 
	 * <<31
	 * 运算后：-2147483648-->1000 0000 0000 0000 0000 0000 0000 0000
	 * 
	 * temp=32，打印结果：
	 * 原值：1084576613-->100 0000 1010 0101 0101 0011 0110 0101
	 * <<32
	 * 运算后：1084576613-->100 0000 1010 0101 0101 0011 0110 0101
	 * 
	 * temp=33，打印结果：
	 * 原值：1084576613-->100 0000 1010 0101 0101 0011 0110 0101
	 * <<33
	 * 运算后：-2125814070-->1000 0001 0100 1010 1010 0110 1100 1010
	 * 
	 */

 特殊值的二进制表示：

/**
	 * 特殊值的二进制表示
	 */
	@Test
	public void test4() {
		System.out.println(Integer.toBinaryString(-2147483648));
		System.out.println(Math.abs(-2147483648));
		System.out.println(Integer.toBinaryString(Math.abs(-2147483648)));
		System.out.println(Integer.toBinaryString(-2147483647));
		System.out.println(Integer.toBinaryString(2147483647));
		System.out.println(Integer.toBinaryString(0));
		System.out.println(Integer.toBinaryString(-1));
	}

	/**
	 * 打印结果：
	 * 10000000000000000000000000000000
	 * -2147483648
	 * 10000000000000000000000000000000
	 * 10000000000000000000000000000001
	 * 1111111111111111111111111111111
	 * 0
	 * 11111111111111111111111111111111
	 */

 

负数左位移：

 

/**
	 * 负数左移
	 */
	@Test
	public void test6() {
		int temp = 33;
		String as = "-1000000101001010101001101100101";
		// 使用Integer.parseInt方法，将as转整型时，符号位不能为1，如果要表示负数，在as左测最高位添加“-”，数值位表示负数的绝对值。
		int an = Integer.parseInt(as, 2);
		System.out.println("原值：" + an + "-->" + Integer.toBinaryString(an));
		System.out.println("<<" + temp);
		int bn = an << temp;
		System.out.println("运算后：" + bn + "-->" + Integer.toBinaryString(bn));
	}

	/**
	 * temp=1，打印结果：
	 * 
	 * 原值：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011 
	 * <<1
	 * 运算后：2125814070-->111 1110 1011 0101 0101 1001 0011 0110
	 * 
	 * 
	 * temp=2，打印结果：
	 * 
	 * 原值：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011
	 * <<2
	 * 运算后：-43339156-->1111 1101 0110 1010 1011 0010 0110 1100
	 * 
	 * 
	 * temp=31，打印结果：
	 * 
	 * 原值：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011
	 * <<31
	 * 运算后：-2147483648-->1000 0000 0000 0000 0000 0000 0000 0000
	 * 
	 * 
	 * temp=32，打印结果：
	 * 
	 * 原值：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011
	 * <<32
	 * 运算后：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011
	 * 
	 * 
	 * temp=33，打印结果：
	 * 
	 * 原值：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011
	 * <<33
	 * 运算后：2125814070-->111 1110 1011 0101 0101 1001 0011 0110
	 * 
	 */

 

2、右移运算 >>

 

符号位不变，左边补上符号位 

 

 正数右位移：

/**
	 * 正数右位移
	 */
	@Test
	public void right1() {
		int temp = 33;
		String as = "01000000101001010101001101100101";
		int an = Integer.parseInt(as, 2);
		System.out.println("原值：" + an + "-->" + Integer.toBinaryString(an));
		System.out.println(">>" + temp);
		int bn = an >> temp;
		System.out.println("运算后：" + bn + "-->" + Integer.toBinaryString(bn));
	}
	
	/**
	 * temp=1，打印结果：
	 * 原值：1084576613-->100 0000 1010 0101 0101 0011 0110 0101
	 * >>1
	 * 运算后：542288306-->10 0000 0101 0010 1010 1001 1011 0010
	 * 
	 * temp=2，打印结果：
	 * 原值：1084576613-->100 0000 1010 0101 0101 0011 0110 0101
	 * >>2
	 * 运算后：271144153-->1 0000 0010 1001 0101 0100 1101 1001
	 * 
	 * temp=31，打印结果：
	 * 原值：1084576613-->100 0000 1010 0101 0101 0011 0110 0101
	 * >>31
	 * 运算后：0-->0
	 * 
	 * temp=32，打印结果：
	 * 原值：1084576613-->100 0000 1010 0101 0101 0011 0110 0101
	 * >>32
	 * 运算后：1084576613-->100 0000 1010 0101 0101 0011 0110 0101
	 * 
	 * temp=33，打印结果：
	 * 原值：1084576613-->100 0000 1010 0101 0101 0011 0110 0101
	 * >>33
	 * 运算后：542288306-->10 0000 0101 0010 1010 1001 1011 0010 
	 * 
	 */

 

负数右位移：

/**
	 * 负数右位移
	 */
	@Test
	public void right2() {
		int temp = 33;
		String as = "-01000000101001010101001101100101";
		int an = Integer.parseInt(as, 2);
		System.out.println("原值：" + an + "-->" + Integer.toBinaryString(an));
		System.out.println(">>" + temp);
		int bn = an >> temp;
		System.out.println("运算后：" + bn + "-->" + Integer.toBinaryString(bn));
	}
	

	/**
	 * temp=1，打印结果：
	 * 原值：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011
	 * >>1
	 * 运算后：-542288307-->1101 1111 1010 1101 0101 0110 0100 1101
	 * 
	 * temp=2，打印结果：
	 * 原值：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011
	 * >>2
	 * 运算后：-271144154-->1110 1111 1101 0110 1010 1011 0010 0110
	 * 
	 * temp=31，打印结果：
	 * 原值：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011
	 * >>31
	 * 运算后：-1-->1111 1111 1111 1111 1111 1111 1111 1111
	 * 
	 * temp=32，打印结果：
	 * 原值：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011
	 * >>32
	 * 运算后：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011
	 * 
	 * temp=33，打印结果：
	 * 原值：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011
	 * >>33
	 * 运算后：-542288307-->1101 1111 1010 1101 0101 0110 0100 1101
	 */

 

 3、无符号右移

忽略了符号位扩展，0补最高位 

 

正数右移：

 

/**
	 * 无符号右移：正数
	 */
	@Test
	public void right3() {
		int temp = 33;
		String as = "1000000101001010101001101100101";//1100 0000 1010 0101 0101 0011 0110 0101
		int an = Integer.parseInt(as, 2);
		System.out.println("原值：" + an + "-->" + Integer.toBinaryString(an));
		System.out.println(">>>" + temp);
		int bn = an >>> temp;
		System.out.println("运算后：" + bn + "-->" + Integer.toBinaryString(bn));
	}
	
	/**
	 * temp=1，打印结果： 
	 * 原值：1084576613-->100 0000 1010 0101 0101 0011 0110 0101
	 * >>>1
	 * 运算后：542288306-->10 0000 0101 0010 1010 1001 1011 0010
	 * 
	 * temp=2，打印结果： 
	 * 原值：1084576613-->100 0000 1010 0101 0101 0011 0110 0101
	 * >>>2
	 * 运算后：271144153-->1 0000 0010 1001 0101 0100 1101 1001
	 * 
	 * temp=31，打印结果： 
	 * 原值：1084576613-->100 0000 1010 0101 0101 0011 0110 0101
	 * >>>31
	 * 运算后：0-->0
	 * 
	 * temp=32，打印结果： 
	 * 原值：1084576613-->100 0000 1010 0101 0101 0011 0110 0101
	 * >>>32
	 * 运算后：1084576613-->100 0000 1010 0101 0101 0011 0110 0101
	 * 
	 * temp=32，打印结果： 
	 * 原值：1084576613-->100 0000 1010 0101 0101 0011 0110 0101
	 * >>>33
	 * 运算后：542288306-->10 0000 0101 0010 1010 1001 1011 0010
	 */

 

 

负数右移：

/**
	 * 无符号右移：负数
	 */
	@Test
	public void right3() {
		int temp = 32;
		String as = "-01000000101001010101001101100101";
		int an = Integer.parseInt(as, 2);
		System.out.println("原值：" + an + "-->" + Integer.toBinaryString(an));
		System.out.println(">>" + temp);
		int bn = an >>> temp;
		System.out.println("运算后：" + bn + "-->" + Integer.toBinaryString(bn));
	}
	
	/**
	 * temp=1，打印结果： 
	 * 原值：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011
	 * >>>1
	 * 运算后：1605195341-->101 1111 1010 1101 0101 0110 0100 1101
	 * 
	 * temp=2，打印结果： 
	 * 原值：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011
	 * >>>2
	 * 运算后：802597670-->10 1111 1101 0110 1010 1011 0010 0110
	 * 
	 * temp=31，打印结果： 
	 * 原值：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011
	 * >>>31
	 * 运算后：1-->1
	 * 
	 * temp=32，打印结果： 
	 * 原值：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011
	 * >>>32
	 * 运算后：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011
	 * 
	 * temp=33，打印结果： 
	 * 原值：-1084576613-->1011 1111 0101 1010 1010 1100 1001 1011
	 * >>>33
	 * 运算后：1605195341-->101 1111 1010 1101 0101 0110 0100 1101
	 * 
	 */

 

 最后一张总结图



 

 

 

mumu_li1005
关注
专栏目录
java位移运算 <<1_[转]java位运算（1）
weixin_29549793的博客
02-24 3014
http://blog.csdn.net/xiaochunyong/article/details/7748713Java提供的位运算符有：左移( <>) 、无符号右移(>>>) 、位与(&)、位或( |)、位非(~)、位异或(^)，除了位非( ~ )是一元操作符外，其它的都是二元操作符。1、左移( <Test1、将5左移2位：pa...
java 位运算符在实际开发中的用处_[java基础] 002 - 位运算符的详解和妙用
weixin_28523493的博客
02-16 577
本随笔参考了其他博客内容，且在验证有效之下才或誊抄或摘录或加上自己经验组合而成。参考博客：1，http://c.biancheng.net/view/784.html2，https://blog.csdn.net/minaki_/article/details/81980079------------------------------------------------------------分...
Java中的位移运算
JSON_ZJS的博客
12-19 872
位移运算符 左移 “a&lt;&lt;b”将二进制形式的a逐位左移b位，最低位空出来的b位补0。 带符号右移 “a&gt;&gt;b”将二进制形式的a逐位右移b位，最高位空出来的b位补原来的符号位。 无符号右移 “a&gt;&gt;&gt;b”将二进制形式的a逐位右移b位，最高位空出来的b位补0。 位移运算符正数实例 100 00000000 00000...
Java 中的位移运算
12-02 3085
位移运算符就是在二进制的基础上对数字进行平移。按照平移的方向和填充数字的规则分为三种：>(带符号右移)和>>>(无符号右移)。 计算规则如下： ① 左移n位相当于乘以2的n次方。 ② 右移n位相当于除以2的n次方。这里是取商哈，余数就不要了。 ③ >>>(无符号右移)    运算规则：    按二进制形式把所有的数字向右移动对应位数，低位移出(舍弃)，高位的空位补零。对于正
java 位移运算
最新发布
u013168615的专栏
12-27 5469
java 位移运算
Java 位移运算
yin__ren的博客
11-19 438
一、运算符 <<：左移运算 >>：右移运算 >>>：无符号右移运算 二、位移超过 32/64 int 类型：进行 a>>b 的位移操作时，系统会先进行 b % 32 取余操作，得到真正位移的位数 long 类型：同 int，会先进行 b % 64 的取余操作 public class TestModel { public static void main(String[] args) { long WORD_MASK =
【Java】位移技巧合集
qq_43751336的博客
12-31 211
左移一位相当于乘以2的1次方，左移n位就相当于乘以2的n次方。 5 << 1 = 10;// 左移一位相当于乘以2的1次方,即5 * 2 = 10 5 << 2 = 20;// 左移2位就相当于乘以2的2次方。即5 * 2^2 = 5 * 4 = 20 右移一位相当于除以2的1次方，右移n位就相当于除以2的n次方。 8 >> 1 = 4;// 右移一位相当于除以2的1次方,即8 / 2 = 4 8 >> 2 = 2;// 左移2位就相当于乘以2的2.
浅谈java中的移动位运算：,>>>
08-26
Java中的移动位运算是一种在计算机科学中用于处理二进制数据的基本操作，它涉及到将一个数字的二进制表示向左或向右移动指定的位数。本文将深入探讨Java中的移动位运算符：`（左移运算符）、`>>`（有符号右移运算符...
Java右移运算与除法的速度对比
自度度人 自觉觉他
02-12 2173
对比一下右移运算和除法的效率，整数除法，除以2 对除法和右移做100亿次，计算消耗的时间，为了减少误差的影响，分别做十次，最后取平均值. 结果显示，除法耗时略多点，一百亿次运算多耗时50毫秒左右 除法平均时间：3965 右移平均时间：3910 本测试纯属娱乐，结论不一定可靠。 public class Test { public static void main(String[...
c语言中一些常用的逻辑运算,C语言中的位运算和逻辑运算
weixin_42298093的博客
05-19 1597
这篇文章来自：http://blog.csdn.net/qp120291570/article/details/8708286位运算C语言中的位运算包括与(&)，或(|)，亦或(^),非(~).下面的代码包扩了这些基本运算，还有一个两个数的交换(不用第三个数)。#include#include//print a int in binaryvoid bit_print(int a){int ...
java基础----位移运算
king_yh的博客
07-02 250
左移运算只有&lt;&lt;，表示不带符号左移。它作位移处理时，会直接左移并在低位填入0，所以原本的正数可能会因此变成负数。右移运算有&gt;&gt;，表示带符号右移，它作位移处理时，会先将值向右移，并在高位填0，然后将位移后所空出的高位，全部改成原来的最高位的值（代表正负号的位）；右移运算还有&gt;&gt;&gt;，表示无符号右移，它不会将所处理的值的最高位视为正负符号，所以作位移处理时，会直...
JAVA基础知识_位移知识小白篇
琼歌
12-04 251
一、介绍 java的计算都是将数据转化成二进制数据，然后进行位移运算，如果在计算中直接运用位移计算可以提高速度，在JDK中的很多源码也是通过高效率的位移来节约时间。常见的java位移有三类、左位移、右位移、无符号位移。在这之前我们也需要了解java之间的逻辑运算。 本文介绍流程如下： 1、常见逻辑运算 2、左位移 3、右位移 4、无符号位移 5、HashMap源码分析 二、逻辑运算...
【Java】位运算练习
Bry'ce的博客
05-11 357
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。 package 位运算; import java.util.Scanner; public class TTT { /** * 输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。 */ public static int NumberOf1(int n) { int t=1; int count=0;//...
【Java】Java中的位移运算
mizepeng的博客
03-30 7986
以下分析仅针对Java语言，可以直接看最下面的结论。 一、左移（<<）：高位舍弃，低位补0，所有位一起左移，包括符号位   代码（初始为正数1，连续左移，直到为0） int n = 1; int step = 0; System.out.println(step + ":" + Integer.toBinaryString(n) + ":" + n); while (n != 0) { n = n << 1; step++; System.out.p
java中的位移_JAVA中的位移运算
weixin_30269201的博客
02-15 3571
移位运算符就是在二进制的基础上对数字进行平移。我们知道，Java中byte、short和char类型在进行计算时都是先将其转换为int类型，同样在进行移位运算时也不例外。它们移位后的结果也都会变成int类型。由于int类型为32位的(1)，所以对于byte、short、char和int进行移位时，规定实际移动的次数最多是31位，如果超过31，则按n = n % 32来计算，也就是说移位33次和移位...
JAVA 测试总结
Lynnand的博客
12-20 728
1.给定一个整数数组，判断是否存在重复元素。 如果存在一值在数组中出现至少两次，函数返回true。如果数组中每个元素都不相同，则返回false。范例 {1，2，3，4} 输出true class Solution { public boolean containsDuplicate(int[] nums) { //将数组作为形参传入 Arrays.sort(nums);//将数组升序 int n = nums.length;//将数组长度赋值变量 ...
Java的移位运算
热门推荐
mryang125的博客
11-01 1万+
前言 计算机支持两种移位运算，分别是向左移位 x << k 和向右移位x >> k，左移位会对输入的操作数舍弃最高的k位，并在右端补k个0。而右移位运算却分为两种情况，分别是逻辑右移和算术右移（也叫无符号右移和符号右移），在逻辑右移中，会对操作数舍弃最低的k位，并在左端补k个0，在算术运算中，则对操作数舍弃最低的k位，并在左端补k个最高有效位的值。 对于有符号数来说，最高位有效值是不同的，所以逻辑右移和算术右移将产生不同的效果，而C语言并没有明确定义有符号数该使用哪种类型的右移.
Java位移运算
zlz
11-16 4301
最近在补习Java基础，位移运算是今天的主角。 在此之前我们要先来复习下计算机二进制的一些概念。 在计算机硬件的世界里，芯片，处理器等所处理的电信号都为高低电平，即为10信号。 顺接上篇的一个概念来讲下：字节（byte） 1 byte = 8bit（位） 也就是一个字节相当于8位（0000 0000） 如果是两个字节那就是16位 0000 0000 0000 0000 计算机里的数也分...
JAVA基础测试与面试题解析
在Java中，2乘以8的高效运算可以使用位移运算符"，例如2，意味着将2向左移动3位，相当于2 * (1) = 2 * 8。 在多重嵌套循环中，要跳出最内层循环，可以使用"break"语句；若需跳过本次循环的剩余部分并继续下一轮循环...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值