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

最新推荐文章于 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 BCD和String的转换
12-22
这个工程里提供了一个工具类，是提供BCD码与String的互相转换的，有需要的可以下载
java 转16进制_java中进制的转换,Byte与16进制的转换方法
weixin_39928667的博客
02-12 2937
java中对于进制的转换有很多方式，其中对于常见的基本的二进制 八进制 十进制 十六进制等的转换有对于的包装类实现，不需要通过二外的算法来进行实现，具体如下：首先关于最简单的二进制转换的方法有：十进制转成十六进制：String Integer.toHexString(int i)十进制转成八进制String Integer.toOctalString(int i)十进制转成二进制String In...
java int 类_java Int数据工具类
weixin_36018748的博客
02-15 313
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 89
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...
获取一个 Byte 的各个 Bit 值
java小强
10-11 3239
1. bit：位    一个二进制数据0或1，是1bit；2. byte：字节    存储空间的基本计量单位，如：MySQL中定义 VARCHAR(45)  即是指 45个字节；    1 byte = 8 bit3. 一个英文字符占一个字节；    1 字母 = 1 byte = 8 bit4. 一个汉字占2个字节；    1 汉字 = 2 byte = 16 bitbyte：一个字节（8位）...
Android数据类型之间相互转换系统介绍
09-05
本文主要针对初学者面临的Android数据类型转换问题进行详细介绍。 Android中的数据类型主要遵循Java的分类，包括布尔型、字符型和数值型。数值型进一步分为整型（byte、short、int、long）和浮点型（float、double...
android图片类型之间相互转换实现代码
09-03
以上代码涵盖了Android开发中常见的图片类型转换。需要注意的是，在处理Bitmap时，由于其消耗内存较大，建议在不使用时及时释放，以避免内存泄漏。此外，转换过程中可以根据实际需求调整图片质量和压缩格式，以达到...
Android处理图像数据转换的各种方法
09-03
在Android开发中，处理图像数据转换是不可或缺的一部分。无论是在加载、显示还是编辑图像时，都需要将各种数据格式转换成Bitmap对象，以便于系统能够处理和显示。以下是一些常用的Android图像数据转换方法： 1. RGB...
jni数据类型转换
02-05
jni数据类型转换例程 1. java向native传递常用基本数据类型 和字符串类型 2. java向native传递数组类型 3. java向native传递自定义java对象 4. java向native传递任意java对象（以向native传递ArrayList为例) 5....
Android/Java中，各种数据类型之间的互相转换，给出各种实例，附上中文注释
最新发布
HRD的博客
08-22 1428
当涉及到数据类型之间的转换时，Android提供了许多内置方法和操作符来简化这个过程。下面是一些常见的数据类型转换实例，包括注释来帮助你理解。
android数据类型
qq_41362557的博客
03-25 1224
我特别尊敬的一个人说过一句话：“原生有的方法就用原生的，不要搞骚操作。”，en！骚操作搞不好程序就蹦了，而且还繁琐不美观等。那么想着原生的方法，也得知道Google封装的库有什么方法，不知道就没办法用了。今天就整理一下数据类型的知识吧！毕竟数据类型的转换还是很常用的。 目录java数据类型有哪些基本数据类型引用数据类型 java数据类型有哪些 基本数据类型 short（短整型）int（整型）; long（长整型）; float（单精度浮点型）; boolean（布尔值）; char（字符型）; double
Android 和 SQLite 基本数据类型
daozhongyang的专栏
03-23 9115
Android 基本数据类型：boolean, char, byte, int, long, float, double, String Android 的5种打印级别：Verbose,Debug,Info,Warning,Error ­ SQLite3 支持的数据类型5种：Null,Integer,Real(浮点数)，Text,BLOB(二进制对象) 请参见 htt
Android --- 怎么把其他类型的数据转换成 Json 字符串
梁同学与Android
03-24 1687
今天用AS写了这么一个功能，就是怎么把 Json 数据转换成 Json 字符串 ，怎么将 Json 字符串存到本地文件中，首先第一个问题：怎么把其他类型的数据转换成 Json 字符串 其它类型的数据有很多，比如 String、Object、Number、Boolean、Bean、List、Array、Map、Set 等，我们把这些封装到一个工具类中即可，上代码，嗨嗨！ package com.example.baseobservable.json; import com.googlecode.openbe
Int,Integer,String类型互相转换方法
gx632122336的博客
03-25 175
int<->Integer: int->Integer: new Integer(5) static Integer valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例 Integer->int: intValue() Integer<->String: String->Integer: static Integer decode(String nm) static Integer valueOf(String s) Integer
【Android学习札记】数据类型
bt_xxx的博客
05-20 686
基本数据类型、扩展数据类型
Android 数据类型转换
weixin_46354773的博客
08-19 1200
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常用数据类型（String 、int、float、double、）转换
yue_233的博客
06-17 1万+
Android常用数据类型（String 、int、float、double、long）转换 因为经常用到类型装换，所以整理一下，方便查找： 一、String转int，float，double，long. int i = Integer.parseInt(str) 或者 int i = Integer.valueOf(str).intValue(); float f = Float.pa...
int型整数和BCD码之间的相互转化
热门推荐
wxywxywxy110的博客
09-27 1万+
举例说明：假设int型整数为12345678，转化为BCD码后成为了32位的12345678，表示4个字节。#include<stdio.h> typedef unsigned long u32; u32 inttoBCD(int m) { u32 r=0,n=1; int a; while(m) { a=m %10; m=m/10;
android中各种数据类型之间转换
vaecer
03-22 1万+
字符串String转换成整数int 1). int i = Integer.parseInt([String]); 或 i = Integer.parseInt([String],[int radix]); 2). int i = Integer.valueOf(my_str).intValue();  注: 字串转成 Double, Float, Long 的方法大同小
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值