复习笔记2 变量 类型转换 自动升位

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;
	}
}