Java 基本类型、封装类型、常量池、基本运算

基本数据类型：

byte：Java中最小的数据类型，在内存中占8位(bit)，即1个字节，取值范围-128~127，默认值0

short：短整型，在内存中占16位，即2个字节，取值范围-32768~32717，默认值0

int：整型，用于存储整数，在内在中占32位，即4个字节，取值范围-2147483648~2147483647，默认值0

long：长整型，在内存中占64位，即8个字节-2^63~2^63-1，默认值0L

float：浮点型，在内存中占32位，即4个字节，用于存储带小数点的数字（与double的区别在于float类型有效小数点只有6~7位），默认值0

double：双精度浮点型，用于存储带有小数点的数字，在内存中占64位，即8个字节，默认值0

char：字符型，用于存储单个字符，占16位，即2个字节，取值范围0~65535，默认值为空

boolean：布尔类型，占1个字节，用于判断真或假（仅有两个值，即true、false），默认值false

封装类型：Byte、Short、Integer、Long、Float、Double、Character、Boolean

1.基本类型定义出来是普通变量，在栈中开辟内存，值是多少栈中就是多少。

2.除了单个基本数据类型，其他都是引用类型，数组（包括基本类型数组）、类等。

定义的时候，执行到“=”号都是在栈中；new之后就在堆中，栈里的内容类似指针但不是地址，指向堆，堆中的内容才是数值，堆自己也有一个地址。

3.封装类型在定义的时候需要赋值

        int a;//基本类型可以不初始化
        Integer b=new Integer(15);//封装类型需要初始化
        double c1;
        Double c2=new Double(11);

常量池：在堆中，可以理解成缓存数据，以后有需要的时候直接拿，不需要重新开内存。有缓存池的类是String，全开的。基本类型的封装类中，除了Double、Long、Float没有实现这个技术，其他都有缓存池，但是缓存池容纳的数据只有一个字节，即-128 - 127，超过这个范围就需要创建对象。

整型：为了避免多次创建对象，我们事先就创建好一个大小为256的Integer数组SMALL_VALUES，所以如果值在这个范围内，就可以直接返回我们事先创建好的对象就可以了。

浮点型：因为在范围内有很多小数，所以没有常量池。

装箱就是自动将基本数据类型转换为封装类型；拆箱就是自动将封装类型转换为基本数据类型。

基本运算

1.一条表达式混有多种类型，最后取最高的级别的类型

2.char类型的数据转换为高级类型（int，long等），会转换为其对应的ASCII码

3.使用+=时，不会产生类型转换

        char x='A';
        int p=3,z=x;
        System.out.println(x+" "+p+" "+z);//A 3 65
        x+=p;
        System.out.println(x+" "+p+" "+z);//D 3 65

char和+=

4.强制转化，高精度变为低精度，会损失精度

5.“==”比较的是内存地址，“equals”比较的内容，两个内容相同的对象用“==”比较是不同的，因为内存地址不同；用“equals”比较则是相同的。对于封装类型，还要考虑是否有常量池数据，如果内容在常量池有，则没有创建新的对象，如果有new则明确创建了新的对象。

6.如果基本类型和封装类型进行+、-、×、÷、==的基本运算，是自动拆箱，对基础数据类型进行运算。

7.如果基本类型和封装类型用equals比较，是自动装箱，比较值。

String是实现常量池技术的类，用“==”测试比较

package my_acm;

import java.util.ArrayList;

public class MyTest6 {
    public static void main(String []args) {
        String s0="ab";
        String s1="ab";
        String s2="cd";
        String s3="a"+"b";
        String s4=new String("ab");
        String s5=new String("cd");
        String s6="abcd";
        String s7=s1+s2;
        String s8=s4+s5;
        String s9=s6.intern();
        //这个方法首先在常量池中查找是否存在一份equal相等的字符串如果有的话就返回该字符串的引用，没有的话就将它加入到字符串常量池中
        String s10=new String("abcd");
        System.out.println("s0 "+s0.hashCode()+" "+System.identityHashCode(s0));//3015    366712642
        System.out.println("s1 "+s1.hashCode()+" "+System.identityHashCode(s1));//3105    366712642
        System.out.println("s2 "+s2.hashCode()+" "+System.identityHashCode(s2));//3169    1829164700
        System.out.println("s3 "+s3.hashCode()+" "+System.identityHashCode(s3));//3105    366712642
        System.out.println("s4 "+s4.hashCode()+" "+System.identityHashCode(s4));//3105    2018699554
        System.out.println("s5 "+s5.hashCode()+" "+System.identityHashCode(s5));//3169    1311053135
        System.out.println("s6 "+s6.hashCode()+" "+System.identityHashCode(s6));//2987074 118352462
        System.out.println("s7 "+s7.hashCode()+" "+System.identityHashCode(s7));//2987074 1550089733
        System.out.println("s8 "+s8.hashCode()+" "+System.identityHashCode(s8));//2987074 865113938
        System.out.println("s9 "+s9.hashCode()+" "+System.identityHashCode(s9));//2987074 118352462
        System.out.println("s10 "+s10.hashCode()+" "+System.identityHashCode(s10));//2987074 1442407170
        //理解成：System.identityHashCode(s0)方法返回的是内存地址，用于下面的==比较
        System.out.println(s0 == s1);//t
        System.out.println(s1 == s3);//t  常量池里自动拼接，相当于常量池里有ab、cd、abcd这3个常量
        System.out.println(s1 == s4);//f
        System.out.println(s6 == s7);//f
        //在JAVA9中，因为用的是动态调用，所以返回的是一个新的String对象。所以s6和s7，s8，s10 不是同一块堆内存
        System.out.println(s6 == s10);//f
        System.out.println(s7 == s8);//f
        System.out.println(s6 == s9);//t intern()方法使得s9的引用和s6一样
        System.out.println(s8 == s10);//f
    }
}

牛客刷题：

1.%取余运算

y=-12；x=-5；y%x=-2；

被除数=商*除数+余数 -12=2*(-5)+(-2);

减法 -12-(-5)-(-5)=-2;

2.无变量混合运算

小数都默认为double型

System.out.println(100%3);//1

System.out.println(100%3.0);//1.0 虚拟机对100转型为100.0的double类型，结果自然是1.0