计算机基础知识——Java01

一、八种基本数据类型的大小，以及他们的封装类

整数+字符串=字符串

 

1、包装类是对象，拥有方法和字段，对象的调用都是通过引用对象的地址，基本类型不是
2、包装类型是引用的传递，基本类型是值的传递
3、声明方式不同，基本数据类型不需要new关键字，而包装类型需要new在堆内存中进行new来分配内存空间
4、存储位置不同，基本数据类型直接将值保存在值栈中，而包装类型是把对象放在堆中，然后通过对象的引用来调用他们
5、初始值不同，eg： int的初始值为 0 、 boolean的初始值为false 而包装类型的初始值为null
6、使用方式不同，基本数据类型直接赋值使用就好 ，而包装类型是在集合如 coolection Map时会使用

 

 

装箱与拆箱：

Integer x=1    此处用到了装箱，是基底层是：Integer x=Integer.valueOf(1); 

Int y=x             此处用到了拆箱

 

当值在-128至127之间时，

Integer a=100

Integer b=100    此处用到了装箱，是基底层是：Integer b=Integer.valueOf(100); 

这时 ，a==b的值是true，这数是从缓存拿的。超过这个范围的话，则是false，这时a,b都是new 出来的Integer对象

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

 

 

关于最大最小值

      System.out.println(Integer.MAX_VALUE);        //2147483647
        System.out.println(Integer.MIN_VALUE);      //-2147483648
        System.out.println(Integer.MAX_VALUE+1);     //-2147483648
        System.out.println(Integer.MIN_VALUE-1);        //2147483647

神奇
 

 

写的特别好的一篇文章，直接看这里吧

https://blog.csdn.net/qing_gee/article/details/101670051?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task

还有这个

https://www.cnblogs.com/lchzls/p/6709655.html

二、equal、==区别

 

1、初步了解在JVM中的内存分配知识
        在JVM中，内存分为堆内存跟栈内存。他们二者的区别是： 当我们创建一个对象（new Object）时，就会调用对象的构造函数来开辟空间，将对象数据存储到堆内存中，与此同时在栈内存中生成对应的引用，当我们在后续代码中调用的时候用的都是栈内存中的引用。还需注意的一点，基本数据类型是存储在栈内存中。

2、equal、==区别

     如果一个类没有自己定义equals方法，它默认的equals方法（从Object 类继承的）就是使用==操作符，

 public boolean equals(Object obj) {
        return (this == obj);
    }

也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须覆盖equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。

总结的：

　　  1）对于==

              如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；

　　　　如果作用于引用类型的变量，则比较的是所指向的对象的地址

　　2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量，

               equals继承Object类，比较的是地址

　　　　如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；

　　　　诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。
 

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class t1 {
    public static void main(String[] args) {
        //-128至127
        Integer a1=100;
        Integer aa=100;

     
        System.out.println(a1==aa);             //true 在-128到127之间，直接从IntegerCache中拿的
        int a2=100;
        Integer a3=new Integer(100);
        Integer a4=new Integer(100);


        //好像因为==对于基础数据比较的是值是否相等
        System.out.println(a1==a2);           //true
        System.out.println(a3==a2);          //true

        System.out.println(a1==a3);           //false
        System.out.println(a3==a4);           //false


        System.out.println(a3.equals(a4));  //true   Integer类重写了equal
        System.out.println("+++++++++++++++");
        
        
         //大于127
        Integer b1=300;
        Integer bb=300;
        System.out.println(bb==b1);              //false   超过范围，是new了对象给b1、bb
    //    System.out.println(b1.equals(bb));       //true
        int b2=300;
        Integer b3=new Integer(300);
        Integer b4=new Integer(300);

        //好像因为==对于基础数据比较的是值是否相等
        System.out.println(b1==b2);           //true
        System.out.println(b3==b2);         //true


        System.out.println(b1==b3);           //false
        System.out.println(b3==b4);         //false

        System.out.println(b3.equals(b4));  //true        Integer类重写了equal

        List<Integer> l1 = new ArrayList<Integer>(3);
        l1.add(1);
        List<Integer> l2 = new ArrayList<Integer>(3);
        l2.add(1);

        System.out.println(l1==l2);           //false
        System.out.println(l1.equals(l2));   //true       这里不明白，好像并没有重写equal方法，为什么还会比较值难道重写了？？


        System.out.println("______________");
        String x="hello";
        String y="hello";
        String z=new String("hello");
        String z2=new String("hello");
        System.out.println(x==y);            //true
        System.out.println(x==z);           //false
        System.out.println(z==(z2));        //false




        String n1=new String("bye");
        String n2="bye";
        System.out.println(n1==n2);       //false

        System.out.println(x.equals(y));    //true
        System.out.println(x.equals(z));    //true
        System.out.println(z.equals(z2));   //true     string重写了equal方法
        System.out.println("**********");
        System.out.println(Integer.MAX_VALUE);   //2147483647
        System.out.println(Integer.MIN_VALUE);      //-2147483648
        System.out.println(Integer.MAX_VALUE+1);     //-2147483648
        System.out.println(Integer.MIN_VALUE-1);        //2147483647

    }
}

关于x==z为什么是false:

当new一个String对象的时候，会先去String池中先找有没有相同的字符串，如果有，那么就会生成一个对象指向这个字符串，但是后面运行到new的时候，不管String中有没有该字符串，都会直接生成一个对象，然后返回该对象指针所指地址的字符串，也就是生成了一个或两个对象，而我们所比较的那个对象，正好就是new的时候返回的那个，也就是地址是不相同的;

当你new完对象，并将该对象赋值到其他的对象的时候，其实z指向的是堆中的字符串，而不是String池中的字符串;