Java类型转换实例

例：将字符串内容转为浮点数，再还原出原字符串内容
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;

public class test3 {
	public static void main(String[] args) {
		new test3();
	}

	/**
	 * 第一种方法
	 */
	/**
	 * 1,整数到字节数组的转换
	 *
	 * @param number
	 * @return
	 */
	public static byte[] intToByte(int number) {
		int temp = number;
		byte[] b = new byte[4];
		for (int i = b.length - 1; i > -1; i--) {
			b[i] = new Integer(temp & 0xff).byteValue(); // 将最高位保存在最低位
			temp = temp >> 8; // 向右移8位
		}
		return b;
	}

	/**
	 * 2,字节数组到整数的转换
	 *
	 * @param b
	 * @return
	 */
	public static int byteToInt(byte[] b) {
		int s = 0;
		for (int i = 0; i < 3; i++) {
			if (b[i] >= 0)
				s = s + b[i];
			else

				s = s + 256 + b[i];
			s = s * 256;
		}
		if (b[3] >= 0) // 最后一个之所以不乘，是因为可能会溢出
			s = s + b[3];
		else
			s = s + 256 + b[3];
		return s;
	}

	/**
	 * 3,字符到字节转换
	 *
	 * @param ch
	 * @return
	 */
	public static byte[] charToByte(char ch) {
		int temp = (int) ch;
		byte[] b = new byte[2];
		for (int i = b.length - 1; i > -1; i--) {
			b[i] = new Integer(temp & 0xff).byteValue(); // 将最高位保存在最低位
			temp = temp >> 8; // 向右移8位
		}
		return b;
	}

	/**
	 * 4,字节到字符转换
	 *
	 * @param b
	 * @return
	 */
	public static char byteToChar(byte[] b) {
		int s = 0;
		if (b[0] > 0)
			s += b[0];
		else
			s += 256 + b[0];
		s *= 256;
		if (b[1] > 0)
			s += b[1];
		else
			s += 256 + b[1];
		char ch = (char) s;
		return ch;
	}

	/**
	 * 5,双精度浮点到字节转换
	 *
	 * @param d
	 * @return
	 */
	public static byte[] doubleToByte(double d) {
		byte[] b = new byte[8];
		long l = Double.doubleToLongBits(d);
		for (int i = 0; i < b.length; i++) {
			b[i] = new Long(l).byteValue();
			l = l >> 8;

		}
		return b;
	}

	/**
	 * 6,字节到双精度浮点转换
	 *
	 * @param b
	 * @return
	 */
	public static double byteToDouble(byte[] b) {
		long l;

		l = b[0];
		l &= 0xff;
		l |= ((long) b[1] << 8);
		l &= 0xffff;
		l |= ((long) b[2] << 16);
		l &= 0xffffff;
		l |= ((long) b[3] << 24);
		l &= 0xffffffffl;
		l |= ((long) b[4] << 32);
		l &= 0xffffffffffl;

		l |= ((long) b[5] << 40);
		l &= 0xffffffffffffl;
		l |= ((long) b[6] << 48);

		l |= ((long) b[7] << 56);
		return Double.longBitsToDouble(l);
	}

	/**
	 * 7，单精度浮点转换为字节
	 *
	 * @param f
	 * @return
	 */
	public static byte[] float2byte(float f) {

		// 把float转换为byte[]
		int fbit = Float.floatToIntBits(f);

		byte[] b = new byte[4];
		for (int i = 0; i < 4; i++) {
			b[i] = (byte) (fbit >> (24 - i * 8));
		}

		// 翻转数组
		int len = b.length;
		// 建立一个与源数组元素类型相同的数组
		byte[] dest = new byte[len];
		// 为了防止修改源数组，将源数组拷贝一份副本
		System.arraycopy(b, 0, dest, 0, len);
		byte temp;
		// 将顺位第i个与倒数第i个交换
		for (int i = 0; i < len / 2; ++i) {
			temp = dest[i];
			dest[i] = dest[len - i - 1];
			dest[len - i - 1] = temp;
		}

		return dest;

	}

	/**
	 * ,8，字节转换为单精度浮点
	 *
	 * @param b
	 *            字节（至少4个字节）
	 * @param index
	 *            开始位置
	 * @return
	 */
	public static float byte2float(byte[] b, int index) {
		int l;
		l = b[index + 0];
		l &= 0xff;
		l |= ((long) b[index + 1] << 8);
		l &= 0xffff;
		l |= ((long) b[index + 2] << 16);
		l &= 0xffffff;
		l |= ((long) b[index + 3] << 24);
		return Float.intBitsToFloat(l);
	}

	/**
	 * 将Byte转换为String 或者将String转换为Byte
	 *
	 * @author Administrator
	 *
	 */

	/**
	 * 默认的字符集编码 UTF-8 一个汉字占三个字节
	 */
	private static String CHAR_ENCODE = "UTF-8";

	/**
	 * 设置全局的字符编码
	 *
	 * @param charEncode
	 */
	public static void configCharEncode(String charEncode) {
		CHAR_ENCODE = charEncode;
	}

	/**
	 * @param str
	 *            源字符串转换成字节数组的字符串
	 * @return
	 */
	public static byte[] StringToByte(String str) {
		return StringToByte(str, CHAR_ENCODE);
	}

	/**
	 *
	 * @param srcObj
	 *            源字节数组转换成String的字节数组
	 * @return
	 */
	public static String ByteToString(byte[] srcObj) {
		return ByteToString(srcObj, CHAR_ENCODE);
	}

	/**
	 * UTF-8 一个汉字占三个字节
	 *
	 * @param str
	 *            源字符串 转换成字节数组的字符串
	 * @return
	 */
	public static byte[] StringToByte(String str, String charEncode) {
		byte[] destObj = null;
		try {
			if (null == str || str.trim().equals("")) {
				destObj = new byte[0];
				return destObj;
			} else {
				destObj = str.getBytes(charEncode);
			}
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return destObj;
	}

	/**
	 * @param srcObj
	 *            源字节数组转换成String的字节数组
	 * @return
	 */
	public static String ByteToString(byte[] srcObj, String charEncode) {
		String destObj = null;
		try {
			destObj = new String(srcObj, charEncode);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return destObj.replaceAll("\0", " ");
	}

	/**
	 * Convert byte[] to hex string
	 *
	 * @param src
	 * @return
	 */
	public static String bytesToHexString(byte[] src) {
		StringBuilder stringBuilder = new StringBuilder("");
		if (src == null || src.length <= 0) {
			return null;
		}
		for (int i = 0; i < src.length; i++) {
			int v = src[i] & 0xFF;
			String hv = Integer.toHexString(v);
			if (hv.length() < 2) {
				stringBuilder.append(0);
			}
			stringBuilder.append(hv);
		}
		return stringBuilder.toString();
	}

	/**
	 * Convert hex string to byte[]
	 *
	 * @param hexString
	 * @return
	 */
	public static byte[] hexStringToBytes(String hexString) {
		if (hexString == null || hexString.equals("")) {
			return null;
		}
		hexString = hexString.toUpperCase();
		int length = hexString.length() / 2;
		char[] hexChars = hexString.toCharArray();
		byte[] d = new byte[length];
		for (int i = 0; i < length; i++) {
			int pos = i * 2;
			d[i] = (byte) (charToBytes(hexChars[pos]) << 4 | charToBytes(hexChars[pos + 1]));
		}
		return d;
	}

	/**
	 * Convert char to byte
	 *
	 * @param c
	 * @return
	 */
	private static byte charToBytes(char c) {
		return (byte) "0123456789ABCDEF".indexOf(c);
	}

	/**
	 * 第二种方法
	 */

	/**
	 * 1，BYTE转INT
	 *
	 * @param b
	 * @return
	 */
	protected int byteArrayToInt(byte[] b) {
		return (b[0] << 24) + ((b[1] & 0xFF) << 16) + ((b[2] & 0xFF) << 8)
				+ (b[3] & 0xFF);
	}

	/**
	 * ,2，BYTE转SHORT
	 *
	 * @param b
	 * @return
	 */
	protected int byteArrayToShort(byte[] b) {
		return (b[0] << 8) + (b[1] & 0xFF);
	}

	/**
	 * ,3，SHORT转BYTE数据
	 *
	 * @param s
	 * @return
	 */
	protected byte[] shortToByteArray(short s) {
		byte[] shortBuf = new byte[2];
		for (int i = 0; i < 2; i++) {
			int offset = (shortBuf.length - 1 - i) * 8;
			shortBuf[i] = (byte) ((s >>> offset) & 0xff);
		}
		return shortBuf;
	}

	/**
	 * ,4，INT数据转BYTE数据
	 *
	 * @param i
	 * @return
	 */
	protected byte[] intToByteArray(int i) {
		byte[] result = new byte[4];
		result[0] = (byte) ((i >> 24) & 0xFF);
		result[1] = (byte) ((i >> 16) & 0xFF);
		result[2] = (byte) ((i >> 8) & 0xFF);
		result[3] = (byte) (i & 0xFF);
		return result;
	}

	/**
	 * ,5，转换long型为byte数组
	 *
	 * @param bb
	 * @param x
	 * @param index
	 */
	public byte[] longToByteArray(long x, int index) {
		byte[] bb = new byte[8];
		bb[index + 7] = (byte) (x >> 56);
		bb[index + 6] = (byte) (x >> 48);
		bb[index + 5] = (byte) (x >> 40);
		bb[index + 4] = (byte) (x >> 32);
		bb[index + 3] = (byte) (x >> 24);
		bb[index + 2] = (byte) (x >> 16);
		bb[index + 1] = (byte) (x >> 8);
		bb[index + 0] = (byte) (x >> 0);
		return bb;
	}

	/**
	 * ,6，通过byte数组取到long
	 *
	 * @param bb
	 * @param index
	 * @return
	 */
	public long byteArrayToLong(byte[] bb, int index) {
		return ((((long) bb[index + 7] & 0xff) << 56)
				| (((long) bb[index + 6] & 0xff) << 48)
				| (((long) bb[index + 5] & 0xff) << 40)
				| (((long) bb[index + 4] & 0xff) << 32)
				| (((long) bb[index + 3] & 0xff) << 24)
				| (((long) bb[index + 2] & 0xff) << 16)
				| (((long) bb[index + 1] & 0xff) << 8) | (((long) bb[index + 0] & 0xff) << 0));
	}

	/**
	 * ,7，float转换byte
	 *
	 * @param bb
	 * @param x
	 * @param index
	 */
	public static byte[] floatTobyteArray(float v) {
		ByteBuffer bb = ByteBuffer.allocate(4);
		byte[] ret = new byte[4];
		FloatBuffer fb = bb.asFloatBuffer();
		fb.put(v);
		bb.get(ret);
		return ret;
	}

	/**
	 * ,8，通过byte数组取得float
	 *
	 * @param bb
	 * @param index
	 * @return
	 */
	public static float byteArrayToFloat(byte[] v) {
		ByteBuffer bb = ByteBuffer.wrap(v);
		FloatBuffer fb = bb.asFloatBuffer();
		return fb.get();
	}

	/**
	 * ,9，double转换byte
	 *
	 * @param bb
	 * @param x
	 * @param index
	 */
	public byte[] doubleToByteArray(double x) {
		ByteBuffer bb = ByteBuffer.allocate(8);
		byte[] ret = new byte[8];
		DoubleBuffer fb = bb.asDoubleBuffer();
		fb.put(x);
		bb.get(ret);
		return ret;
	}

	/**
	 * ,10，通过byte数组取得float
	 *
	 * @param bb
	 * @param index
	 * @return
	 */
	public double byteArrayToDouble(byte[] b) {
		ByteBuffer bb = ByteBuffer.wrap(b);
		DoubleBuffer fb = bb.asDoubleBuffer();
		return fb.get();
	}

	public test3() {
		//例：将字符串内容转为浮点数，再还原出原字符串内容
		String Content = "Contiune";
		System.out.println("例：将字符串内容转为浮点数，再还原出原字符串内容");
		// 1，字符串转为浮点
		// （1）先将字符串转为数组
		System.out.println("1，字符串转为浮点:（1）先将字符串转为数组Content="
				+ StringToByte(Content));
		// （2）再将数组转化为浮点
		System.out.println("1，字符串转为浮点:（1）再将数组转化为浮点Content="
				+ byteToDouble(StringToByte(Content)));
		// 2，浮点转成字符串
		// （1）先将浮点转为字节数组
		System.out.println("2，浮点转成字符串:（1）先将浮点转为字节数组Content="
				+ doubleToByte(byteToDouble(StringToByte(Content))));
		// （2）再将字节数组转为字符串
		System.out
				.println("2，浮点转成字符串:（2）再将字节数组转为字符串Content="
						+ ByteToString(doubleToByte(byteToDouble(StringToByte(Content)))));
	}
}

打印结果如下：

例：将字符串内容转为浮点数，再还原出原字符串内容

1，字符串转为浮点:（1）先将字符串转为数组Content=[[email protected]

1，字符串转为浮点:（1）再将数组转化为浮点Content=3.949643824749462E180

2，浮点转成字符串:（1）先将浮点转为字节数组Content=[[email protected]

2，浮点转成字符串:（2）再将字节数组转为字符串Content=Contiune，即还原出原字符串内容。

<p style="margin-top: 0px; margin-bottom: 10px; padding-top: 0px; padding-bottom: 0px; border: 0px; text-indent: 0em; background: transparent;"></p>

版权声明：本文为博主原创文章，未经博主允许不得转载。

时间： 2024-10-05 14:57:36

Java类型转换实例的相关文章

Flex Socket与Java通信实例说明（转）

Flex Socket与Java通信实例说明(转) 这两天一直在flex的Socket ,现在终于懂了很多.由浅到深一步一步深入.慢慢体会实例,虽然实例都是在网上找的,但也经过了我的测试.我比较喜欢注释,也注释了很多. 跟着走你就会懂.. Flex端 和 Java端, 先运行Java端启动服务.然后在测试Flex. 实例一: Flex端: <?xml version="1.0" encoding="utf-8"?> <mx:TitleWindow

java 类型转换

在java项目的实际开发和应用中,常常需要用到将对象转为String这一基本功能.本文将对常用的转换方法进行一个总结.常用的方法有Object.toString(),(String)要转换的对象,String.valueOf(Object)等.下面对这些方法一一进行分析.方法1:采用 Object.toString()方法请看下面的例子:      Object object = getObject();System.out.println(object.toString()); 注1在这种使用

java编程实例

脚本代码: 1. [代码] package com.gufengxiachen.sthreadchatapp;/** * @author GUXIA */import java.io.BufferedReader;import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.InputStream;import java.io.InputStreamReader;import java.io.Outpu

Java多线程-实例解析

Java多线程实例 3种实现方法Java中的多线程有三种实现方式:1.继承Thread类,重写run方法.Thread本质上也是一个实现了Runnable的实例,他代表一个线程的实例,并且启动线程的唯一方法就是通过Thread类的start方法.2.实现Runnable接口,并实现该接口的run()方法.创建一个Thread对象,用实现的Runnable接口的对象作为参数实例化Thread对象,调用此对象的start方法.3.实现Callable接口,重写call方法.Callable接口与Ru

截取指定长度字节数后的字符串（Java方法实例，注：同样思路js也适用）

可能之前是习惯了上网查看其他人的资料,当我遇到这样的问题的时候,我第一时间想到的就是上网查个现成的方法直接用:可是查阅网上各大论坛以及其他资料之后,发现大部分人都是照搬其他人的,这种情况很严重,而且个人感觉很不利于个人技术的成长:当然更重要的原因是,我感觉网上的大部分方法都把问题给复杂化了,无论是用js方法截取还是通过封装Java类,都感觉繁琐了些:为此我自己写了个相对来说较为简单的方法,其实很简单的思路和方法就能实现,下面奉上我自己的方法,希望大家多多指正不足之处(支持全角输入的字符和汉字等,

Java 注解实例

package com.annotation; import java.lang.annotation.Retention; import java.lang.annotation.Target; import static java.lang.annotation.ElementType.*; import static java.lang.annotation.RetentionPolicy.*; /** * * @author cong * 数据库连接注解 * */ @Target(val

JAVA 类型转换：隐式转换与强制转换

  这篇随笔是对java类型转换的回顾,方便忘记的时候查询,同时希望帮助有这方面需要的朋友 一. 数据类型分类: 简单数据类型:整型.实型.字符型((byte-short-char)-int-long-float-double) 二.简单类型转换 (1)低级向高级转换---自动转换:隐式转换 byte i = 0;        int a =i;        long b = i;        float c =b;        double d =c;        short j =

转 Java类型转换

原文链接:http://www.cnblogs.com/lwbqqyumidi/p/3700164.html 基本数据类型共有8种,分别是:布尔型boolean, 字符型char和数值型byte/short/int/long/float/double.由于字符型char所表示的单个字符与Ascii码中相应整形对应,因此,有时也将其划分到数值型中.引用类型具体可分为:数组.类和接口.因此,本文中Java类型转换的总结也将分为基本数据类型和引用数据类型两个方面展开. 一.基本数据类型的类型转换 基本

java webservice实例教程

原文:java webservice实例教程 源代码下载地址:http://www.zuidaima.com/share/1590350954564608.htm 最近在学习web services,网上先关的资料不多,讲的都是很基础,例子也很简单,自己动手敲了敲在这里和大家分享一下,希望能对初学者有所帮助. Web Services服务器端开发 服务器端开发用的是XFire,版本是1.2.6,XFire现在已经成apache下面的一个项目CXF的一部分了,老早就不更新版本了,XFire过不过时