解决方式：
使用 long 型的 64 位十六进制数 0xFFFFFFFFL，对取得的 32 位(4字节)的整型数值，做按位与(&)操作，
并以 long 型保存这个无符号数值，如下：
long vUnsigned = bf.getInt() & 0xFFFFFFFFL;
注：0xFFFFFFFFL 的高32位默认补0，末尾的 L 代表 long 型。
注：事实上，Java的 Integer 中已经实现此方法：
* Converts the argument to a {@code long} by an unsigned
* conversion. In an unsigned conversion to a {@code long}, the
* high-order 32 bits of the {@code long} are zero and the
* low-order 32 bits are equal to the bits of the integer
* argument.
* Consequently, zero and positive {@code int} values are mapped
* to a numerically equal {@code long} value and negative {@code
* int} values are mapped to a {@code long} value equal to the
* input plus 2
32.
* @param x the value to convert to an unsigned {@code long}
* @return the argument converted to {@code long} by an unsigned
* conversion
* @since 1.8
public static long toUnsignedLong(int x) {
return ((long) x) & 0xffffffffL;
package sparkstreaming_action.socket.main;
import java.nio.ByteBuffer;
public class UnsignedIntTest {
public static void main(String[] args) {
/** 使用 ByteBuffer 存放 64 位无符号整数的字节码
* 1. 默认实例化 HeapByteBuffer
* 2. 以 Byte[] 形式存放数据
* 3. Byte 取值范围：-128 ~ 127
* 4. 字节数组的低位索引号 对应 二进制的高位
ByteBuffer bf = ByteBuffer.allocate(64);
* 如下二进制（无符号 32 位整数值）：
* 10000000 00000100 00000010 00000001
* 代表无符号十进制整数：
* 2147746305
* 代表有符号十进制整数：
* -2147220991
* 将此十进制数按字节存入字节数组缓存中
* 1. 前 32 位置 0
* 2. 后 32 位存放数值
bf.put(0, Byte.valueOf("0")); // 00000000
bf.put(1, Byte.valueOf("0")); // 00000000
bf.put(2, Byte.valueOf("0")); // 00000000
bf.put(3, Byte.valueOf("0")); // 00000000
bf.put(4, Byte.valueOf("-128")); // 10000000
bf.put(5, Byte.valueOf("4")); // 00000100
bf.put(6, Byte.valueOf("2")); // 00000010
bf.put(7, Byte.valueOf("1")); // 00000001
/** 1. 以 Long 型读取8字节整数
* 此时读取正确，为32位的无符号整数
System.out.println("--------------------read 8 bytes, unsigned value------------------------");
long vLong = bf.getLong(0); // 从 index 0 开始读
System.out.println(vLong);
System.out.println(Long.toBinaryString(vLong));
System.out.println(Long.toBinaryString(2147746305L));
/** 2. 以 Int 型读取4字节（低位）整数
* 此时将带有符号位，读取位32位有符号整数，不是预期读到的数据
* *那么，如何只读4字节就能读到32位无符号整数呢？
System.out.println("--------------------read lower 4 bytes, signed value---------------------");
int vInt = bf.getInt(4); // 从 index 4 开始读
System.out.println(vInt);
System.out.println(Integer.toBinaryString(vInt));
System.out.println(Integer.toBinaryString(-2147220991));
/** 3. 只读4字节，并且读到32位无符号整数
* 使用 & 操作符,转成Long型,并取低32位
System.out.println("--------------------read lower 4 bytes, unsigned value---------------------");
// // 用 Int 型 0xFFFFFFFF 按位与，并不能行的通，如果不涉及符号位则可用
// long vUnsigned = bf.getInt(4) & 0xFFFFFFFF;
// 使用 Long 型 0xFFFFFFFFL，按位与，与下面的代码效果相同
// long vUnsigned = bf.getInt(4) & (long)(Math.pow(2, 32) - 1);
long vUnsigned = bf.getInt(4) & 0xFFFFFFFFL;
System.out.println(vUnsigned);
System.out.println(Long.toBinaryString(vUnsigned));
System.out.println(Long.toBinaryString(2147746305L));
System.out.println("--------------------0xFFFFFFFF and 0xFFFFFFFFL---------------------");
System.out.println("0xFFFFFFFF is 32 bits Int value: " + 0xFFFFFFFF); // -1
System.out.println("0x0FFFFFFFF is 32 bits Int value: " + 0x0FFFFFFFF); // -1
System.out.println("0xFFFFFFFFL is 64 bits Long value: " + 0xFFFFFFFFL); // 4294967295
--------------------read 8 bytes, unsigned value------------------------
2147746305
10000000000001000000001000000001
10000000000001000000001000000001
--------------------read lower 4 bytes, signed value---------------------
-2147220991
10000000000001000000001000000001
10000000000001000000001000000001
--------------------read lower 4 bytes, unsigned value---------------------
2147746305
10000000000001000000001000000001
10000000000001000000001000000001
--------------------0xFFFFFFFF and 0xFFFFFFFFL---------------------
0xFFFFFFFF is 32 bits Int value: -1
0x0FFFFFFFF is 32 bits Int value: -1
0xFFFFFFFFL is 64 bits Long value: 4294967295
场景描述： Java 中基本类型都是有符号数值，如果接收到了 C/C++ 处理的无符号数值字节流，将出现转码错误。解决方式： 使用 long 型的 64 位十六进制数 0xFFFFFFFFL，对取得的 32 位(4字节)的整型数值，做按位与(&)操作， 并以 long 型保存这个无符号数值，如下： long vUnsigned = bf.getInt() & ...
JDK1.8 API 中文谷歌翻译版 java帮助文档 JDK API java 帮助文档 谷歌翻译 JDK1.8 API 中文 谷歌翻译版 java帮助文档 Java最新帮助文档 本帮助文档是使用谷歌翻译，非人工翻译。准确性不能保证，请与英文版配合使用
文件打开空白
右键文件属性
public static void main(String[] args){
long ipLong = 0x457145130A1901F6L;
String ip = longToIp(ipLong&0xffffffff);//取低32位
System.ou...
“u”表示“unsigned”，无符号
“l”表示“long”，长整型
如果不加UL的话那就是默认的int型，UL后缀.也是一种强制转换方式.“SysTick_LOAD_RELOAD_Pos”代表“0”
“SysTick_LOAD_RELOAD_Msk”代表“(0xFFFFFFul << SysTick_LOAD_RELOAD_Pos)”
* 输入: 00000010100101000001111010011100
* 输出: 00111001011110000010100101000000
* 解释: 输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596，
* 因此返回 964176192，其二进制表示形式为 001110010111.
http://www.oschina.net/p/flowvisor
http://www.cnblogs.com/centimeter/articles/2395405.html
http://www.360doc.com/content/13/0520/21/7662927_286868466.shtml
http://zhidao.baidu.com/link?url
if (n % 2 == 0) {
// 如果是偶数个数，中位数为中间两个数的平均值
return (quickSelect(nums, 0, n - 1, n / 2) + quickSelect(nums, 0, n - 1, n / 2 - 1)) / 2.0;
} else {
// 如果是奇数个数，中位数为中间的那个数
return quickSelect(nums, 0, n - 1, n / 2);
private static int quickSelect(int[] nums, int left, int right, int k) {
if (left == right) {
return nums[left];
int pivotIndex = left + new Random().nextInt(right - left + 1);
pivotIndex = partition(nums, left, right, pivotIndex);
if (k == pivotIndex) {
return nums[k];
} else if (k < pivotIndex) {
return quickSelect(nums, left, pivotIndex - 1, k);
} else {
return quickSelect(nums, pivotIndex + 1, right, k);
private static int partition(int[] nums, int left, int right, int pivotIndex) {
int pivotValue = nums[pivotIndex];
swap(nums, pivotIndex, right);
int storeIndex = left;
for (int i = left; i <= right; i++) {
if (nums[i] < pivotValue) {
swap(nums, i, storeIndex);
storeIndex++;
swap(nums, storeIndex, right);
return storeIndex;
private static void swap(int[] nums, int i, int j) {
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
以上代码中，`findMedian` 方法用于求取数组 `nums` 的中位数。如果 `nums` 的长度是偶数，则中位数为中间两个数的平均值；如果 `nums` 的长度是奇数，则中位数为中间的那个数。
`quickSelect` 方法用于求取第 `k` 小的数。它使用快速排序的思想，在平均情况下的时间复杂度为O(n)。在这里，我们使用随机化的方法选择枢轴元素，以避免最坏情况下时间复杂度为O(n^2)。
`partition` 方法用于将数组划分为两部分，左边部分的所有元素都小于枢轴元素，右边部分的所有元素都大于枢轴元素。这里使用了双指针的方法。
`swap` 方法用于交换数组中的两个元素。
### 回答2：
使用Java编程语言实现求中位数，可以通过以下步骤:
1. 创建一个函数，用于计算中位数。该函数接受一个整数数组作为输入参数。
2. 使用Arrays类的静态方法sort()对数组进行排序，将数组元素按照升序排列。
3. 使用条件判断语句判断数组长度的奇偶性。如果数组长度是奇数，则中位数为排序后数组的中间元素；如果数组长度是偶数，则中位数为排序后数组中间两个元素的平均值。
4. 在条件判断语句中返回中位数。
以下是一个示例代码实现：
```java
import java.util.Arrays;
public class MedianCalculator {
public static double calculateMedian(int[] nums) {
Arrays.sort(nums); // 对数组进行升序排序
if (nums.length % 2 != 0) {
// 数组长度为奇数
return nums[nums.length / 2];
} else {
// 数组长度为偶数
int mid1 = nums[nums.length / 2 - 1];
int mid2 = nums[nums.length / 2];
return (double) (mid1 + mid2) / 2;
public static void main(String[] args) {
int[] nums = {1, 2, 3, 4, 5};
double median = calculateMedian(nums);
System.out.println("中位数是: " + median);
以上代码的输出结果为：中位数是: 3.0
### 回答3：
中位数是指一组数据中的中间值，即数据按照大小顺序排列后，处于中间位置的数。要用Java实现求取中位数，可以按照以下步骤进行：
1. 首先，需要将给定的一组数据按照从小到大的顺序进行排序。可以使用Java自带的排序算法，如Arrays.sort()方法。
2. 排序后，判断数据的长度。如果数据的长度为奇数，中位数即为排序后位于中间位置的数；如果数据的长度为偶数，中位数即为排序后位于中间两个数的平均值。
3. 根据数据的长度，计算得出中位数的值。可以使用数组索引的方式来获取中位数的值。
具体的Java代码实现如下：
```java
import java.util.Arrays;
public class MedianFinder {
public double findMedian(int[] nums) {
// 对数组进行排序
Arrays.sort(nums);
int n = nums.length;
// 如果数组长度为奇数，直接返回中间位置的数
if (n % 2 != 0) {
return nums[n / 2];
} else {
// 如果数组长度为偶数，返回中间两个数的平均值
return (nums[n / 2 - 1] + nums[n / 2]) / 2.0;
public static void main(String[] args) {
int[] nums = {2, 4, 1, 5, 3};
MedianFinder finder = new MedianFinder();
double median = finder.findMedian(nums);
System.out.println("中位数为：" + median);
以上代码中，定义了一个`MedianFinder`类，并在其中实现了`findMedian`方法来求取中位数。在`main`方法中，先定义一个测试数据数组`nums`，然后创建一个`MedianFinder`对象，并调用`findMedian`方法来获得中位数，并将结果打印输出。
