public class Test3
{
public static void main(String[] args)
{
//定义变量，基本类型的取值范围和位长度
byte b = 0;
System.out.println((b = Byte.MAX_VALUE));
System.out.println((b = Byte.MIN_VALUE));
System.out.println(Byte.SIZE);
System.out.println("===================================>");
short s = 0;
System.out.println((s = Short.MAX_VALUE));
System.out.println((s = Short.MIN_VALUE));
System.out.println(Short.SIZE);
System.out.println("===================================>");
int i = 0;
System.out.println((i = Integer.MAX_VALUE));
System.out.println((i = Integer.MIN_VALUE));
System.out.println(Integer.SIZE);
System.out.println("===================================>");
long l = 0l;
System.out.println((l = Long.MAX_VALUE));
System.out.println((l = Long.MIN_VALUE));
System.out.println(Long.SIZE);
System.out.println("===================================>");
float f = 0.0f;
System.out.println((f = Float.MAX_VALUE));
System.out.println((f = Float.MIN_VALUE));
System.out.println(Float.SIZE);
System.out.println("===================================>");
double d = 0.0;
System.out.println((d = Double.MAX_VALUE));
System.out.println((d = Double.MIN_NORMAL));
System.out.println(Double.SIZE);
System.out.println("===================================>");
boolean bool = false;
System.out.println((bool = Boolean.FALSE));
System.out.println((bool = Boolean.TRUE));
System.out.println("===================================>");
char c = ' ';
System.out.println((c = Character.MAX_VALUE));
System.out.println((c = Character.MIN_VALUE));
System.out.println(Character.SIZE);
System.out.println("===================================>");
//低精度向高精度赋值不需要强制转换
//java会自动升位
l = b;
l = s;
l = i;
l = c;
d = f;
//高精度向低精度赋值会降低精度，so
//需要进行强制类型转换,仅取按照左边
//类型的长度取右边类型的低位，高位被抛弃
b = (byte) s;
b = (byte) i;
b = (byte) l;
b = (byte) c;
f = (float) d;
//对于boolean，在java中，单个bool变量以
//int存储，而bool数组则是以byte数组存储
//对于这些数值，非0为真，0为假,最典型的例子
//在DataOutputStream.readBoolean()方法
bool = b != 0;
bool = s != 0;
bool = i != 0;
bool = l != 0;
bool = f != 0;
bool = d != 0;
bool = c != 0;
//基本类型转换成字节数组，在IO操作中
//经常要进行这种转换
System.out.print("short");printByteArray(toByteArray(s = 0x0201));
System.out.print("int ");printByteArray(toByteArray(i = 0x04030201));
System.out.print("long ");printByteArray(toByteArray(l = 0x0807060504030201l));
System.out.print("char ");printByteArray(toByteArray(c = 0x0201));
System.out.print("true ");printByteArray(toByteArray(bool = true));
System.out.print("false");printByteArray(toByteArray(!bool));
System.out.println("===================================>");
//这里因为表达式升位为int，所以
//需要强制转换
b = 20;
s = (short)(b * 20);
System.out.println(s);
System.out.println("===================================>");
//int的最大值*2之后应该是一个33位的数
//但并没有进行升位到long，所以java的
//默认升位范围在int，即便表达式超出
//int范围，这样会损失精度
i = Integer.MAX_VALUE;
i = i * 2;
System.out.println(i);
System.out.println("===================================>");
//这里并没有如我们所想的提升到long，而
//是仍然为int，最后赋值时才提升到long
//所以处理这个问题需要强制转换一个元素
//为long，使其他的元素都升位到long
i = Integer.MAX_VALUE;
l = i + i;
System.out.println(l);
l = (long)i + i;
System.out.println(l);
//这里看到，只需要有一个为long，不需要
//规定哪一个
l = i + (long)i;
System.out.println(l);
//这里证明上边的理论是错的，事实证明表达式
//由左向右开始，而类型升位也是，所以为了保证
//最后的精度无损，应该考虑在表达式第一个元素
//进行最大升位
l = i + i +(long)i;
System.out.println(l);
l = (long)i + i + i;
System.out.println(l);
System.out.println("===================================>");
//这两个看起来没有变化，因为在java里，double的
//升位级别是最大的，所以没有问题，换句话说，java
//默认的浮点数就是double
b = Byte.MAX_VALUE;
s = Short.MAX_VALUE;
i = Integer.MAX_VALUE;
l = Integer.MAX_VALUE;
c = Short.MAX_VALUE;
f = Float.MAX_VALUE;
d = b + s + c + i + l + f;
System.out.println(d);
d = 0.0 + b + s + c + i + l + f;
System.out.println(d);
System.out.println("===================================>");
//看起来没有问题，1100是正确的，但是如果数组是
//以false开始的呢，高位的0如何判断？所以这个还
//需要一个记录有效位数的变量，也就是数组的长度
//具体可以参考BitSet类
boolean[] boola = {true,true,false,false};
System.out.println(Long.toBinaryString(booleanArrayToNumber(boola)));
System.out.println("===================================>");
//结果为1，原因前边有说到，这里的问题是，还要
//强制转换1为long么，有没有更简单的办法？
l = 1 << 32;
System.out.println(l);
//java整数后加l表示为long类型
l = 1l << 32;
System.out.println(l);
//为什么必须加f?因为默认为double，需要加f声明
//为float类型，这在表达式中会影响精度
f = 1.0f;
}
/**
* 将一个short拆分成字节数组
* @param s
* @return
*/
public static final byte[] toByteArray(short s)
{
return new byte[]{(byte)((s & 0xff00) >> 8), (byte)(s & 0x00ff)};
}
/**
* 将一个int拆分成字节数组
* @param s
* @return
*/
public static final byte[] toByteArray(int i)
{
return new byte[]{(byte)((i & 0xff000000) >> 24), (byte)((i & 0xff0000) >> 16), (byte)((i & 0xff00) >> 8), (byte)(i & 0x00ff)};
}
/**
* 将一个long拆分成字节数组
* @param s
* @return
*/
public static final byte[] toByteArray(long l)
{
return new byte[]{(byte)((l & 0xff00000000000000l) >> 56), (byte)((l & 0xff000000000000l) >> 48), (byte)((l & 0xff0000000000l) >> 40), (byte)((l & 0xff00000000l) >> 32),
(byte)((l & 0xff000000) >> 24), (byte)((l & 0xff0000) >> 16), (byte)((l & 0xff00) >> 8), (byte)(l & 0x00ff)};
}
/**
* 将一个unicode字符拆分成字节数组
* @param c
* @return
*/
public static final byte[] toByteArray(char c)
{
return new byte[]{(byte)((c & 0xff00) >> 8), (byte)(c & 0x00ff)};
}
/**
* 将bool转换成字节
* 或者考虑多个bool按位存在一个整数里边
* @param bool
* @return
*/
public static final byte[] toByteArray(boolean bool)
{
return new byte[]{bool ? (byte)1 : (byte)0};
}
/**
* 打印一个byte数组
* @param b
*/
public static final void printByteArray(byte[] b)
{
StringBuilder sb = new StringBuilder();
sb.append('[');
byte index = 0;
do
{
sb.append(b[index]);
if(index != b.length - 1)
{
sb.append(',');
}
}
while (++index != b.length);
sb.append(']');
System.out.println(sb.toString());
}
/**
* 按位存储布尔数组
* @param b
* @return
*/
public static final long booleanArrayToNumber(boolean[] b)
{
long l = 0;
int bounds = b.length - 1;
int shift = bounds;
int index = 0;
while (index < bounds)
{
l |= (long)(b[index++] ? 1 : 0) << shift--;
}
return l;
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
