觉得不错拿来分享一下。
package ptest;
public class JymProduce {
public String getGertWord(String paramString1, String paramString2, long paramLong,
String paramString3, String paramString4) {
llIIllIIIlIIllIl localllIIllIIIlIIllIl = new llIIllIIIlIIllIl();
return localllIIllIIIlIIllIl.getGertWord(paramString1, paramString2, paramLong,
paramString3, paramString4);
}
public static void main(String[] paramArrayOfString) {
JymProduce localJymProduce = new JymProduce();
System.out.println(localJymProduce.getGertWord("235051102210", "00002702", 1188L,
"20110224", "00"));
}
}
package ptest;
class IIIIIIIlIllIlIll
{
static final int _$21 = 7;
static final int _$20 = 12;
static final int _$19 = 17;
static final int _$18 = 22;
static final int _$17 = 5;
static final int _$16 = 9;
static final int _$15 = 14;
static final int _$14 = 20;
static final int _$13 = 4;
static final int _$12 = 11;
static final int _$11 = 16;
static final int _$10 = 23;
static final int _$9 = 6;
static final int _$8 = 10;
static final int _$7 = 15;
static final int _$6 = 21;
static final byte[] _$5 = { -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
private long[] _$4 = new long[4];
private long[] _$3 = new long[2];
private byte[] _$2 = new byte[64];
public String digestHexStr;
private byte[] _$1 = new byte[16];
public String getMD5ofStr(String paramString)
{
_$2();
_$1(paramString.getBytes(), paramString.length());
_$1();
this.digestHexStr = "";
for (int i = 0; i < 16; ++i)
this.digestHexStr += byteHEX(this._$1[i]);
return this.digestHexStr;
}
public IIIIIIIlIllIlIll()
{
_$2();
}
private void _$2()
{
this._$3[0] = 0L;
this._$3[1] = 0L;
this._$4[0] = 1732584193L;
this._$4[1] = -271733879L;
this._$4[2] = -1732584194L;
this._$4[3] = 271733878L;
}
private long _$4(long paramLong1, long paramLong2, long paramLong3)
{
return (paramLong1 & paramLong2 | (paramLong1 ^ 0xFFFFFFFF) & paramLong3);
}
private long _$3(long paramLong1, long paramLong2, long paramLong3)
{
return (paramLong1 & paramLong3 | paramLong2 & (paramLong3 ^ 0xFFFFFFFF));
}
private long _$2(long paramLong1, long paramLong2, long paramLong3)
{
return (paramLong1 ^ paramLong2 ^ paramLong3);
}
private long _$1(long paramLong1, long paramLong2, long paramLong3)
{
return (paramLong2 ^ (paramLong1 | paramLong3 ^ 0xFFFFFFFF));
}
private long _$4(long paramLong1, long paramLong2, long paramLong3, long paramLong4, long paramLong5, long paramLong6, long paramLong7)
{
paramLong1 += _$4(paramLong2, paramLong3, paramLong4) + paramLong5 + paramLong7;
paramLong1 = (int)paramLong1 << (int)paramLong6 | (int)paramLong1 >>> (int)(32L - paramLong6);
paramLong1 += paramLong2;
return paramLong1;
}
private long _$3(long paramLong1, long paramLong2, long paramLong3, long paramLong4, long paramLong5, long paramLong6, long paramLong7)
{
paramLong1 += _$3(paramLong2, paramLong3, paramLong4) + paramLong5 + paramLong7;
paramLong1 = (int)paramLong1 << (int)paramLong6 | (int)paramLong1 >>> (int)(32L - paramLong6);
paramLong1 += paramLong2;
return paramLong1;
}
private long _$2(long paramLong1, long paramLong2, long paramLong3, long paramLong4, long paramLong5, long paramLong6, long paramLong7)
{
paramLong1 += _$2(paramLong2, paramLong3, paramLong4) + paramLong5 + paramLong7;
paramLong1 = (int)paramLong1 << (int)paramLong6 | (int)paramLong1 >>> (int)(32L - paramLong6);
paramLong1 += paramLong2;
return paramLong1;
}
private long _$1(long paramLong1, long paramLong2, long paramLong3, long paramLong4, long paramLong5, long paramLong6, long paramLong7)
{
paramLong1 += _$1(paramLong2, paramLong3, paramLong4) + paramLong5 + paramLong7;
paramLong1 = (int)paramLong1 << (int)paramLong6 | (int)paramLong1 >>> (int)(32L - paramLong6);
paramLong1 += paramLong2;
return paramLong1;
}
private void _$1(byte[] paramArrayOfByte, int paramInt)
{
int i;
byte[] arrayOfByte = new byte[64];
int j = (int)(this._$3[0] >>> 3) & 0x3F;
if ((this._$3[0] += (paramInt << 3)) < paramInt << 3)
this._$3[1] += 1L;
this._$3[1] += (paramInt >>> 29);
int k = 64 - j;
if (paramInt >= k)
{
_$1(this._$2, paramArrayOfByte, j, 0, k);
_$1(this._$2);
for (i = k; i + 63 < paramInt; i += 64)
{
_$1(arrayOfByte, paramArrayOfByte, 0, i, 64);
_$1(arrayOfByte);
}
j = 0;
}
else
{
i = 0;
}
_$1(this._$2, paramArrayOfByte, j, i, paramInt - i);
}
private void _$1()
{
byte[] arrayOfByte = new byte[8];
_$1(arrayOfByte, this._$3, 8);
int i = (int)(this._$3[0] >>> 3) & 0x3F;
int j = (i < 56) ? 56 - i : 120 - i;
_$1(_$5, j);
_$1(arrayOfByte, 8);
_$1(this._$1, this._$4, 16);
}
private void _$1(byte[] paramArrayOfByte1, byte[] paramArrayOfByte2, int paramInt1, int paramInt2, int paramInt3)
{
for (int i = 0; i < paramInt3; ++i)
paramArrayOfByte1[(paramInt1 + i)] = paramArrayOfByte2[(paramInt2 + i)];
}
private void _$1(byte[] paramArrayOfByte)
{
long l1 = this._$4[0];
long l2 = this._$4[1];
long l3 = this._$4[2];
long l4 = this._$4[3];
long[] arrayOfLong = new long[16];
_$1(arrayOfLong, paramArrayOfByte, 64);
l1 = _$4(l1, l2, l3, l4, arrayOfLong[0], 7L, -680876936L);
l4 = _$4(l4, l1, l2, l3, arrayOfLong[1], 12L, -389564586L);
l3 = _$4(l3, l4, l1, l2, arrayOfLong[2], 17L, 606105819L);
l2 = _$4(l2, l3, l4, l1, arrayOfLong[3], 22L, -1044525330L);
l1 = _$4(l1, l2, l3, l4, arrayOfLong[4], 7L, -176418897L);
l4 = _$4(l4, l1, l2, l3, arrayOfLong[5], 12L, 1200080426L);
l3 = _$4(l3, l4, l1, l2, arrayOfLong[6], 17L, -1473231341L);
l2 = _$4(l2, l3, l4, l1, arrayOfLong[7], 22L, -45705983L);
l1 = _$4(l1, l2, l3, l4, arrayOfLong[8], 7L, 1770035416L);
l4 = _$4(l4, l1, l2, l3, arrayOfLong[9], 12L, -1958414417L);
l3 = _$4(l3, l4, l1, l2, arrayOfLong[10], 17L, -42063L);
l2 = _$4(l2, l3, l4, l1, arrayOfLong[11], 22L, -1990404162L);
l1 = _$4(l1, l2, l3, l4, arrayOfLong[12], 7L, 1804603682L);
l4 = _$4(l4, l1, l2, l3, arrayOfLong[13], 12L, -40341101L);
l3 = _$4(l3, l4, l1, l2, arrayOfLong[14], 17L, -1502002290L);
l2 = _$4(l2, l3, l4, l1, arrayOfLong[15], 22L, 1236535329L);
l1 = _$3(l1, l2, l3, l4, arrayOfLong[1], 5L, -165796510L);
l4 = _$3(l4, l1, l2, l3, arrayOfLong[6], 9L, -1069501632L);
l3 = _$3(l3, l4, l1, l2, arrayOfLong[11], 14L, 643717713L);
l2 = _$3(l2, l3, l4, l1, arrayOfLong[0], 20L, -373897302L);
l1 = _$3(l1, l2, l3, l4, arrayOfLong[5], 5L, -701558691L);
l4 = _$3(l4, l1, l2, l3, arrayOfLong[10], 9L, 38016083L);
l3 = _$3(l3, l4, l1, l2, arrayOfLong[15], 14L, -660478335L);
l2 = _$3(l2, l3, l4, l1, arrayOfLong[4], 20L, -405537848L);
l1 = _$3(l1, l2, l3, l4, arrayOfLong[9], 5L, 568446438L);
l4 = _$3(l4, l1, l2, l3, arrayOfLong[14], 9L, -1019803690L);
l3 = _$3(l3, l4, l1, l2, arrayOfLong[3], 14L, -187363961L);
l2 = _$3(l2, l3, l4, l1, arrayOfLong[8], 20L, 1163531501L);
l1 = _$3(l1, l2, l3, l4, arrayOfLong[13], 5L, -1444681467L);
l4 = _$3(l4, l1, l2, l3, arrayOfLong[2], 9L, -51403784L);
l3 = _$3(l3, l4, l1, l2, arrayOfLong[7], 14L, 1735328473L);
l2 = _$3(l2, l3, l4, l1, arrayOfLong[12], 20L, -1926607734L);
l1 = _$2(l1, l2, l3, l4, arrayOfLong[5], 4L, -378558L);
l4 = _$2(l4, l1, l2, l3, arrayOfLong[8], 11L, -2022574463L);
l3 = _$2(l3, l4, l1, l2, arrayOfLong[11], 16L, 1839030562L);
l2 = _$2(l2, l3, l4, l1, arrayOfLong[14], 23L, -35309556L);
l1 = _$2(l1, l2, l3, l4, arrayOfLong[1], 4L, -1530992060L);
l4 = _$2(l4, l1, l2, l3, arrayOfLong[4], 11L, 1272893353L);
l3 = _$2(l3, l4, l1, l2, arrayOfLong[7], 16L, -155497632L);
l2 = _$2(l2, l3, l4, l1, arrayOfLong[10], 23L, -1094730640L);
l1 = _$2(l1, l2, l3, l4, arrayOfLong[13], 4L, 681279174L);
l4 = _$2(l4, l1, l2, l3, arrayOfLong[0], 11L, -358537222L);
l3 = _$2(l3, l4, l1, l2, arrayOfLong[3], 16L, -722521979L);
l2 = _$2(l2, l3, l4, l1, arrayOfLong[6], 23L, 76029189L);
l1 = _$2(l1, l2, l3, l4, arrayOfLong[9], 4L, -640364487L);
l4 = _$2(l4, l1, l2, l3, arrayOfLong[12], 11L, -421815835L);
l3 = _$2(l3, l4, l1, l2, arrayOfLong[15], 16L, 530742520L);
l2 = _$2(l2, l3, l4, l1, arrayOfLong[2], 23L, -995338651L);
l1 = _$1(l1, l2, l3, l4, arrayOfLong[0], 6L, -198630844L);
l4 = _$1(l4, l1, l2, l3, arrayOfLong[7], 10L, 1126891415L);
l3 = _$1(l3, l4, l1, l2, arrayOfLong[14], 15L, -1416354905L);
l2 = _$1(l2, l3, l4, l1, arrayOfLong[5], 21L, -57434055L);
l1 = _$1(l1, l2, l3, l4, arrayOfLong[12], 6L, 1700485571L);
l4 = _$1(l4, l1, l2, l3, arrayOfLong[3], 10L, -1894986606L);
l3 = _$1(l3, l4, l1, l2, arrayOfLong[10], 15L, -1051523L);
l2 = _$1(l2, l3, l4, l1, arrayOfLong[1], 21L, -2054922799L);
l1 = _$1(l1, l2, l3, l4, arrayOfLong[8], 6L, 1873313359L);
l4 = _$1(l4, l1, l2, l3, arrayOfLong[15], 10L, -30611744L);
l3 = _$1(l3, l4, l1, l2, arrayOfLong[6], 15L, -1560198380L);
l2 = _$1(l2, l3, l4, l1, arrayOfLong[13], 21L, 1309151649L);
l1 = _$1(l1, l2, l3, l4, arrayOfLong[4], 6L, -145523070L);
l4 = _$1(l4, l1, l2, l3, arrayOfLong[11], 10L, -1120210379L);
l3 = _$1(l3, l4, l1, l2, arrayOfLong[2], 15L, 718787259L);
l2 = _$1(l2, l3, l4, l1, arrayOfLong[9], 21L, -343485551L);
this._$4[0] += l1;
this._$4[1] += l2;
this._$4[2] += l3;
this._$4[3] += l4;
}
private void _$1(byte[] paramArrayOfByte, long[] paramArrayOfLong, int paramInt)
{
int i = 0;
for (int j = 0; j < paramInt; j += 4)
{
paramArrayOfByte[j] = (byte)(int)(paramArrayOfLong[i] & 0xFF);
paramArrayOfByte[(j + 1)] = (byte)(int)(paramArrayOfLong[i] >>> 8 & 0xFF);
paramArrayOfByte[(j + 2)] = (byte)(int)(paramArrayOfLong[i] >>> 16 & 0xFF);
paramArrayOfByte[(j + 3)] = (byte)(int)(paramArrayOfLong[i] >>> 24 & 0xFF);
++i;
}
}
private void _$1(long[] paramArrayOfLong, byte[] paramArrayOfByte, int paramInt)
{
int i = 0;
for (int j = 0; j < paramInt; j += 4)
{
paramArrayOfLong[i] = (b2iu(paramArrayOfByte[j]) | b2iu(paramArrayOfByte[(j + 1)]) << 8 | b2iu(paramArrayOfByte[(j + 2)]) << 16 | b2iu(paramArrayOfByte[(j + 3)]) << 24);
++i;
}
}
public static long b2iu(byte paramByte)
{
return paramByte;
}
public static String byteHEX(byte paramByte)
{
char[] arrayOfChar1 = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
char[] arrayOfChar2 = new char[2];
arrayOfChar2[0] = arrayOfChar1[(paramByte >>> 4 & 0xF)];
arrayOfChar2[1] = arrayOfChar1[(paramByte & 0xF)];
String str = new String(arrayOfChar2);
return str;
}
public static String toMD5(String paramString)
{
IIIIIIIlIllIlIll localIIIIIIIlIllIlIll = new IIIIIIIlIllIlIll();
return localIIIIIIIlIllIlIll.getMD5ofStr(paramString).toLowerCase();
}
}
package ptest;
class llIIllIIIlIIllIl
{
public String getGertWord(String paramString1, String paramString2, long paramLong, String paramString3, String paramString4)
{
return _$1(paramString1, paramString2, paramLong, paramString3, paramString4);
}
private String _$1(String paramString1, String paramString2, long paramLong, String paramString3, String paramString4)
{
String str1 = paramString1 + paramString2 + (paramLong * 100L) + paramString3 + paramString4;
IIIIIIIlIllIlIll localIIIIIIIlIllIlIll = new IIIIIIIlIllIlIll();
str1 = localIIIIIIIlIllIlIll.getMD5ofStr(str1);
char[] arrayOfChar = str1.toCharArray();
String str2 = "";
str2 = ((_$1(arrayOfChar[0]) + _$1(arrayOfChar[4]) + _$1(arrayOfChar[8]) + _$1(arrayOfChar[12]) + _$1(arrayOfChar[16]) + _$1(arrayOfChar[20]) + _$1(arrayOfChar[24]) + _$1(arrayOfChar[28])) % 10) + "";
str2 = str2 + ((_$1(arrayOfChar[1]) + _$1(arrayOfChar[5]) + _$1(arrayOfChar[9]) + _$1(arrayOfChar[13]) + _$1(arrayOfChar[17]) + _$1(arrayOfChar[21]) + _$1(arrayOfChar[25]) + _$1(arrayOfChar[29])) % 10) + "";
str2 = str2 + ((_$1(arrayOfChar[2]) + _$1(arrayOfChar[6]) + _$1(arrayOfChar[10]) + _$1(arrayOfChar[14]) + _$1(arrayOfChar[18]) + _$1(arrayOfChar[22]) + _$1(arrayOfChar[26]) + _$1(arrayOfChar[30])) % 10) + "";
str2 = str2 + ((_$1(arrayOfChar[3]) + _$1(arrayOfChar[7]) + _$1(arrayOfChar[11]) + _$1(arrayOfChar[15]) + _$1(arrayOfChar[19]) + _$1(arrayOfChar[23]) + _$1(arrayOfChar[27]) + _$1(arrayOfChar[31])) % 10) + "";
str2 = str2 + ((_$1(arrayOfChar[0]) + _$1(arrayOfChar[2]) + _$1(arrayOfChar[6]) + _$1(arrayOfChar[14]) + _$1(arrayOfChar[30]) + _$1(arrayOfChar[1]) + _$1(arrayOfChar[3]) + _$1(arrayOfChar[7])) % 10) + "";
str2 = str2 + ((_$1(arrayOfChar[0]) + _$1(arrayOfChar[1]) + _$1(arrayOfChar[3]) + _$1(arrayOfChar[7]) + _$1(arrayOfChar[15]) + _$1(arrayOfChar[31]) + _$1(arrayOfChar[30]) + _$1(arrayOfChar[14])) % 10) + "";
str2 = str2 + ((_$1(arrayOfChar[31]) + _$1(arrayOfChar[30]) + _$1(arrayOfChar[7]) + _$1(arrayOfChar[8]) + _$1(arrayOfChar[11]) + _$1(arrayOfChar[22]) + _$1(arrayOfChar[13]) + _$1(arrayOfChar[4])) % 10) + "";
return str2;
}
private int _$1(char paramChar)
{
int i = paramChar;
if (i >= 97)
return (i % 87);
if (i >= 65)
return (i % 45);
return (i % 48);
}
}
相关推荐
本篇将深入探讨如何在Java中实现校验码的生成以及如何在Web项目中应用这些校验码。 首先，校验码的基本原理是通过特定算法对原始数据进行计算，得到一个简短的、唯一的标识，这个标识可以反映出原始数据的一些关键...
**Modbus RTU CRC-16校验码生成器 CRC_Calc v0.3详解** 在工业自动化领域，数据通信的正确性和可靠性至关重要。其中，Modbus RTU（远程终端单元）是一种广泛应用的通信协议，它依赖于错误检测机制来确保数据在传输...
一款CRC16的校验码生成工具，可以自己设置校验码生成多项式，可以对十六进制序列和文件进行校验，得出16位CRC校验码。字符串需要输入ASCii码形式，例如：AE 13 4F 78 0C 90 A0 B1，每两个中间要加空格，当校验多项式...
在Java编程语言中，我们可以自动生成LRC校验码来验证数据的正确性。 ### 1. LRC校验原理 LRC校验的基本思想是对传输或存储的数据每一位进行加法运算，最后取反得到的值即为LRC校验码。具体步骤如下： 1. 将所有...
在JAVA中，生成MD5校验码涉及到以下几个关键知识点： 1. **`java.security.MessageDigest` 类**：这是Java标准库提供的一个类，用于实现各种散列算法，包括MD5。通过`getInstance("MD5")`方法可以获得MD5的实例。 ...
【标题】基于Java开发的校验码工具是一个实用的桌面应用程序，专为计算字符串和文件的校验码而设计。该工具集成了MD5、SHA1和CRC32这三种常用的校验算法，以确保数据的完整性和一致性。 【MD5】MD5（Message-Digest...
Java实现MD5大文件校验码详细解析： 包括具体方法解释、注释 通俗易懂、易于理解
ModBus通讯,CRC校验码生成,Java版实现；ModBus,CRC,Java版实现
本项目实现的CRC16校验码生成方法包括两种：计算法和查表法。 1. **计算法**： 计算法通常基于多项式除法，具体步骤如下： - 选择一个16位的CRC生成多项式，例如X^16 + X^15 + X^2 + 1，其对应的二进制表示为...
* @return CRC-4校验码 */ public static int calculate(byte[] data) { int crc = INITIAL_VALUE; for (byte b : data) { // 逐位处理输入数据的每个字节 for (int i = 0; i ; i++) { boolean bit = ((b >>...
在Android开发中，生成带校验码的卡号是一个常见的需求，这涉及到一系列与数据处理、安全性以及性能优化相关的技术。本文将详细讲解如何在Android环境中实现这些功能，并结合提供的"ID-generator-master"压缩包文件...
在Java中实现CRC16校验功能可以帮助开发者确保数据的完整性和一致性，尤其在文件传输、网络通信或者存储系统中。CRC16的基本原理是通过一个固定长度的校验和来验证数据是否在传输或处理过程中发生了错误。 CRC16的...
它通过附加一个固定长度的校验码来验证数据的完整性，通常用于确保数据在传输或存储过程中没有发生错误。在本案例中，提供的“CRC16校验码计算工具及源代码”是一个基于VC2019开发的解决方案，能够帮助用户计算十六...
#### 四、T-SQL实现EAN-8码生成算法 题目给出的部分内容提供了一个T-SQL存储过程`dbo.EAN8`来实现EAN-8码的生成。下面我们将对该存储过程进行详细分析： ```sql create function dbo.EAN8 (@value varchar(8)) ...
MD5（Message-Digest Algorithm 5）是一种广泛使用的哈希函数，可以将任意长度的输入转化为固定长度的输出，通常用于数据校验和密码存储。然而，由于MD5的碰撞攻击弱点，直接使用MD5来存储密码已经不够安全。为了...
### 求CRC校验码的函数 #### 知识点概述 CRC（Cyclic Redundancy Check，循环冗余校验）是一种用于检测数据传输错误的校验方法，在通信领域有着广泛的应用，例如在串行通信、网络通信以及存储系统中。CRC通过计算...
为了实现这个功能，开发者可能使用了Java的图形库，如Java AWT或Swing来绘制条形码，或者利用第三方库如ZXing（Zebra Crossing）来简化条形码生成过程。 总的来说，这个项目提供了生成以69为固定开头的EAN-13条形码...
CRC通过一个预定义的多项式进行计算，生成一个固定长度的校验码，该校验码被附加到原始数据的末尾。接收端收到数据后，使用相同的多项式再次计算校验码，并与接收到的校验码进行比较，以此判断数据是否在传输过程中...
- **jFreeChart**：虽然jFreeChart主要是一个图表库，但也可以用于生成条形码，特别是Code 128和Code 39。 2. **使用ZXing生成条码** 首先，你需要在项目中引入ZXing库。然后，你可以创建一个`BitMatrix`对象，将...