【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 都能够在编译的过程中确定下来

    }

巴特西

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

最新文章

热门文章

巴特西

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

最新文章

热门文章

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