long 转换为 byte后正确排序

最新推荐文章于 2024-03-26 10:39:23 发布
原创 最新推荐文章于 2024-03-26 10:39:23 发布 · 236 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

  关于 java中long类型数据转换为byte[]数组排序，不能正确排序问题，目前的解决方案为：
        long 转为 byte[] 时，对 byte[] 中的每一个byte 做一次 减去 128 的操作：如long2Orderbyte 中的实现方式；
        byte[]转为  long 时 ，需要对byte[] 中的每一位 做一次 加 128 的操作： 如orderByte2long 中的实现方式；
 
    经过测试，数据经过2次往返转换，数据值不变，且byte[]可以正确的排序。

  public static byte[] long2Orderbyte(long n)
  {
    byte[] b = new byte[8];
    b[0] = (byte) ((byte) (n >> 56) - 128);
    b[1] = (byte) ((byte) (n >> 48) - 128);
    b[2] = (byte) ((byte) (n >> 40) - 128);
    b[3] = (byte) ((byte) (n >> 32) - 128);
    b[4] = (byte) ((byte) (n >> 24) - 128);
    b[5] = (byte) ((byte) (n >> 16) - 128);
    b[6] = (byte) ((byte) (n >> 8) - 128);
    b[7] = (byte) ((byte) (n >> 0) - 128);
    return b;
  }

  public static long orderByte2long(byte[] b, int offset) throws IllegalArgumentException
  {
    if (b == null || offset < 0 || b.length < offset + 8) {
      log.warn("target or startIndex error");
      throw new IllegalArgumentException("target or startIndex error");
    }
    return ((((long) (b[offset] + 128) & 0xff) << 56) | (((long) (b[offset + 1] + 128) & 0xff) << 48) | (((long) (b[offset + 2] + 128) & 0xff) << 40)
      | (((long) (b[offset + 3] + 128) & 0xff) << 32) | (((long) (b[offset + 4] + 128) & 0xff) << 24) | (((long) (b[offset + 5] + 128) & 0xff) << 16)
      | (((long) (b[offset + 6] + 128) & 0xff) << 8) | (((long) (b[offset + 7] + 128) & 0xff) << 0));
  }

package com.younglibin;

public final class TypeConversionUtil {

	private TypeConversionUtil() {

	}

	public static int byte2int(byte[] b, int offset)
			throws IllegalArgumentException {
		if (b == null || offset < 0 || b.length < offset + 4) {
			throw new IllegalArgumentException("target or startIndex error");
		}
		return b[offset + 3] & 0xff | (b[offset + 2] & 0xff) << 8
				| (b[offset + 1] & 0xff) << 16 | (b[offset] & 0xff) << 24;
	}

	public static void int2byte(int n, byte[] b, int offset)
			throws IllegalArgumentException {
		if (b == null || offset < 0 || b.length < offset + 4) {
			throw new IllegalArgumentException("target or startIndex error");
		}
		b[offset] = (byte) (n >> 24);
		b[offset + 1] = (byte) (n >> 16);
		b[offset + 2] = (byte) (n >> 8);
		b[offset + 3] = (byte) n;
	}

	public static short byte2short(byte[] b, int offset)
			throws IllegalArgumentException {
		if (b == null || offset < 0 || b.length < offset + 2) {
			throw new IllegalArgumentException("target or startIndex error");
		}
		return (short) (((b[offset] < 0 ? b[offset] + 256 : b[offset]) << 8) + (b[offset + 1] < 0 ? b[offset + 1] + 256
				: b[offset + 1]));
	}

	public static void short2byte(short n, byte[] b, int offset)
			throws IllegalArgumentException {
		if (b == null || offset < 0 || b.length < offset + 2) {
			throw new IllegalArgumentException("target or startIndex error");
		}

		b[offset] = (byte) ((n & 0xFF00) >> 8);
		b[offset + 1] = (byte) (n & 0xFF);

	}

	public static long byte2long(byte[] b, int offset)
			throws IllegalArgumentException {
		if (b == null || offset < 0 || b.length < offset + 8) {
			throw new IllegalArgumentException("target or startIndex error");
		}
		return ((((long) b[offset] & 0xff) << 56)
				| (((long) b[offset + 1] & 0xff) << 48)
				| (((long) b[offset + 2] & 0xff) << 40)
				| (((long) b[offset + 3] & 0xff) << 32)
				| (((long) b[offset + 4] & 0xff) << 24)
				| (((long) b[offset + 5] & 0xff) << 16)
				| (((long) b[offset + 6] & 0xff) << 8) | (((long) b[offset + 7] & 0xff) << 0));
	}

	public static void long2byte(long n, byte[] b, int offset)
			throws IllegalArgumentException {
		if (b == null || offset < 0 || b.length < offset + 8) {
			throw new IllegalArgumentException("target or startIndex error");
		}
		b[offset + 0] = (byte) (n >> 56);
		b[offset + 1] = (byte) (n >> 48);
		b[offset + 2] = (byte) (n >> 40);
		b[offset + 3] = (byte) (n >> 32);
		b[offset + 4] = (byte) (n >> 24);
		b[offset + 5] = (byte) (n >> 16);
		b[offset + 6] = (byte) (n >> 8);
		b[offset + 7] = (byte) (n >> 0);
	}

	public static byte[] long2byte(long n)

	{
		byte[] b = new byte[8];
		b[0] = (byte) (n >> 56);
		b[1] = (byte) (n >> 48);
		b[2] = (byte) (n >> 40);
		b[3] = (byte) (n >> 32);
		b[4] = (byte) (n >> 24);
		b[5] = (byte) (n >> 16);
		b[6] = (byte) (n >> 8);
		b[7] = (byte) (n >> 0);
		return b;
	}

	public static byte[] long2Orderbyte(long n) {
		byte[] b = new byte[8];
		b[0] = (byte) ((byte) (n >> 56) - 128);
		b[1] = (byte) ((byte) (n >> 48) - 128);
		b[2] = (byte) ((byte) (n >> 40) - 128);
		b[3] = (byte) ((byte) (n >> 32) - 128);
		b[4] = (byte) ((byte) (n >> 24) - 128);
		b[5] = (byte) ((byte) (n >> 16) - 128);
		b[6] = (byte) ((byte) (n >> 8) - 128);
		b[7] = (byte) ((byte) (n >> 0) - 128);
		return b;
	}

	public static long orderByte2long(byte[] b, int offset)
			throws IllegalArgumentException {

		return ((((long) (b[offset] + 128) & 0xff) << 56)
				| (((long) (b[offset + 1] + 128) & 0xff) << 48)
				| (((long) (b[offset + 2] + 128) & 0xff) << 40)
				| (((long) (b[offset + 3] + 128) & 0xff) << 32)
				| (((long) (b[offset + 4] + 128) & 0xff) << 24)
				| (((long) (b[offset + 5] + 128) & 0xff) << 16)
				| (((long) (b[offset + 6] + 128) & 0xff) << 8) | (((long) (b[offset + 7] + 128) & 0xff) << 0));
	}

	public static void main(String args[]) {
		int a = 99200, b = 99199;
		System.out.println("a>b:" + (a > b));
		byte[] abyte = long2byte(a), bbyte = long2byte(b);
		System.out.println("abyte > abyte :" + compare(abyte, bbyte));
		byte[] aNewbyte = long2Orderbyte(a), bNewbyte = long2Orderbyte(b);
		System.out.println("aNewbyte > aNewbyte : "
				+ compare(aNewbyte, bNewbyte));
		System.out.println("a = " + orderByte2long(aNewbyte, 0));
		System.out.println("b = " + orderByte2long(bNewbyte, 0));
		testOrder();
	}

	public static void testOrder() {
		long b = 0;
		for (long a = 1; a < 100000; a++) {
			b = a - 1;
			byte[] aoldbyte = long2byte(a), boldbyte = long2byte(b);
			if (compare(aoldbyte, boldbyte) > 0) {

			} else if (compare(aoldbyte, boldbyte) < 0) {
				System.out.println("error" + a);
			} else {
				System.out.println("equals");
			}
		}
		System.out.println("use order --------------------------");
		for (long a = 1; a < 100000; a++) {
			b = a - 1;
			byte[] aoldbyte = long2Orderbyte(a), boldbyte = long2Orderbyte(b);
			if (compare(aoldbyte, boldbyte) > 0) {

			} else if (compare(aoldbyte, boldbyte) < 0) {
				System.out.println("error" + a);
			} else {
				System.out.println("equals");
			}

			if (a != orderByte2long(aoldbyte, 0)) {
				System.out.println("use orderByte2long error:" + a);
			}

			if (b != orderByte2long(boldbyte, 0)) {
				System.out.println("use orderByte2long error:" + b);
			}
		}
	}

	public static int compare(byte[] a, byte[] b) {
		int index = 0;
		int reFlag = 0;
		while (index < 8) {
			if (a[index] > b[index]) {
				reFlag = 1;
				break;
			} else if (a[index] < b[index]) {
				reFlag = -1;
				break;
			}
			index++;
		}
		return reFlag;
	}
}

 

PostgreSQL的学习心得和知识总结（一百五十三）|[performance]将 OR 子句转换为 ANY 表达式
孤傲小二~阿沐的博客
10-09 1624
[performance]将 OR 子句转换为 ANY 表达式
JavaSE基础复习：基本数据类型转换以及强制类型转换精度缺失原因
weixin_52008431的博客
03-23 1228
目录 数据类型转换规则 强制类型转换 不使用强制类型转化符图例 使用强制类型转化符图例 强制类型转换精度缺失 数据类型转换规则 八种基本数据类型byte short int long float doule char boolean （1）除boolean类型不能转换...
java数组排序
12-01
java Arrays.sort中文叫数组名，是指sort(byte[] a)和sort(long[] a)两种排序方法，使用这个两种方法可以对数字在指定的范围内排序。这个方法在 java.util这个包里面，所以在用到的时候需要先将它导入。
long、int转为byte[]
u010659877的专栏
10-22 2769
很多数据类型的基本数据结构都是byte[]，如何快速初始化byte[]的length位为0。 1、 一位一位的赋值 byte[] data = new byte[10000]; for (int i = 0; i < length; i++){ data[i] = (byte)0; } 2、转换为long的方式赋值 现在要解决的问题是给length位byte赋值为0，我们可以拆分一个函数，就是把long写入byte[]中，代码如下，该函数每被调用一次，就解决了8个长度的赋值问题，这个函数不光可以解
将Long类型转换成Byte字节类型数组及反转
zdingyun的专栏
09-18 8647
Option Explicit Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (Destination As Any, Source As Any, ByVal Length As Long) Dim Buffer(3) As BytePrivate Sub LngToBin_Clic
java数组——数组排序sort()
werewofe的专栏
01-03 2452
例子： //  排列数组 sort   int[] array = new int[]{1,4,6,8,3};   Arrays.sort(array);   for(int e:array){    System.out.print(e+",");   } 运行效果如下： 1,3,4,6,8, public static void sort(Object[] a) Sorts
字节数组和基本类型转换
weixin_37549458的博客
12-22 3043
基础知识 boolean 一位 byte 8位 一个字节 short char 2个字节 int float 4个字节 double long 8字节 java是unicode编码，一个char可以占两个bai字节，可以存储一du个汉字。一个String，要zhi看有几个字母或者dao几个汉字，一个英文字母就是一个字节，一个汉字就是两个字节，以此类推计算。 带符号按位左移 << 带符号右移>> 不带符号右移 >>> 1.内存中的位运算，都会先转换成int，4个字节
让 Redis zset 支持多条件排序
热门推荐
GitChat
11-01 1万+
Redis 的 zset 可以很方便的实现一个排行榜，但是只通过单纯的 score 和 key 排序并不满足一些需要多条件排序的需求。本文将会介绍一些通过计算让 zset 的 score 支持多条件排序的方法。...
es查询时间long转date_Elasticsearch 5.x 源码分析（13）探讨ES的long_range,date_range类型，可能不仅只是语法糖...
weixin_36015177的博客
01-14 1306
好久没看书了，最近闲来无事，针对ES的range查询的一些毛刺问题，想办法如何去降低(避免是避免不了了)。无意中在ES的官网看到一篇博客，光看标题肯定就觉的吊炸天了吧。话说Elasticsearch 5.2 开始就引入了integer_range,float_range, long_range,double_range和date_range，好吧，老实说，之前从来没有关心过它。直到有一天突然想到...
java int转byte和long转byte的方法
09-01
下面小编就为大家带来一篇java int转byte和long转byte的方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
java数据类型转byte数组
10-08
ip地址转4字节byte，char转2字节byte，byte数组转char，int整数转换为4字节的byte数组，byte数组转换为int整数，double类型转8字节数组，8位数组转double，long整数转换为8字节的byte数组，short整数转换为2字节的byte数组，byte数组转换为无符号short整数，byte数组转换为无符号short整数
数据排序转换
ZHI11235813的博客
06-04 607
最近在做RK平台的相关东东，RK内存的数据排序如下图（以12bit为例）：大端存储（从左向右，高地址，低字节）首先，RK平台的数据是以大端存储，使用fwrite()函数保存到计算机里，变成小端存储（高地址，高字节），即但是，我们希望保存下来的数据小端显示是高字节4位无数据，如下图所示（图越来越渣了）所以希望在保存数据前进行内存中数据排序的转换，写了一个不咋地的小程序，总算可以实现想要的功能。#in...
long类型值与bytes数组互转
博客主要分享技术教程、工具教程、bug解决、前沿技术动态、编程经验、心得感悟等。 内容同步、干货获取、推广宣发请看侧栏推广信息
07-05 4430
每个人都有惰性，但不断学习是好好生活的根本，共勉！
long型转成bytes
danielinbiti的专栏
03-25 5982
今天刚好有人问VB的Long转换成Bytes，问下面代码是什么意思 Bytes = (Number And &H7F000000) \ &H1000000 Or (((Number And &H80000000) 实际上各种语言计算位的方式都是基本一致的。要理解这些什么意思，关键得能把这些变量和16进制数要有位的概念。 1、VB中long是32位，如果就是4个字节，一个字节的二进制是8位（
long转byte java_long 与byte类型间相互转换
weixin_35417196的博客
02-20 730
package test;import java.io.UnsupportedEncodingException;import java.nio.ByteBuffer;public class Stest {public static void main(String args[]) throws UnsupportedEncodingException {// test for convertL...
long与byte互转中的错误
u014353495的专栏
03-02 817
一、long转byte[] long l = 10000L; byte[] b = new byte[8]; b = java.lang.Long.toString(l).getBytes();二、byte[]转longlong l = 0L; l = java.lang.Long.parseLong(new String(b));三、注意点在转换过程中String 类型不能有错
进制的总结
最新发布
qq_29186033的博客
03-26 1241
/long型转byte[]，高位在前，低位在后 (long 8字节)=（pc端int64默认高位在前）//int型转byte[]，高位在前，低位在后 (int 4字节)=（pc端int32默认高位在前）//int型转byte[]，低位在前，高位在后 (int 4字节)=（pc端int32默认高位在前）//字节数组转int型，高位在前，低位在后 (int 4字节)=（pc端int32默认高位在前）//字节数组转int型，低位在前，高位在后 (int 4字节)=（pc端int32默认高位在前）
go语言排序之选择排序、冒泡排序、快速排序
The_Reader的博客
12-11 459
选择排序： 即每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。 package main import "fmt" //选择排序 func main() { bytes := []byte{9, 7, 3, 5,...
Java自动类型转换详细解析及案例分析
Java中常见的数据类型按照精度从小到大排序如下：byte < short < char < int < long 。 除了数值类型之间的转换，自动类型转换还发生在以下几种情况： - 字符串转换为基本数据类型：使用包装类的静态方法parseXxx...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值