2进制

计算机的底层全部都是2进制的!

byte short int long float double char String

Java 利用算法支持了10进制:

• parseInt 将10进制转换为2进制
• toString 将2进制转换为10进制

原理:

案例:

public class Demo01 {
public static void main(String[] args) {
/*
* 显示整数的2进制, 也就是显示内存中实际的2进制
* 存储情况.
*/
//编译以后 "50" 就被编译为2进制
int i = 50;
System.out.println(
Integer.toBinaryString(i));
//Java输出整数时候自动调用了Integer.toString()
//将2进制转换为10进制字符串输出!
System.out.println(i); //50
}
}

案例:

public class Demo02 {
public static void main(String[] args) {
/*
* 输出0~50全部的2进制
*/
for (int i = 0; i <= 50; i++) {
System.out.println(
StringUtils.leftPad(
Integer.toBinaryString(i), 32, "0"));
}
}
}

16进制

16进制用于简写2进制!!!

2进制书写繁琐! 使用16进制可以将2进制每4位数缩写为一个16进制数字

01101001 00100001 11101001 00101001
简写为
69ade929

案例:

public class Demo03 {
public static void main(String[] args) {
/*
* 16进制用于缩写2进制.
* 16进制就是2进制!!!
*/
int i = 0x69ade929;
System.out.println(
Integer.toBinaryString(i));
//Java 利用算法 parseInt(hex, 16) 将16进制
//转换为2进制.
String hex = "69ade929";
int n = Integer.parseInt(hex, 16);
System.out.println(
Integer.toBinaryString(n));
}
}

补码

将2进制数的一半作为负数的算法, 称为补码

max =
01111111 11111111 11111111 11111111
int max = 0x7fffffff;

案例:

public class Demo05 {
public static void main(String[] args) {
/*
* 输出-50 到 50的全部补码
*/
for(int i=-50; i<=50; i++){
System.out.println(
StringUtils.leftPad(
Integer.toBinaryString(i),32,"0"));
}
}
}

案例:负数

public class Demo04 {
public static void main(String[] args) {
int i = -3;
System.out.println(
Integer.toBinaryString(i));
System.out.println(i);//-3
long l = -3L;
System.out.println(
Long.toBinaryString(l));
}
}

案例:

public class Demo06 {
public static void main(String[] args) {
/*
* 输出整数的最大值
*/
//int max = 0x7fffffff;
int max = Integer.MAX_VALUE;
System.out.println(max);
System.out.println(
Integer.toBinaryString(max));
/*
* 输出整数的最小值
*/
int min = 0x80000000;
System.out.println(min);
System.out.println(
Integer.toBinaryString(min));
}
}

题目

int i = 0xffffffff;
System.out.println(i);
如上代码输出结果:
A.2147483647 B.-2147483647 C.2147483648 D.-2147483648 E.-1

补码互补对称现象

面试题:

System.out.println(~3+1);
如上代码的结果是: ( C )
A.3 B.4 C.-3 D.-4
原理如下:
3
=
00000000 00000000 00000000 00000011
= 3
~3
=
11111111 11111111 11111111 11111100
= -4
~3+1 =
11111111 11111111 11111111 11111101
= -3
System.out.println(~20+1);
如上代码的结果是: ( C )
A.20 B.21 C.-20 D.-21
原理:
20
= 00000000 00000000 00000000 00010100
=
20
~20
= 11111111 11111111 11111111 11101011
= -21
~20+1
= 11111111 11111111 11111111 11101100
= -20
System.out.println(~20);
如上代码的结果是: ( D )
A.20 B.21 C.-20 D.-21
System.out.println(~-20);
如上代码的结果是: ( E )
A.20 B.21 C.-20 D.-21 E.19

2进制计算

~ 取反运算
& 与运算
| 或运算
>>> 逻辑右移位运算
>>
数学右移位运算
<<
左移位运算

& 与运算(逻辑乘法)

规则:

0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 & 1 = 1

| 或运算 (逻辑加法)

规则:

0 | 0 = 0
0 | 1 = 1
1 | 0 = 1
1 | 1 = 1

>>> 逻辑右移位运算

每个位向右移位, 高位补0

例子:

n
= 00101011 10110111 10100101 11011010
m=n>>>1 = 000101011 10110111 10100101 1101101
k=n>>>2 = 0000101011 10110111 10100101 110110

<< 左移位运算

每个位向左移位, 低位补0

例子:

n
= 00101011 10110111 10100101 11011010
m=n<<1
= 0101011 10110111 10100101 110110100
k=n<< 2 = 101011 10110111 10100101 1101101000

案例: 利用2进制计算, 将 '中' 进行UTF-8编码

int c = '中';//0x4e2d
//
c
00000000 00000000 0100 1110 0010 1101
//utf-8 b1= 1110XXXX
//utf-8 b2= 10XXXXXX
//utf-8 b3= 10XXXXXX

编码:

解码:

代码:

public class Demo07 {
public static void main(String[] args)
throws Exception{
/*
* 利用2进制计算实现 中文字的UTF-8编码
*/
int c = '中';
//UTF-8 空白编码格式:
int b1=0xe0;
int b2=0x80;
int b3=0x80;
//填充第一个编码
int c1 = (c>>>12) | b1;
//填充第二个编码
int c2 = (c>>>6) & 0x3f | b2;
//填充第三个编码
int c3 = c & 0x3f | b3;
print(c);
print(b1);
print(c>>>12);
print(c1);
print(c2);
print(c3);
//解码: 测试
String str = new String(
new byte[]{(byte)c1,(byte)c2,(byte)c3}
, "UTF-8");
System.out.println(str);
//utf-8 解码的工作原理
int ch = (c1<<12)& 0xffff |
(c2<<6) & 0xfff
|
c3 & 0x3f;
System.out.println((char)ch);//中
}
public static void print(int c) {
System.out.println(
StringUtils.leftPad(
Integer.toBinaryString(c),32,"0"));
}
}

经典面试题目:

优化计算 n % 4 可以优化为 ( n & 0x3 )
n = 5 = 00000000 00000000 00000000 00000101
% 4 = 1
n = 6 = 00000000 00000000 00000000 00000110
% 4 = 2
n = 7 = 00000000 00000000 00000000 00000111
% 4 = 3
n = 8 = 00000000 00000000 00000000 00001000
% 4 = 0
n = 9 = 00000000 00000000 00000000 00001001
% 4 = 1
优化计算 n % 8 可以优化为 ( n & 0x7 )
优化计算 n % 16 可以优化为 ( n & 0xf )
if (year & 0x3 == 0){
//可以被4整除!
}

移位计算的数学意义

142323.
1423230. 扩大10倍
14232300. 扩大10倍
142323.
1423230. 扩大10倍
14232300. 扩大10倍
小数点不动, 数字向左移动
i
=
00000000 00000000 00000000 00110010. = 50
i<<1 =
0000000 00000000 00000000 001100100. = 100
i<<2 =
000000 00000000 00000000 0011001000. = 200

案例:

public class Demo08 {
public static void main(String[] args) {
/*
* 左移位的数学意义
*/
int n = 50;
int m = n<<1;
int k = n<<2;
System.out.println(m);
System.out.println(k);
Demo07.print(n);
Demo07.print(m);
Demo07.print(k);
/*
* 右移位的数学意义
*/
n = 50;
m = n>>1; //>>>
k = n>>2; //>>>
System.out.println(m);//25
System.out.println(k);//12
Demo07.print(n);
Demo07.print(m);
Demo07.print(k);
/*
* >>> >> 在正数情况下一样
* >>> >> 在负数情况下不同
*
>> 负时候, 高位补1
*
>>> 负时候, 高位补0
*
* n =
11111111 11111111 11111111 11001110 -50
* n>>1
111111111 11111111 11111111 1100111 -25
* n>>2
1111111111 11111111 11111111 110011 -13
* n>>>1 011111111 11111111 11111111 1100111
*
* 将 >> 称为数学移位计算(向小方向取整)
* 将 >>> 称为逻辑移位计算
*
*/
n = -50;
n = n>>1;
k = n>>>1;
System.out.println(n);
System.out.println(k);
}
}

反射

反射是Java提供的API, 是Java 中的动态执行机制, 可以动态加载类,动态创建对象,动态访问属性,动态调用方法. 等

甚至打破访问限制, 访问私有成员(打破了封装)

静态执行

按照编译期间约定执行执行顺序, 在运行期间顺序执行.

Foo foo = new Foo();
foo.test();

动态执行

编译期间不指定执行顺序, 在运行期间才缺点创建那个对象, 执行方法.

利用反射API, 可以实现动态执行!

动态加载类

Class cls = Class.forName(类名);

动态创建对象

Object obj = cls.newInstance();

这个类型必须有无参数构造器, 如果没有将抛出异常, 反射提供了调用有参数构造器的API方法! 不是重点!

反射API可以动态获取类的信息

包括: 类中声明的属性, 类中声明的方法, 等

案例:

public class Foo {
private int id = 5;
public String name = "Tom";
public void test(){
System.out.println("test()");
}
public void hello(){
System.out.println("Hello()");
}
}
public class Demo01 {
public static void main(String[] args)
throws Exception{
/*
* 利用反射API动态加载类到方法区
* 在运行期间加载一个类到内存中
*/
Scanner in = new Scanner(System.in);
System.out.print("输入类名:");
//在运行期间得到类名
String className = in.nextLine();
//动态加载类, 如果类名错误将抛出异常
Class cls = Class.forName(className);
//显示加载的结果
System.out.println(cls);
//动态创建对象
Object obj = cls.newInstance();
System.out.println(obj);
//Declared: 声明的
Field: 字段,属性
//动态获取类中声明的全部属性信息
Field[] fields=cls.getDeclaredFields();
for (Field field : fields) {
System.out.println(field);
}
//动态获取类中声明的全部方法信息
Method[] methods = cls.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method);
}
}
}

经典题目:

Eclipse 的快捷菜单用到了哪些技术?
答: 反射 呗!

最后

以上就是懦弱小鸽子为你收集整理的二进制及java反射机制（培训笔记）2进制反射的全部内容，希望文章能够帮你解决二进制及java反射机制（培训笔记）2进制反射所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。