【Java】-NO.16.EBook.4.Java.1.002-【疯狂Java讲义第3版 李刚】- 数据类型

1.0.0 Summary

Tittle：【Java】-NO.16.EBook.4.Java.1.002-【疯狂Java讲义第3版 李刚】- 数据类型

Style：EBook

Series：Java

Since：2017-09-01

End：....

Total Hours：...

Degree Of Diffculty：2

Degree Of Mastery：2

Practical Level：2

Desired Goal：2

Archieve Goal：....

Gerneral Evaluation：...

Writer:kingdelee

Related Links：

http://www.cnblogs.com/kingdelee/

1.基本数据类型

double：占8字节，64位

float：占4字节，32位

需要精确保存浮点类型，应该使用BigDecimal

1字节：即8位

浮点型

float af = 5.2345556f;
		// 下面将看到af的值已经发生了改变
		System.out.println(af);
		double a = 0.0;
		double c = Double.NEGATIVE_INFINITY;
		float d = Float.NEGATIVE_INFINITY;
		// 看到float和double的负无穷大是相等的。
		System.out.println(c == d);
		// 0.0除以0.0将出现非数
		System.out.println(a / a);
		// 两个非数之间是不相等的
		System.out.println(a / a == Float.NaN);
		// 所有正无穷大都是相等的
		System.out.println(6.0 / 0 == 555.0/0);
		// 负数除以0.0得到负无穷大
		System.out.println(-8 / a);
		// 下面代码将抛出除以0的异常
		// System.out.println(0 / 0);

5.2345557
true
NaN
false
true
-Infinity

　

类型转换：

String 字符串类型：

当第一次使用某个字符串字面量时，jvm会使用常量池缓存字符串字面量。之后每次使用都直接使用常量池的字面量。

除法： /

一般除数不能为0. 例外情况：当 有一方是浮点数时，结果也是浮点数，即除数是0 则为正/负 无穷大。

public static void main(String[] args)
	{
		double a = 5.2;
		double b = 3.1;
		double div = a / b;
		// div的值将是1.6774193548387097
		System.out.println(div);
		// 输出正无穷大：Infinity
		System.out.println("5除以0.0的结果是:" + 5 / 0.0);
		// 输出负无穷大：-Infinity
		System.out.println("-5除以0.0的结果是:" + - 5 / 0.0);
		// 下面代码将出现异常
		// java.lang.ArithmeticException: / by zero
		System.out.println("-5除以0的结果是::" + -5 / 0);
	}

　　

取余： %

1.两边都是整数，对0取余会抛异常；除数为0，余数为0

2.有一边为浮点数，对0取余结果为非数NaN；除数不为0时，输出0.0

 public static void main(String[] args)
	{
		double a = 5.2;
		double b = 3.1;
		double mod = a % b;
 
		System.out.println(mod); // mod的值为2.1
		System.out.println("5对0.0求余的结果是:" + 5 % 0.0); // 输出非数:NaN
		System.out.println("-5.0对0求余的结果是:" + -5.0 % 0); // 输出非数:NaN
		System.out.println("0对5.0求余的结果是:" + 0 % 5.0); // 输出0.0
		System.out.println("0对0.0求余的结果是:" + 0 % 0.0); // 输出非数:NaN
		System.out.println("0对5求余的结果是:" + 0 % 5); // 0
		// 下面代码将出现异常：java.lang.ArithmeticException: / by zero
		System.out.println("-5对0求余的结果是:" + -5 % 0);
	}

　　

简单算术：

	public static void main(String[] args)
	{
		double a = 3.2; // 定义变量a为3.2
		// 求a的5次方，并将计算结果赋为b。
		double b = Math.pow(a , 5);
		System.out.println(b); // 输出b的值。
		// 求a的平方根，并将结果赋给c
		double c = Math.sqrt(a);
		System.out.println(c); // 输出c的值。
		// 计算随机数,返回一个0～1之间的伪随机数。
		double d = Math.random();
		System.out.println(d); // 输出随机数d的值
		// 求1.57的sin函数值：1.57被当成弧度数
		double e = Math.sin(1.57);
		System.out.println(e); // 输出接近1
	}

赋值运算符　　

    public static void main(String[] args)
	{
		// 定义一个byte类型的变量
		byte a = 5;
		// 下面语句出错，因为5默认是int类型，a + 5就是int类型。
		// 把int类型赋给byte类型的变量，所以出错，编译时出错
//		 a = a + 5;
		// 定义一个byte类型的变量
		byte b = 5;
		// 下面语句不会出现错误
		b += 5;
	}

　　

　

Byte：

Short：

Character：

Integer：

/**
     * Cache to support the object identity semantics of autoboxing for values between
     * -128 and 127 (inclusive) as required by JLS.
     *
     * The cache is initialized on first usage.  The size of the cache
     * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
     * During VM initialization, java.lang.Integer.IntegerCache.high property
     * may be set and saved in the private system properties in the
     * sun.misc.VM class.
     */

　　

Long：

Float和Double都没有cache

package com.lee.test.java.ebook.crazy_java.u_6_oop_2;
 
/**
 * Description:
 * <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
 * <br/>Copyright (C), 2001-2016, Yeeku.H.Lee
 * <br/>This program is protected by copyright laws.
 * <br/>Program Name:
 * <br/>Date:
 *
 * @author Yeeku.H.Lee kongyeeku@163.com
 * @version 1.0
 */
public class WrapperClassCompare {
    public static void main(String[] args) {
        Integer a = new Integer(6);
        // 输出true
        System.out.println("6的包装类实例是否大于5.0" + (a > 5.0));
        System.out.println("比较2个包装类的实例是否相等："
                + (new Integer(2) == new Integer(2))); // 输出false
        System.out.println(new Integer(2).equals(new Integer(2)));
        // 通过自动装箱，允许把基本类型值赋值给包装类的实例
        Integer ina = 2;
        Integer inb = 2;
        System.out.println("两个2自动装箱后是否相等：" + (ina == inb)); // 输出true
        Integer biga = 128;
        Integer bigb = 128;
        System.out.println("两个128自动装箱后是否相等：" + (biga == bigb)); // 输出false
        System.out.println("两个128自动装箱后是否equals：" + biga.equals(bigb)); // 输出true
 
        Integer a1 = new Integer(1);
        Integer a2 = new Integer(1);
 
        System.out.println(a1.equals(a2));
        System.out.println(a1 == a2);
 
        System.out.println("---------String----------");
 
        String str1 = "1";
        String str2 = "1";
        String str3 = new String("2");
        String str4 = new String("2");
        String str5 = "1" + str1;
        String str6 = "11";
        String str7 = new String("11");
        // 弱
        System.out.println("两个字符串字面量内容比较：" + "1".equals("1"));
        // 弱
        System.out.println("两个字符串字面量对象对象：" + "1" == "1");
        System.out.println("两个字符串字面量内容比较：" + str1.equals(str2));
        System.out.println("两个字符串字面量对象比较：" + str1 == str2);
        System.out.println("两个字符串字面量内容比较：" + str3.equals(str4));
        System.out.println("两个字符串字面量对象比较：" + str3 == str4);
        System.out.println("拼接的字符串比较1：" + str5.equals(str6));
        System.out.println("拼接的字符串比较：" + str5 == str6);
        System.out.println("拼接的字符串比较：" + str6 == str7);
 
        System.out.println("---------Integer----------");
 
        Integer int1 = 1;
        Integer int2 = 1;
        Integer int3 = new Integer(1);
        Integer int4 = new Integer(1);
        Integer int5 = 128;
        Integer int6 = 128;
 
        // 弱
//        System.out.println(1 == 1);
        System.out.println("两个字符串字面量内容比较：" + int1.equals(int2));
        System.out.println("两个字符串字面量对象比较：" + (int1 == int2));
        System.out.println("两个字符串字面量内容比较：" + int3.equals(int4));
        System.out.println("两个字符串字面量对象比较：" + (int3 == int4));
        System.out.println("两个字符串字面量内容比较：" + int5.equals(int6));
        System.out.println("两个字符串字面量对象比较：" + (int5 == int6));
 
        Byte b3 = new Byte("1");
        System.out.println(b3);
        Byte b4 = new Byte("11");
        System.out.println(b4);
        // Byte [-128, 127] 即 2^7，
        Byte b5 = new Byte("127");
//        System.out.println(1 << 7 - 1);
        System.out.println(b5);
        // Short [-32768, 32767] 2^15
//        System.out.println((1 << 15) - 1);
 
        Short s1 = 128;
        Short s2 = 128;
        Short s3 = 127;
        Short s4 = 127;
        System.out.println(s1 == s2); // true
        System.out.println(s3 == s4); // false
 
        Long l1 = 128l;
        Long l2 = 128l;
        Long l3 = 127l;
        Long l4 = 127l;
        System.out.println(l1 == l2); // false
        System.out.println(l3 == l4); // true
 
        System.out.println("-------String---------");
 
    }
}

　

    public static void main(String[] args) {
 
        // 常量池：
        //      管理编译时的被确定并保存到.class的数据（常量）。
 
        // 1.字符串常量池
        //  管理在编译时计算出来的值。如String s1 = "a"
        // 2. new String("a")，先使用常量池管理"a"，再在堆内存保存构建的"a"对象，即共有两个对象
        // 3. .intern()可以值复制到常量池中并返回对应的地址，如果已经存在则返回已存在的地址
 
        String s1 = "a";
        String s2 = "a";
        String s3 = new String("a");
        String s4 = new String("a");
 
        System.out.println("#1:" + (s1 == s2));   // T 两个都是常量池中的值，其地址一样
        System.out.println("#2:" + (s1 == s3));   // F 前者是常量池，后者是堆内存中的，地址肯定不一样
        System.out.println("#3:" + (s3 == s4));   // F new 出来的是堆内存中不一样的两个对象，尽管构造函数将其对象的值是一样的，但地址不一样
 
        String intern = s3.intern();
        String intern1 = s4.intern();
        System.out.println("#4:" + (s2 == intern)); // T intern返回了常量池中的相同值的地址
        System.out.println("#5:" + (s3 == intern)); // F s3依旧是堆内存的地址，intern是常量池的地址
        System.out.println("#6:" + (intern1 == intern)); //T 都是常量池的地址
 
    }
 
    @Test
    public void t1() {
 
        // 2.普通变量
        // 根据字符串常量的定义，必须是编译时确定下来的。 String t4 = "a" + "b"; 这种有 计算的非final的是无法在编译时就确定的。
 
        String t1 = "a";
        String t2 = "b";
        String t1_t2 = t1 + t2;
        String t3 = "ab";
        String t4 = "a" + "b";
        String t5 = "ab";
 
        System.out.println("#1:" + (t3 == t1_t2));  // F
        System.out.println("#2:" + (t4 == t1_t2));  // F
        System.out.println("#3:" + (t4 == t5));  // T
    }
 
    @Test
    public void t2() {
 
        // 2.宏变量
        //  使用final修饰的变量可以转化为宏变量，即在编译的时候就能够确下来并保存到常量池中。
 
        final String t1 = "a";
        final String t2 = "b";
        final String t1_t2 = t1 + t2;
        final String t3 = "ab";
        final String t4 = "a" + "b";
 
        System.out.println("#1:" + (t3 == t1_t2));  // T 都能够在编译的过程中确定下来
        System.out.println("#2:" + (t4 == t1_t2));  // T 都能够在编译的过程中确定下来
    }