tohexstringjava

㈠ 跪求“java中二进制怎么表示”

java中二进制的表示：

1、Java中定义两个数，然后分别打印出它们的二进制表示（例如7和-7）：

System.out.println("Java二进制7:"+Integer.toBinaryString(7));

System.out.println("Java二进制-7:"+Integer.toBinaryString(-7));

输出：

Java二进制7: 111

Java二进制-7:

7的二进制就是111

-7转化二进制的过程:

(1)把-7转化成7，二进制是 111

(2)Java中对于不满32位的int二进制自动补齐，所以变成了 (29个0)111

(3)然后取反 (29个1)000

(4)然后加1 (29个1)001

(1)tohexstringjava扩展阅读：

c语言中二进制的转换：

用函数转换itoa(值，数组名，进制)

#include<stdio.h>

#include<stdlib.h>

voidmain()

{

char str[8];

inti=8;

itoa(i,str,2);

printf("%s",str);

}

㈡ 用JAVA将十进制转换成十六进制

1、用Integer.toHexString方法即可将十进制装成十六进制。

package com.test;

public class Test {

public static void main(String[] args) {
int i = 123;
System.out.println(Integer.toHexString(i));
}
}

㈢ java中怎么将10进制转化成十六进制

1,可以手动计算先将10进制的数转为二进制，二进制再转为16进制

2，我们可以直接使用java api提供的方法直接转换

int num = 14;

String hexNum = Integer.toHexString(num);

hexNum即为16进制的数

3，如图

㈣ JAVA 在线等 急！！

importjava.util.Scanner;

publicclassComputerUtil{

publicstaticvoidmain(String[]args){

Scannerinput=newScanner(System.in);

floatnum1=0;
floatnum2=0;

intresult=0;

System.out.print("Inputnum1:");
num1=input.nextFloat();
System.out.print("Inputnum2:");
num2=input.nextFloat();

result=(int)(num1+num2);

System.out.println("num1:"+num1+"->"+(char)num1);
System.out.println("num2:"+num2+"->"+(char)num2);
System.out.println("result:"+result+"->"+(char)result);

input.close();
}

}

㈤ java中如何输出字符变量的Unicode编码值

java中可以使用char类提供的charAt()方法来获得字符的unicode的编码值，示例如下：

(5)tohexstringjava扩展阅读：

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。

参考资料：网络-java

㈥ 用JAVA把二进制数转换成十进制数。

二进制转十进制

Integer.valueOf("0101",2).toString()

import java.util.Scanner;

public class Test {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("输入一个二进制数: ");

String a = sc.nextLine();

int d = Integer.parseInt(a, 2); // 2进制

int o = Integer.parseInt(a, 8); // 8进制

System.out.println("二进制转为十进制: " + d);

System.out.println("八进制转为十进制: " + o);

计算机内部使用二进制表示数

二进制与十进制的转换是比较复杂的。比如我们要让计算机计算50+50=?，那么首先要把十进制的50转换成二进制的“50”——110010，这个过程要做多次除法，而计算机对于除法的计算是最慢的。把十进制的50转换成二进制的110010还不算完，计算出结果1100100之后还要再转换成十进制数100，这是一个做乘法的过程，对计算机来说虽然比除法简单，但计算速度也不快。

以上内容参考：网络-十进制

㈦ java如何编程实现，获取固定IP发来所有的数据包

java获取固定IP发来所有的数据包，需要实现网络嗅探的部分功能：

代码如下;

/*******************
*JpcapTip.java
*/
packagem;

importjpcap.PacketReceiver;
importjpcap.JpcapCaptor;
importjpcap.packet.*;
importjpcap.NetworkInterface;
importjpcap.NetworkInterfaceAddress;
//importjava.net.InetAddress;
//importjava.net.UnknownHostException;

{

publicvoidreceivePacket(Packetpacket){
System.out.println("********************************************");
/*IP数据报报文头*/
byte[]l=packet.header;
/*
for(intt=0;t<21;t++){
System.out.print(l[t]+"***");
}
*/
Stringstr="";
System.out.print("报文头:");
for(inti=0;i<l.length;i++){
//str=str+l;
intm=0;
m=l[i];
m=m<<24;
m=m>>>24;
str=str+Integer.toHexString(m);
//System.out.print("***"+l[i]);
}
System.out.println(str);
intd=l.length;
System.out.println("首部长度："+(d*8)+"bit");

/*分析源IP地址和目的IP地址*/
/*分析协议类型*/
/**
if(packet.getClass().equals(IPPacket.class)){
IPPacketipPacket=(IPPacket)packet;
byte[]iph=ipPacket.option;
Stringiphstr=newString(iph);
System.out.println(iphstr);
}
*/
if(packet.getClass().equals(ARPPacket.class))
{
System.out.println("协议类型：ARP协议");
try{
ARPPacketarpPacket=(ARPPacket)packet;
System.out.println("源网卡MAC地址为："+arpPacket.getSenderHardwareAddress());
System.out.println("源IP地址为："+arpPacket.getSenderProtocolAddress());
System.out.println("目的网卡MAC地址为："+arpPacket.getTargetHardwareAddress());
System.out.println("目的IP地址为："+arpPacket.getTargetProtocolAddress());

}catch(Exceptione){
e.printStackTrace();
}
}
else
if(packet.getClass().equals(UDPPacket.class))
{
System.out.println("协议类型：UDP协议");
try{
UDPPacketudpPacket=(UDPPacket)packet;
System.out.println("源IP地址为："+udpPacket.src_ip);
inttport=udpPacket.src_port;
System.out.println("源端口为："+tport);
System.out.println("目的IP地址为："+udpPacket.dst_ip);
intlport=udpPacket.dst_port;
System.out.println("目的端口为："+lport);
}catch(Exceptione){
e.printStackTrace();
}
}
else
if(packet.getClass().equals(TCPPacket.class)){
System.out.println("协议类型：TCP协议");
try{
TCPPackettcpPacket=(TCPPacket)packet;
inttport=tcpPacket.src_port;
System.out.println("源IP地址为："+tcpPacket.src_ip);
System.out.println("源端口为："+tport);
System.out.println("目的IP地址为："+tcpPacket.dst_ip);
intlport=tcpPacket.dst_port;
System.out.println("目的端口为："+lport);
}catch(Exceptione){
e.printStackTrace();
}
}
else
if(packet.getClass().equals(ICMPPacket.class))
System.out.println("协议类型：ICMP协议");
else
System.out.println("协议类型：GGP、EGP、JGP协议或OSPF协议或ISO的第4类运输协议TP4");

/*IP数据报文数据*/
byte[]k=packet.data;
Stringstr1="";
System.out.print("数据:");
for(inti=0;i<k.length;i++){
//intm=0;
//m=k[i];
//m=m<<24;
//m=m>>>24;
//str1=str+Integer.toHexString(m);
str1=newString(k);
//str1=str1+k[i];
//System.out.print("***"+k[i]);
}
System.out.println(str1);
System.out.println("数据报类型:"+packet.getClass());

System.out.println("********************************************");
}

publicstaticvoidmain(String[]args)throwsException{
//TODO自动生成方法存根

NetworkInterface[]devices=JpcapCaptor.getDeviceList();//.getDeviceList();.
//for(inti=0;i<devices.length;i++){
inta=0;
//try{
/*本地网络信息*/
byte[]b=devices[1].mac_address;//网卡物理地址
//}
//catch(){}
System.out.print("网卡MAC:00");
for(intj=0;j<b.length;j++){
//a=a<<8;
a=b[j];
a=a<<24;
a=a>>>24;
System.out.print(Integer.toHexString(a));
}
System.out.println();
NetworkInterfaceAddress[]k=devices[1].addresses;

//System.out.println("网卡MAC:"+Integer.toHexString(a));
for(intn=0;n<k.length;n++){
System.out.println("本机IP地址:"+k[n].address);//本机IP地址
System.out.println("子网掩码:"+k[n].subnet);//子网掩码
}
System.out.println("网络连接类型:"+devices[1].datalink_description);
//}
NetworkInterfacedeviceName=devices[1];
/*将网卡设为混杂模式下用网络设备deviceName*/
JpcapCaptorjpcap=JpcapCaptor.openDevice(deviceName,2000,false,1);//openDevice(deviceName,1028,false,1);
jpcap.loopPacket(-1,newJpcapTip());
}

}

㈧ Java的小问题

一.double类型的存储表示

Java的浮点类型表示完全按照IEEE754标准(Standards of IEEE 754 floating point numbers),有兴趣可以上IEEE标准网站(www.ieee.org)查阅.该标准的内容基本上描述了浮点类型的存储格式(Storage Layout),下面我从中总结几段,来概括该标准,详细信息请查阅标准原文.

1.什么是浮点数.

计算机上表达实数有两中方法:定点表示(fixed-point)和浮点表示(floating-point).定点表示法就是在现有的数字中间的某个位置固定小数点,整数部分和小数部分的表示和一个普通整数的表示法没什么两样.例如,我们的数字长度为4,小数点位于中间,那么你可以表示10.28,也可以表示00.01,与这种方法性质类似的定点表示还有使用分数的形式.定点数的固定窗口形式使得他既不能够表示非常大的数又不能表示非常小的数.并且当除法发生时,大量 的精度丢失.

浮点数采用科学计数法的形式来表示实数.例如123.456可以表示成1.23456×102.相对于定点数的固定窗口(fixed Window)的限制,它采用的是浮动窗口(sliding window),因此可以表示较大精度范围的一个实数.

2.存储布局(Storage Layout)

所谓的存储布局就是一个浮点数在内存中如何表示.我们知道浮点数有float和double,前者是4个字节也就是32位,后者是8个字节也就是64位.布局分别为:

符号 指数 小数部分 偏移附加(bias)

单精度 1[31] 8[30-23] 23[22-00] 127

双精度 1[63] 11[62-52] 52[51-00] 1023

中括号内为位的编号范围,外面为该部分所占有的位的数量.偏移附加不属于位表示的内容,是一个常量,稍后解释.

符号只有一位:0-表示正数 1-表示负数

指数部分:用指数部分的值(8位/11位,unsigned)的值 减去 偏移附加 得到该数实际的指数 例如值为200,实际指数为73=200-127.对于双精度的double来说常量bias=1023

尾数:尾数是什么?对于一个科学计数法来讲,形式象这样的 L.M×BE,那么这个L.M就是所谓的尾数(mantisa).它由一个起始位和一个小数部分组成.举个例子,5可以用科学计数法表示成不同形式:

5*100

0.5*101

50*10-1

那么我们引进一个概念,规范化形式(normalized form)和非规范化形式(denormalized form).我们定义规范化形式为小数点位于第一个不为0的数字后面的表达形式为规范化形式,因此上面的第一种形式为规范化形式,其他的为非规范化形式,Java中的浮点表示完全按照这个标准,只有两种形式规范化形式:1.f 和 非规范化形式 0.f .

那么,对于我们的位布局来说,选用底数为2的话,只有一个数字是非零的,那就是1.所以我们的隐含起始数字可以不用占用一个位,因为除了0就只能是1,具体的隐含规则,稍后展示.

3.表示的意义.

对应于上面的表格,每一个区域对应的值的范围所表示的浮点数的意义:

符号位s 指数位e 小数位f 所表示的意义v

0 00..00 00..00 +0

0 00..00 00..01

:

11..11 正的非规范实数,计算方法v=0.f × 2(-b+1)

0 00..01

:

11..10 XX..XX 正的规范化实数,计算方法v=1.f × 2(e-b)

0 11..11 00..00 正的无穷大

0 11..11 00..01

:

01..11 无意义的非数字SNAN

0 11..11 10..00

:

11..11 无意义的非数字QNAN

其中b=127(float)/b=1023(double),SNAN表示无效运算结果,QNAN表示不确定的运算结果,都是无意义的.

如果把符号位s改成1,那么就全部都是负数的含义,其他意义和这相同.

另外我们看到,对于无意义的数字是指数部分为全1时,也就是说这里有很多种组合都是无意义的非数字,而我们的Java中,判断一个数字是否是NAN的做法相当简单

static public boolean isNaN(double v) {

return (v != v);

}

从这里可以看出来,虚拟机对于double类型的数据比较时,肯定是先做了指数值的判定,发现不是全1时才作内存的逐位比较.当然这是我得推测,真像不知道是否如此.

再另外,我们''现在十分清楚,double类型所能表示的最小值就是它的值之间的距离,也就是我们所说的精度,数字按这种精度向整数"1阶梯式的累加时,正好不能和1完全匹配,换句话说,1不是最小值(精度/距离)的整数倍.因此如果你设置变量 double d = 0.1;而结果不会是0.1,因为无法表示0.1;

二.怎么查看double类型的存储结构?

我们很清楚Java的Double类型提供一个函数叫做doubleToLongBits函数,这个函数的其实很简单,我们知道,long类型和double类型都是64位的,他们的内存大小一样,这个函数的做法就是把double对应的内存结构复制到同样大小的long类型变量的内存结构中.返回这个long值.因为Java不支持对double类型做位运算,因此:

1.该函数不可能用Java语言完成,所以他是JNI实现

2.我们利用对long类型的位运算可以把该内存结构打印出来查看.

/**

* 测试

*/

public static void main(String[] args){

myTest t = new myTest();

double d = 0.1d;

long l = Double.doubleToLongBits(d);

System.out.println(t.getLongBits(l));

}

/**

* 得到常整数的bit位表示字符串

* @param a

* @return

*/

public String getLongBits(long a){

//8个字节的字节数组,读出来

byte[] b = new byte[8];

for(int i=7;i>=0;i--){

b[i] = (byte)(a&0x000000FF);

a = a>>8;

}

return this.byte2hex(b); //调用下面一个函数

}

/**

* 字节数组转换成字符串

* @param b

* @return

*/

public static String byte2hex(byte[] b){

StringBuffer sb=new StringBuffer();

String stmp="";

for(int n=0;nstmp=(Integer.toHexString(b[n]&0XFF));

if(stmp.length()==1){

//不足两位的末尾补零

sb.append("0"+stmp);

} else{

sb.append(stmp);

}

if(n//":"作为分割符

sb.append(":");

}

}

return sb.toString().toUpperCase();

}

0.1打印出来的内存结果是:

3F:B9:99:99:99:99:99:9A

我们恢复一下和第一节的表示意义对照表对照一下:

0 01111111011 1001.....1010

有兴趣的话,可以那科学计算器按照第一节的规则计算一下它的值,哦,正好就是我们通过System.out.println(d)打印的结果.

㈨ java基础问题

JimmyPerson@de6ced是输出的字符串“Jimmy”加上这个jimmy类，
jdk中的System.out.println（ )提供了对对象的输出方式，所有java类都继承Object这个类，去看看API可以知道该类的toString方法，具体可以查看java源代码。我找了部分源代码，如下
System.out.println("Jimmy" + jimmy );

->public void println(String x) {
synchronized (this) {
print(x);
newLine();
}
}

其中print（x）中x参数可以是基本类型，string类型，还有Object，输出Object的代码如下：
public void print(Object obj) {
write(String.valueOf(obj));
}

而String.valueOf(obj)就是调用toString方法，代码如下：
public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}

先在再看看toString里是什么内容，阁下就知道了，代码如下
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
其中getClass().getName()是输出类的类名，Integer.toHexString(hashCode())是将类的内容以哈希值转化为16进制输出
|

javaJDK里面包含了源代码，查看源代码，看看别人的精髓也是一种不错的学习方法

㈩ java中如何将十进制数字转化成二进制

如果表达小于2^31-1的正数代码如下：

public void binaryToDecimal(int n){

int t = 0; //用来记录位数

int bin = 0; //用来记录最后的二进制数

int r = 0; //用来存储余数

while(n != 0){

r = n % 2;

n = n / 2;

bin += r * Math().pow(10,t);

t++;

}

System.out.println(bin);

}

使用字符串的拼接（+）来实现大于2^31-1的数，代码如下:

public void binaryToDecimal(int n){

String str = "";

while(n!=0){

str = n%2+str;

n = n/2;

}

System.out.println(str);

}

可以右移后再与0x01进行&运算得到第一位的数字判断判断它的第几位上是0，第几位上是1，代码如下：

class ByteMove

{

public static void main(String[] args)

{

int i = 7;

move(i);

}

static void move(int num){

for(int i= 0;i<6;i++){

System.out.println("第"+(i+1)+"位：" + (num >> i & 0x01));

}

}

}