如何将java中负数转化为无符号类型32位的，与c中执行的结果不一样，请高手指点...

最新推荐文章于 2021-04-28 14:25:58 发布
最新推荐文章于 2021-04-28 14:25:58 发布
阅读量476 收藏
点赞数
分类专栏： c++/java/python 文章标签： C C++ C# Java J#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_8110/article/details/81992867
版权
下面分别是两段java和c当中的代码，其中java代码是从c中移植过来的，执行结果不一样，导致出现的原因是：在java中不存在无符号类型32位，所以导致结果不一样，请高手指点一二，谢谢！ 

import java.math.BigDecimal;
import java.math.BigInteger;

public class SimLock {                                                                         
	private static final String SEED = "4589652157125675";                                       
	private static final int SIMLOOK_SPE_ICCID_LEN = 20;                                         
	private static final int SIMLOOK_SPE_PIC_PSW_LEN = 16;                                       

	public static int SimLookGenPicPsw(String strSrc, int nSrcLen, char[]strDec, int nDecLen)   
	{               
		int srcMinLength = 0;                                                                      
		int i = 0;                                                                                 
		int j = 0;  

		BigDecimal data1 = new BigDecimal(0);
		BigDecimal data2 = new BigDecimal(0);
		BigDecimal decData1 = new BigDecimal(0);
		BigDecimal decData2 = new BigDecimal(0);  
		char[] vTmpSrc = new char[SIMLOOK_SPE_ICCID_LEN];
		char[] vPSW = new char[SIMLOOK_SPE_PIC_PSW_LEN];

		if ( strSrc == null )                                                    
			return -1;                                                                               

		if ( 6 > nSrcLen || SIMLOOK_SPE_PIC_PSW_LEN > nDecLen )                                    
			return -1;                                                                               

		//源字符串最小长度                                                                                                                                                                    
		srcMinLength = (strSrc.length() > nSrcLen) ? nSrcLen:strSrc.length();

		//不足20位前面补0                                                                          
		if ( srcMinLength < SIMLOOK_SPE_ICCID_LEN )                                                
		{                                                                                          
			for(i = 0;i < SIMLOOK_SPE_ICCID_LEN - srcMinLength;++i )                                 
			{                                                                                        
				vTmpSrc[i] = '0';                                                                     
			}                                                                                        

			for(j = 0;j < srcMinLength;++j)                                                          
			{                                                                                        
				vTmpSrc[i++] = strSrc.charAt(j);                                                              
			}                                                                                        
		}                                                                                          
		else/*超过20位的后面丢弃*/                                                                 
		{                                                                                          
			for(j = 0;j < SIMLOOK_SPE_ICCID_LEN;++j )                                                
			{                                                                                        
				vTmpSrc[j] = strSrc.charAt(j);                                                               
			}                                                                                        
		}                                                                                                                                                                                                                                    
		i = 4;/*前4 位跳过*/                                                                       
		j = 0;                                                                                     
		while(i < SIMLOOK_SPE_ICCID_LEN)                                                           
		{     
			vPSW[j] = (char)(vTmpSrc[i]^SEED.charAt(j));                                                                                                                                    
			if ( vTmpSrc[i] > '9' || vTmpSrc[i] < '0' )                                              
			{                                                                                        
				/*把非数字字符转换成数字*/                                                             
	            vPSW[j] = (char) (vTmpSrc[i]&0x07);                                              
			} 

			 /*转换成数值前,保证最高位非0*/                                                          
	        if (vPSW[0] == '0')                                                                  
	        {        
	            vPSW[0] = '2';                                                                   
	        }                                                                                    
	        if (vPSW[(SIMLOOK_SPE_PIC_PSW_LEN/2)] == '0')                                        
	        {                       
	            vPSW[(SIMLOOK_SPE_PIC_PSW_LEN/2)] = '6';                                         
	        }

	        ++i;++j;                                                                             
		}  
		/*把16位字符串转换成两个数值*/                                                             
		i = 0;                                                                                     
		while(i<(SIMLOOK_SPE_PIC_PSW_LEN/2))                                                       
	    {                                                                                        
	        data2 = data2.multiply(new BigDecimal(10)).add(new BigDecimal(vPSW[i] - '0'));  
	        data1 = data1.multiply(new BigDecimal(10)).add(new BigDecimal(vPSW[i+(SIMLOOK_SPE_PIC_PSW_LEN/2)] - '0'));
	        i++;                                                                                 
	    }                                                                                        
		 /*对数值进行与，异或*/
	    decData1 = new BigDecimal(data1.toBigIntegerExact().and(data2.toBigIntegerExact()));
	    System.out.println(decData1);
	    decData2 = new BigDecimal(data1.toBigInteger().xor(data2.toBigInteger()));
	    i= 0;                                                                                    
	    /*再把数值转换成字符串*/
	    while(i<(SIMLOOK_SPE_PIC_PSW_LEN/2))                                                     
	    {                            
	    	srcMinLength = decData1.toBigInteger().mod(new BigInteger("10")).intValue();	
	    	strDec[i] = (char) (srcMinLength + '0');  
	        decData1 = new BigDecimal(decData1.toBigInteger().divide(new BigInteger("10")));                                                              
	    	srcMinLength = decData2.toBigInteger().mod(new BigInteger("10")).intValue();	                                              
	        strDec[i+(SIMLOOK_SPE_PIC_PSW_LEN/2)] = (char) (srcMinLength + '0');                 
	        decData2 = new BigDecimal(decData2.toBigInteger().divide(new BigInteger("10")));  
	        i++;                                                                                 
	    }
		return 1;                                                                                  

	}


}



//c代码 

#include <string.h>
#include <stdio.h>
#ifndef FALSE   /* in case these macros already exist */
#define FALSE 0  /* values of boolean */
#endif
#ifndef TRUE
#define TRUE 1
#endif

typedef signed char ascii;
typedef unsigned char           u8;
typedef unsigned long int       u32;
#define min(a, b) (a)<(b)?(a):(b)
#define SPE_SIMLOCK_TRACE printf
#define SIMLOOK_SPE_ICCID_LEN 20
#define SIMLOOK_SPE_PIC_PSW_LEN 16
static u8 SIMLOOKGenPICPSW(ascii *sSrc, u8 nSrcLen, ascii *sDec, u8 nDecLen)
{
    u8 i = 0;
    u8 l = 0;
    u8 tmp = 0;
    u8 vPSW[SIMLOOK_SPE_PIC_PSW_LEN+1] = {0};
	u8 vTmpSrc[SIMLOOK_SPE_ICCID_LEN+1] = {0};
    u32 data1 = 0, data2 = 0, decData1 = 0, decData2;
    static u8 seed[] = "4589652157125675";
    if ((!sSrc) || (!sDec)||
        (6/*最小长度为6位*/ > nSrcLen) || ((SIMLOOK_SPE_PIC_PSW_LEN+1) > nDecLen))
    {
        return -1;
    }
	tmp = strlen((const char *)sSrc);
	tmp = min(tmp, nSrcLen);
	/*不足20位前面补0*/
	if (tmp < SIMLOOK_SPE_ICCID_LEN)
	{
		for(i = 0;i<(SIMLOOK_SPE_ICCID_LEN-tmp);i++)
		{
			vTmpSrc[i] = '0';
		}
		strncpy((char*)(vTmpSrc+i), (const char*)sSrc, tmp);
	}
	else
	{
		/*超过20位的后面丢弃*/
		strncpy((char*)vTmpSrc, (const char*)sSrc, SIMLOOK_SPE_ICCID_LEN);
	}
	vTmpSrc[SIMLOOK_SPE_ICCID_LEN] = '\0';

    i = 4;/*前4 位跳过*/
    while(i<SIMLOOK_SPE_ICCID_LEN)
    {
        vPSW[l] = vTmpSrc[i]^seed[l];
        if ((vTmpSrc[i] > '9') || (vTmpSrc[i] < '0'))
        {
            /*把非数字字符转换成数字*/
            vPSW[l] = vTmpSrc[i]&0x07;
        }
        /*转换成数值前,保证最高位非0*/
        if (vPSW[0] == '0')
        {
            vPSW[0] = '2';
        }
        if (vPSW[(SIMLOOK_SPE_PIC_PSW_LEN/2)] == '0')
        {
            vPSW[(SIMLOOK_SPE_PIC_PSW_LEN/2)] = '6';
        }
        i++;l++;
    }
    SPE_SIMLOCK_TRACE("vPSW = %s\n", vPSW);
    i = 0;
    /*把16位字符串转换成两个数值*/
    while(i<(SIMLOOK_SPE_PIC_PSW_LEN/2))
    {
        data2 = data2*10+(vPSW[i] - '0');
        data1 = data1*10+(vPSW[i+(SIMLOOK_SPE_PIC_PSW_LEN/2)] - '0');
        i++;
    }
    /*对数值进行与，异或*/
    decData1 = data1&data2;
    decData2 = data1^data2;
    SPE_SIMLOCK_TRACE("data1 = %d, data2 = %d\n", data1, data2);
    SPE_SIMLOCK_TRACE("decData1 = %d, decData2 = %d\n", decData1, decData2);
    i= 0;
    /*再把数值转换成字符串*/
    while(i<(SIMLOOK_SPE_PIC_PSW_LEN/2))
    {
        tmp = (u8)(decData1%10);
        sDec[i] = tmp + '0';
        decData1 = decData1/10;

        tmp = (u8)(decData2%10);
        sDec[i+(SIMLOOK_SPE_PIC_PSW_LEN/2)] = tmp + '0';
        decData2 = decData2/10;

        i++;
    }

    sDec[SIMLOOK_SPE_PIC_PSW_LEN] = '\0';
    SPE_SIMLOCK_TRACE("----sDec = %s\n", sDec);
    return TRUE;
}

以上是两段代码，请大牛们给出意见？
iteye_8110
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
负数转化为整数
aircoder的博客
10-01 2402
负数转化为整数 int a = -1321313; 12 13 printf("1a: %d\n",a); 14 if (a < 0){ 15 16 a = -a; 17 } 18 19 20 printf("2a: %d\n",a); 整数 转化为字符 ...
java 有符号 转成无符号_java中有符号和无符号数据类型发生转换
weixin_39979489的博客
02-13 734
package com.itheima.test01;/** byte short int long float double 是有符号位的数* char boolean 是无符号位的数* 补码 反码 原码* 存储：补码* 正数的原码 反码 补码是一个** -1* 原码 1000000000...1* 补码 = 反码 + 1* 反码1111111111...0* 补码1111111111......
Java signed unsigned long 无符号数和有符号数之间的转换测试
请叫我大师兄
04-28 3436
Java 中的long类型是64位，即64个二进制位在一起来表示一个数，但是64个bit位中，最顶上1个bit是标志位，用来表示正负数的，所以，他能表示的最大的正数，就是63个1，带上最高位是0，然而其他的平台是可以把64位全部用来表示数字的。没有把最高位当作标记位来用。怎么把这个无符号的数字变成Java能表示的long呢？ @Test public void Max() { System.out.println(Long.MAX_VALUE); Syst
C语言中无符号与有符号及相加问题
08-27
在C语言中，数据类型分为有符号类型（如int、short、long等）和无符号类型（如unsigned int、unsigned short、unsigned long等）。这两种类型的数值表示方式不同，导致它们在进行运算时可能会出现一些非直观的结果，...
Java中 % 与Math.floorMod() 区别详解
08-24
"Java中 % 与Math.floorMod() 区别详解" Java中 % 与Math.floorMod() 都是取余或取模运算符，但是它们之间存在着一定的区别。 取余（Remainder） 在Java中， `%` 是一个取余运算符，它的结果的符号与被除数的符号...
1.将数组分成正数和负数2.16位无符号排序3.七段码4.产生随机数5.字程序编制
03-26
这里我们将深入探讨五个关键知识点，分别是：数组的正负数划分、16位无符号数排序、七段码表示、随机数生成以及字程序编制。 首先，我们来看数组的正负数划分。在编程中，数组是一种存储同类型数据集合的数据结构。...
【推荐】C语言中有符号数与无符号数解析[归纳].pdf
10-11
在C语言中，有符号数和无符号数是两种不同的数据类型，它们在计算机内部的表示和处理上有显著的区别。有符号数可以表示正数、零和负数，而无符号数只能表示非负整数。 1. **有符号数的表示**： 在有符号数中，通常...
C 代码 演示如何将有符号整数存储为 二进制向量，并且可以对它们执行算术.rar
05-27
在标题提到的“C代码演示如何将有符号整数存储为二进制向量，并且可以对它们执行算术”中，我们看到一个实用程序，它允许程序员以二进制向量的形式操作整数。这种技术对于理解计算机内部如何处理数据，以及在某些...
负数强制转换为无符号数时计算出错
weixin_42119324的博客
03-17 4828
unsigned u = 10; int i = -42; cout &amp;lt;&amp;lt; u + i &amp;lt;&amp;lt; endl; 执行“u+i”时，计算机将负数i强制转换为无符号数。负数在计算机中存储的是补码（当然正数也是） int 占4字节32位的情况下： -42原码：0 000 0000 0000 0000 0000 0000 0010 1010 反码：1 111 1111 1111 ...
c++ double相加 结果确定吗_写Java代码时你注意到了这十个细节吗？
weixin_36482670的博客
12-29 314
点击上方"Java学习之道"，选择"关注"公众号优秀文章，第一时间收到！注：本文来自粉丝[菜鸟逆袭]投稿1.奇数性看下面代码时候是否能判断参数 i 是奇数?publicstaticbooleanisOdd(inti){ returni%2==1;}答案是: No!看似正确的判断奇数, 但是如果 i 是负数, 那么它返回值都是false造成这种现象的是 => ...
无符号整型赋值陷阱
热门推荐
Mike的专栏
04-22 1万+
有没有人尝试过将负数赋给一个无符号整型变量？知不知道这样做会发生什么？还没有尝试的就让我们来探索下无符号整型隐藏的秘密。 先来看看下面代码： int main() {       unsigned int val = -1;       cout       retu
负数转无符号运算 （-1对256取模）
brucethl的专栏
10-22 7747
c++primer5遇到了这个-1对256取模，负数取模还真的不清楚，所以查了查资料，供大家参考。 　　原文是这样说的：C++中，把负值赋给unsigned 对象是完全合法的，其结果是初始值对无符号类型表示数值总数取模后的余数。所以，如果把-1赋给8位的unsigned char，那么结果是255，因为255是-1对256求模后的值。 　　1.从数学角度解读： 　　取模运算时,对于负数,应该...
Java中32位无符号数的取法
碣石观海的博客
08-05 5704
场景描述： Java 中基本类型都是有符号数值，如果接收到了 C/C++ 处理的无符号数值字节流，将出现转码错误。 解决方式： 使用 long 型的 64 位十六进制数 0xFFFFFFFFL，对取得的 32 位(4字节)的整型数值，做按位与(&)操作， 并以 long 型保存这个无符号数值，如下： long vUnsigned = bf.getInt() & ...
java读取u32_Java U32類代碼示例
weixin_30979383的博客
02-27 241
import org.openflow.util.U32; //導入依賴的package包/類protected void updateActiveSwitchInfo(IOFSwitch sw) {if (role == Role.SLAVE) {return;}// Obtain the row info for the switchMap switchInfo = new HashMap()...
将10进制负数转化为32位二进制补码形式（表示出int类型负数在计算机中的存储形式）
CYL641的博客
03-07 2858
我们知道，int 类型的数为有符号数，在计算机中占据4个字节（以32位2进制的形式存储）。 下面这段代码将负数转化为它在计算机中的存储形式，操作平台为VS。 注意：用int类型的负数是有范围的，int类型能表示的负数为：-2^31~1 但是在这段代码中，为了扩大范围，我们直接输入该负数的绝对值，将它声明为unsigned int（无符号整型）变量，扩宽了能表示的正数范围。 用32位2进制输出，即负...
c语言无符号整型 一直累加 溢出_C语言中数据进行类型转换时需要注意的那些问题...
最新发布
05-31
对于无符号整型，在累加操作时可能会发生溢出，这是因为无符号整型的取值范围是0~2^n-1，当超出这个范围时就会发生溢出。比如，当一个32位的无符号整型已经累加到了2^32-1，再执行加1操作时，它会变为0而不是2^32，这就是溢出。 在进行类型转换时，需要注意以下几点： 1. 低精度类型向高精度类型转换时不会丢失精度，但高精度类型向低精度类型转换时可能会丢失精度。 2. 在进行带符号类型和无符号类型之间的转换时，需要注意符号位的影响。如果将一个负数转换为无符号类型，它的符号位会被当做数值位处理，因此得到的结果会非常大。 3. 在进行浮点类型和整型之间的转换时，需要注意精度的损失。因为浮点类型的精度比整型高，将浮点数转换为整型时可能会损失精度。 在进行类型转换时，应该尽量避免数据精度的损失和溢出的情况，以保证程序的正确性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值