Java 基本数据类型 及 == 与 equals 方法的区别

基本数据类型

byte：Java中最小的数据类型，在内存中占1个字节(8 bit)，取值范围-128~127，默认值0
short：短整型，2个字节(16 bit)，取值范围-32768~32717，默认值0
int：整型，用于存储整数，在内存中占4个字节，取值范围-2147483648~2147483647，默认值0
long：长整型，在内存中占8个字节-2^63~263-1，默认值0L

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

char：字符型，用于存储单个字符，内存中占2个字节，取值范围0~65535，默认值为空
boolean：布尔类型，占1个字节，用于判断真或假（仅有两个值，即true、false），默认值false

引用类型

Java语言本身不支持C++中的结构（struct）或联合（union）数据类型，它的复合数据类型一般都是通过类或接口进行构造，类提供了捆绑数据和方法的方式，同时可以针对程序外部进行信息隐藏。引用类型分3种：类，接口，数组；

类(Class)：所有的类，无论是Java自身已经存在的，还是用户后来创建的；
Objec类：它是所有类的父类，每个类都实现这个类的方法；用Object 可以定义所有的类；
String：String类代表字符串，Java
接口(interface): 系统自带或者用户创建的
数组(array): 系统自带或者用户创建的

Java中的数据类型在内存的存储原理

Java的数据类型存储原理要根据其为局部变量还是成员变量来区分，局部变量与成员变量根据定义变量的位置区分：
局部变量：方法中的变量；
成员变量：类中方法外；

局部变量数据类型存储原理：
(1) 基本数据类型的存储原理：所有的简单数据类型不存在“引用”的概念，基本数据类型都是直接存储在内存中的内存栈上的，数据本身的值就是存储在栈空间里面，Java语言里面八种数据类型是这种存储模型；
(2) 引用类型的存储原理：引用类型继承于Object类（也是引用类型）都是按照Java里面存储对象的内存模型来进行数据存储的，使用Java内存堆和内存栈来进行这种类型的数据存储，简单地讲，“引用”(存储对象在内存堆上的地址)是存储在有序的内存栈上的，而对象本身的值存储在内存堆上的；

基本数据类型和引用类型的区别主要在于基本数据类型是分配在栈上的，而引用类型是分配在堆上的
举例说明

分析一下 == 和equals()的区别

String[] a={"latiny1","latiny2"};
String[] b={"latiny1","latiny2"};
if(a==b){
System.out.println("a==b");
}else{
System.out.println("a!=b");
}

程序输出a!=b
原因：a和b的地址是不相同的，a==b比较的是两个变量的地址，数据a与b的地址不一样

对于局部变量来说，不论是基本数据类型还是引用类型，他们都会先在栈中分配一块内存，对于基本类型来说，这块区域包含的是基本类型的内容；而对于引用类型来说，这块区域包含的是指向真正内容的指针，真正的内容被手动的分配在堆上。

对于成员变量来说，不论是基本数据类型还是引用类型，他们都会存储在堆内存或者方法区中；成员变量可细分为静态成员变量和普通成员变量，静态成员变量类属于类，类可以直接访问，存储在方法区中；普通成员变量属于类对象，必须声明对象之后，通过对象才能访问，存储在堆中。

基本类型转换

(1)自动类型转换
Java所有的数值类型变量都可以互相转换，如果系统把某种基本类型的值直接赋给另一种基本类型的变量，则这种方式被称为自动类型转换。

int e = 1;
double d =e;

以上代码不会报错，系统会自动转换。

(2) 强制类型转换
当把一个范围大的数值或变量赋给另一个范围小的变量时，需要进行强制转换。

double d =1.5;
int e = d;

以上代码会报错，把大范围的数值赋给小范围的变量，需要强制转换，这样才能通过编译，且大范围的数值会丢失精度。
int e = (int) d;

== 与 equals 方法
判断两个变量是否相等有两种方式：一种是利用 == 运算符，另一种是利用equals方法。
① 比较java基本类型：
比较基本类型只能用"“，不能用"equals”，这里的""比较的是两个基本类型的值；
② 比较包装类：

Character a = new Character('A');
Character b = new Character('A');

System.out.println(a == b);
System.out.println(a.equals(b));

Integer i1 = new Integer(10);
Integer i2 = new Integer(10);

System.out.println(i1 == i2);
System.out.println(i1.equals(i2));

输出结果：　
false
true
false
true

这边"=="比较的是对象的内存地址，new了两个不同的对象所存放的地址是不一样的，这边的"equals"比较的就是值，这里为什么比较的是值呢，equals里的重写了equals的方法。附上源码：

public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
}

③ 比较String："=="比较的是内存地址，"equals"比较的是值

String s1 = "latiny";
String s2 = "latiny";

System.out.println(s1 == s2);
System.out.println(s1.equals(s2));

String s3 = new String("latiny");
String s4 = new String("latiny");

System.out.println(s3 == s4);
System.out.println(s3.equals(s4));

输出结果：

true
true
false
true

Java String 和 new String()的区别

栈区存引用和基本类型，不能存对象，而堆区存对象。==是比较地址，equals()比较对象内容。

(1) String str1 = “abcd"的实现过程：首先栈区创建str引用，然后在String池（独立于栈和堆而存在，存储不可变量）中寻找其指向的内容为"abcd"的对象，如果String池中没有，则创建一个，然后str指向String池中的对象，如果有，则直接将str1指向"abcd”“；如果后来又定义了字符串变量 str2 = “abcd”,则直接将str2引用指向String池中已经存在的“abcd”，不再重新创建对象；当str1进行了赋值（str1=“abc”），则str1将不再指向"abcd”，而是重新指String池中的"abc"，此时如果定义String str3 = “abc”,进行str1 == str3操作，返回值为true，因为他们的值一样，地址一样，但是如果内容为"abc"的str1进行了字符串的+连接str1 = str1+“d”；此时str1指向的是在堆中新建的内容为"abcd"的对象，即此时进行str1==str2，返回值false，因为地址不一样。

(2) String str3 = new String(“abcd”)的实现过程：直接在堆中创建对象。如果后来又有String str4 = new String(“abcd”)，str4不会指向之前的对象，而是重新创建一个对象并指向它，所以如果此时进行str3==str4返回值是false，因为两个对象的地址不一样，如果是str3.equals(str4)，返回true,因为内容相同。

④ 比较对象：
这里"=="比较的是内存地址，"equals"比较的也是地址，没有重写equals方法的类都是调用的Object的equals的方法。

Person p1 = new Person(1001, "latiny1");
Person p2 = new Person(1001, "latiny1");
         
System.out.println(p1 == p2);
System.out.println(p1.equals(p2));

输出结果：

false
false