安卓中各种数据类型之间的转换

最新推荐文章于 2023-08-22 13:25:25 发布
最新推荐文章于 2023-08-22 13:25:25 发布
阅读量1k 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_33338482/article/details/70807380
版权

留着以后用，先备份起来。

public class BytesUtil 
{

    private static final char[] hex = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D','E', 'F' };
public static int bytes2Integer(byte[] data, int offset, int len) {
    // TODO Auto-generated method stub
    if((data == null) || (offset < 0) || (len <= 0) || (len + offset > data.length))
    {
        return -1;
    }

    int value = 0;
    for(int i = 0; i < len; i++)
    {
        value = value*256 + oneByte2Integer(data[i+offset]);
    }
    return value;
}

public static int ascii2Integer(byte[] data, int offset, int len) {
    // TODO Auto-generated method stub
    if((data == null) || (offset < 0) || (len <= 0) || (len + offset > data.length))
    {
        return -1;
    }

    int value = 0;
    for(int i = 0; i < len; i++)
    {
        value = value*10 + oneByte2Integer(data[i+offset])-0x30;
    }
    return value;
}

public static int oneByte2Integer(byte b) {
    // TODO Auto-generated method stub
    return b < 0 ? (b + 256) : b;
}

public static int BCDtoInteger(byte[] buffer, int offset, int len) 
{
    // TODO Auto-generated method stub
    if((buffer == null) || (offset < 0) || (len <= 0) || (buffer.length < offset+len))
    {
        return -2147483648;
    }
    int value = 0;
    for(int i = offset; i < len+offset; i++)
    {
        value = (value*10) + ((buffer[i] >>> 4) & 0x0F);
        value = (value*10) + (buffer[i] & 0x0F);            
    }
    return value;
}

//private final static byte[] hex = {0,1,2,3,4,5,6,7,8,9,0xA,0xB,0xC,0xD,0xE,0xF};//"0123456789ABCDEF".getBytes(); 

// 从字节数组到十六进制字符串转换
public static final String bytesToHexStr(byte[] data,int begin,int len,String filling) 
{
    if((data == null) || (begin < 0) || (len <= 0) || (data.length < begin + len))
    {
        return null;
    }

    StringBuffer buffer = new StringBuffer(len * 2);

    for (int i = begin; i < begin+len; i++) 
    {
        buffer.append(hex[(data[i] >>> 4) & 0x0F]);
        buffer.append(hex[data[i] & 0x0F]);
        buffer.append(filling);
    }

    return buffer.toString();
}

// 从字节数组到十六进制字符串转换
public static final String bytesToHexStr(byte[] bcd,int begin,int len) 
{
    if(bcd != null)
    {
        StringBuffer buffer = new StringBuffer(len * 2);

        for (int i = begin; i < begin+len; i++) 
        {
            buffer.append(hex[(bcd[i] >>> 4) & 0x0F]);
            buffer.append(hex[bcd[i] & 0x0F]);
        }

        return buffer.toString();
    }
    return null;
}

// 从字节数组到十六进制字符串转换
public static String bytesToHexStr(char[] bcd,int begin,int len)
{
    if(bcd != null)
    {
        StringBuffer buffer = new StringBuffer(len * 2);

        for (int i = begin; i < begin+len; i++) 
        {
            buffer.append(hex[(bcd[i] >>> 4) & 0x0F]);
            buffer.append(hex[bcd[i] & 0x0F]);
        }

        return buffer.toString();
    }
    return null;
}
public static String byteToHexStr(byte b) {   
    StringBuffer buffer = new StringBuffer(2);
    buffer.append(hex[(b >>> 4) & 0x0F]);
    buffer.append(hex[b & 0x0F]);
    return buffer.toString();   
} 
public static String byteToHexStr(char b) {   
    StringBuffer buffer = new StringBuffer(2);
    buffer.append(hex[(b >>> 4) & 0x0F]);
    buffer.append(hex[b & 0x0F]);
    return buffer.toString();    
} 
// 从十六进制字符串到字节数组转换  
public static byte[] HexStringToBytes(String hexstr) {  
    byte[] b = new byte[hexstr.length() / 2];  
    int j = 0;  
    for (int i = 0; i < b.length; i++) {  
        char c0 = hexstr.charAt(j++);  
        char c1 = hexstr.charAt(j++);  
        b[i] = (byte) ((parse(c0) << 4) | parse(c1));  
    }  
    return b;  
}  

private static int parse(char c) {  
    if (c >= 'a')  
        return (c - 'a' + 10) & 0x0f;  
    if (c >= 'A')  
        return (c - 'A' + 10) & 0x0f;  
    return (c - '0') & 0x0f;  
}  

public static String bytesToString(byte[] data,int begin,int len,String code)
{
    String str = null;
    if(data != null)
    {
        try 
        {
            if(code != null)
            {
                str = new String(data,begin,len,code);
            }
            else 
            {
                str = new String(data,begin,len);
            }
        } 
        catch (NullPointerException e) 
        {
            // TODO: handle exception
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch(IndexOutOfBoundsException e)
        {
            e.printStackTrace();
        }
    }
    return str;
}

public static String bytesToHexStr(byte[] data, int begin,
        int len, int maxLen, String filling)
{
    // TODO Auto-generated method stub
    if((data == null) || (begin < 0) || (len <= 0) || (data.length < begin + len) || (maxLen <= 0))
    {
        return null;
    }

    StringBuffer buffer = new StringBuffer(len * 2);

    for (int i = begin; i < begin+len; i++) 
    {
        buffer.append(hex[(data[i%maxLen] >>> 4) & 0x0F]);
        buffer.append(hex[data[i%maxLen] & 0x0F]);
        buffer.append(filling);
    }

    return buffer.toString();
}

//把高位是拆字的字符数组整合
public static byte[] getbytesIntegrate(byte[] data, int sta, int end) 
                 throws IllegalArgumentException
{
    // TODO Auto-generated method stub
    if((data == null) || (sta < 0) || (end < 0 ))
    {
        throw new IllegalArgumentException("error");
    }

    byte[] bytesData=new byte[(end-sta)/2];
    for(int i=0;i<bytesData.length;i++)
    {
        bytesData[i]=(byte) ((data[2*i+sta]&0x0F)*16+(data[2*i+sta+1]&0x0F));
    }
    return bytesData;
}

public static int bytesIntegrateToInteger(byte[] data, int offset, int len)
                  throws IllegalArgumentException
{
    byte[] bytesData = getbytesIntegrate(data,offset,offset + len);     
    if(bytesData != null)
    {
        return bytes2Integer(bytesData,0,bytesData.length);
    }
    return 0;
}

public static int getbytesIntegrate(byte[] out_data,int offset,byte[] data, int sta, int end,int max) 
                  throws IllegalArgumentException
{
    // TODO Auto-generated method stub
    if((data == null) || (sta < 0) || (end < 0 ) || (out_data == null) || (offset < 0))
    {
        throw new IllegalArgumentException("error");
    }

    int len = (end - sta + max) % max;
    if(len > data.length)
    {
        throw new IllegalArgumentException("error");
    }

    len = len / 2;
    if(offset + len > out_data.length)
    {
        throw new IllegalArgumentException("error");
    }


    for(int i = 0;i < len;i++)
    {
        out_data[i+offset]=(byte) ((data[(2 * i + sta) % max] & 0x0F) * 16+(data[(2 * i + sta + 1) % max] & 0x0F));
    }
    return len;
}

public static byte[] getBytesExtend(byte[] data) {
    // TODO Auto-generated method stub      
    if(data == null)
    {
        return null;
    }
    byte[] bytesData=new byte[data.length*2];
    int len = getBytesExtend(bytesData,0,data,0,data.length);
    if(len >= 0)
    {
        return bytesData;
    }
    else
    {
        return null;
    }
}

public static int getBytesExtend(byte[] out_data,int offset,byte[] data) {
    // TODO Auto-generated method stub
    if((out_data == null) || (data == null))
    {
        return -1;
    }
    if((offset < 0) || (offset >= out_data.length))
    {
        return -1;
    }
    if(out_data.length < offset+data.length*2)
    {
        return -1;
    }
    for(int i=0;i<data.length;i++)
    {
        out_data[2*i+offset]=(byte) (((oneByte2Integer(data[i]) >>> 4) & 0x0F)+0x30);
        out_data[2*i+1+offset]=(byte) ((oneByte2Integer(data[i]) & 0x0F)+0x30);
    }
    return data.length*2;
}

public static byte getHExtend(byte b) {
    // TODO Auto-generated method stub
    return (byte) (((b >>> 4) & 0x0F) + 0x30);
}

public static byte getLExtend(byte b) {
    // TODO Auto-generated method stub
    return (byte) ((b & 0x0F) + 0x30);
}

public static int getBytesExtend(byte[] out_data, int out_data_offset, byte[] data,
        int offset, int len)
{
    // TODO Auto-generated method stub
    if((data == null) || (out_data == null) || (out_data_offset < 0) || (offset < 0) ||
            (out_data.length < out_data_offset + 2 * len) || (data.length < offset + len))
    {
        return -1;
    }

    for(int i = 0;i < len;i++)
    {
        out_data[2*i + out_data_offset]=(byte) (((oneByte2Integer(data[i + offset]) >>> 4) & 0x0F)+0x30);
        out_data[2*i + 1 + out_data_offset]=(byte) ((oneByte2Integer(data[i + offset]) & 0x0F)+0x30);
    }
    return 2 * len;
}


public static String bytesToHexStr(byte[] data)
{
    // TODO Auto-generated method stub
    if(data != null)
    {
        return bytesToHexStr(data,0,data.length);
    }
    return null;
}

public static void setBytes(byte charType,byte[]dataBuf)
{
    // TODO Auto-generated method stub
    if(dataBuf!=null)
    {
        int i=0;
        for(i=0;i<dataBuf.length;i++)
            dataBuf[i]=charType;
    }

}
// 十六进制转换字符串 
public static String hexStr2Str(String hexStr)  
{    
    String str = "0123456789ABCDEF";    
    char[] hexs = hexStr.toCharArray();    
    byte[] bytes = new byte[hexStr.length() / 2];    
    int n;    

    for (int i = 0; i < bytes.length; i++)  
    {    
        n = str.indexOf(hexs[2 * i]) * 16;    
        n += str.indexOf(hexs[2 * i + 1]);    
        bytes[i] = (byte) (n & 0xff);    
    }    
    return new String(bytes);    
}}
九九999
关注
android中各种数据类型之间转换
zhwadezh的博客
02-09 9004
字符串String转换成整数int1).inti=Integer.parseInt([String]);或i=Integer.parseInt([String],[intradix]);2).inti=Integer.valueOf(my_str).intValue();注:字串转成Double,Float,Long的方法大同小异.整数int转换成字符串...
Android数据类型之间相互转换系统介绍
01-20
一些初学Android的朋友可能会遇到JAVA的数据类型之间转换的苦恼，例如，整数和float,double型之间的转换，整数和String类型之间的转换，以及处理、显示时间方面的问题等。下面笔者就开发中的一些体会介绍给大家。 我们知道，android的数据类型分为三大类，即布尔型、字符型和数值型，而其中数值型又分为整型和浮点型；相对于数据类型，Java的变量类型为布尔型 boolean；字符型char；整型byte、short、int、long；浮点型float、double。其中四种整型变量和两种浮点型变量分别对应于不同的精度和范围。此外，我们还经常用到两种类变量，即String和Date
android 数据类型转换大全
a22422931的博客
10-11 1931
import android.text.TextUtils; import android.util.Log; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.In
android数据类型转换工具类
qingsongfoxconn123的专栏
10-26 1352
string与基础类型之间转换工具类
android类型转换
快乐的小鸟
01-30 8883
Android中类型转换好像支持不是太好，备份下有用的类型转换函数和工具函数. 一、类型转换 1.byte 转 int  ( int 可以再转成long double float ） 1.public static int byteToInt(byte[] data, int offset)  2.{  3.        int result = 0;  4.    int n1
android图片类型之间相互转换实现代码
09-03
以上代码涵盖了Android开发中常见的图片类型转换。需要注意的是，在处理Bitmap时，由于其消耗内存较大，建议在不使用时及时释放，以避免内存泄漏。此外，转换过程中可以根据实际需求调整图片质量和压缩格式，以达到...
Android处理图像数据转换的各种方法
09-03
在Android开发中，处理图像数据转换是不可或缺的一部分。无论是在加载、显示还是编辑图像时，都需要将各种数据格式转换成Bitmap对象，以便于系统能够处理和显示。以下是一些常用的Android图像数据转换方法： 1. RGB...
数据类型转换实用工具
06-27
1、双字转实数：有时通讯数据类型为实数，占2个字。此时可用到功能块：DWORD_TO_REAL_1，此功能块是我们公司软件实数存储方式，大多数据可用此功能块转换数据类型；而功能块DWORD_TO_REAL_2功能与此相同，但它可灵活调整数据排列方式，可根据实数字节排列方式对功能块重新定义。 2、字型转有符号整形：有时通讯数据类型为有符号整数，占一个字。此时可用到功能块：WORD_TO_INT_1，并可灵活调整字节高低位。
java int 类_java Int数据工具类
weixin_36018748的博客
02-15 312
1、在使用tcp协议传输数据时，使用到的 Int 数据的工具类方法//将 Int 数据转换成字节数组public static byte[] intToByteArray(int data){byte[] result = new byte[4];result[0] = (byte)((data >> 24) & 0xFF);result[1] = (byte)((data &...
java官方 des,DES.java · KimmingLau/DES和AES实现 - Gitee.com
weixin_39906521的博客
03-10 88
import java.io.UnsupportedEncodingException;import java.util.ArrayList;import java.util.Arrays;import java.util.Collections;import java.util.List;import java.util.Scanner;public class DES {public stat...
Android/Java中，各种数据类型之间的互相转换，给出各种实例，附上中文注释
最新发布
HRD的博客
08-22 1427
当涉及到数据类型之间的转换时，Android提供了许多内置方法和操作符来简化这个过程。下面是一些常见的数据类型转换实例，包括注释来帮助你理解。
android开发:数据类型,Android开发从零开始之java-数据类型
weixin_30247833的博客
05-30 348
/** 作者：钟志钢* 功能：java数据类型与分支结构* 时间：2013-1-23** 1，基本数据类型：整数、小数(浮点)、布尔、字符类型。* 2，整数类型：byte, short, int, long.* byte, 一个字节，8位. short,两个字节，int, 四个字节， long , 8 个字节* byte数据范围：负的二的八减一次方 到 正的二的八减一次方减一；* 最高 位是符号位...
Android float与byte相互转换
jinhuiyu0403的专栏
10-08 979
/** * 浮点转换为字节 * * @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 >> .
Android 数据类型转换
weixin_46354773的博客
08-19 1193
StringBuffer 转换成 String String c = stringBuffer.toString(); String 换成 StringBuffer String str=“Hello World.”; StringBuffer buffer = new StringBuffer(str); String str=“Hello World.”; StringBuffer buffer2 = new StringBuffer(); buffer2.append(str); Strin.
android数据库支持的数据类型
u011247942的博客
10-20 1338
NULL、INTEGER、REAL、TEXT、BLOB 但是，sqlite3也支持如下的数据类型 smallint           16位整数 integer             32位整数 decimal(p,s)   p是精确值,s是小数位数 float                  32位实数 double             64位实数 char(n)    
Java,android涉及的所有数据类型
HDHunter的专栏
05-04 1829
什么事数据类型，简单的说，就是存数据用的。在我们开发的过程中，简单数据类型越来越变成中间量，而工程中真正使用较多的， 则是一些复杂的存数据的东西。 大家可以盘点一下，有什么类型没有收录，欢迎留言。 primitive type。基本类型直接包含值（directly contain value）。 boolean类型以及数值类型（numeric types）。 numeric ty
android 字符串 整型 浮点型 相互转换
八戒卖萌的博客
07-21 7078
java中String字符串转化为数字： // 转换为浮点型： // 使用Double或者Float的parseDouble或者parseFloat方法进行转换 // String s = "123.456 "; //要确保字符串为一个数值，否则会出异常 // double d = Double.parseDoubl
Java数据类型转换与Android应用开发基础
在Android开发中，数据类型转换常见于各种数据处理和API交互。例如，从JSON字符串解析数据时，可能需要将String转换为Integer、Double等；在UI组件间传递数据时，可能需要将整型数字转换为字符串显示在TextView上；...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值