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