Java基础(一)

作者: isuntong | 来源:发表于2020-01-12 10:22 被阅读0次

final、finally、finallize的区别；
int和Integer的区别；
数据类型；
数据类型内存。

final, finally, finalize 的区别

final

用于声明属性,方法和类, 分别表示属性不可变, 方法不可覆盖, 类不可继承.

finally

是异常处理语句结构的一部分，表示总是执行.

finalize

是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等. JVM不保证此方法总被调用.

int 和 Integer 有什么区别

int 是 Java 提供的 8 种原始数据类型之一。Java 为每个原始类型提供了封装类，Integer 是 Java 为 int 提供的封装类。 int 的默认值为 0，而 Integer 的默认值为 null，是引用类型，即 Integer 可以区分出未赋值和值为 0 的区别，int 则无法表达出未赋值的情况， Java 中 int 和 Integer 关系是比较微妙的。关系如下：

int 是基本的数据类型；
Integer 是 int 的封装类；
int 和 Integer 都可以表示某一个数值；
int 和 Integer 不能够互用，因为他们两种不同的数据类型；

补充：

Java 基本数据类型

变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。

内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。

因此，通过定义不同类型的变量，可以在内存中储存整数、小数或者字符。

Java 的两大数据类型:

内置数据类型
引用数据类型

内置数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

byte：

byte 数据类型是8位、有符号的，以二进制补码表示的整数；
最小值是 -128（-2^7）；
最大值是 127（2^7-1）；
默认值是 0；
byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
例子：byte a = 100，byte b = -50。

short：

short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15）；
最大值是 32767（2^15 - 1）；
Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
默认值是 0；
例子：short s = 1000，short r = -20000。

int：

int 数据类型是32位、有符号的以二进制补码表示的整数；
最小值是 -2,147,483,648（-2^31）；
最大值是 2,147,483,647（2^31 - 1）；
一般地整型变量默认为 int 类型；
默认值是 0 ；
例子：int a = 100000, int b = -200000。

long：

long 数据类型是 64 位、有符号的以二进制补码表示的整数；
最小值是 -9,223,372,036,854,775,808（-2^63）；
最大值是 9,223,372,036,854,775,807（2^63 -1）；
这种类型主要使用在需要比较大整数的系统上；
默认值是 0L；
例子： long a = 100000L，Long b = -200000L。
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

注意：

不加L默认是int，int转为long是安全的，所以会自动转，能编译通过，当值超过int范围时报错
浮点数不加F默认是double类型，double转float可能损失精度，因为不会自动转，编译是通不过的

double：

double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
浮点数的默认类型为double类型；
double类型同样不能表示精确的值，如货币；
默认值是 0.0d；
例子：double d1 = 123.4。

补充：

public static void main(String[] args) {
        double d1 = 1.1D;
           double d2 = 2.2D;
           double d3 = d1+d2;
           System.out.println("d1+d2=    "+d3);

           BigDecimal b1 = new BigDecimal(d1);
           BigDecimal b2 = new BigDecimal(d2);
           BigDecimal b3 = b1.add(b2);
           System.out.println("b1.add(b2)=    "+b3);

           BigDecimal b4 = new BigDecimal(String.valueOf(d1));
           BigDecimal b5 = new BigDecimal(String.valueOf(d2));
           BigDecimal b6 = b4.add(b5);
           System.out.println("b4.add(b5)=    "+b6);
    }

用字符串类型作为BgDecimal构造器参数计算的数据是对的，而double类型作为BgDecimal构造器参数依旧是不对的。

boolean：

boolean数据类型表示一位的信息；
只有两个取值：true 和 false；
这种类型只作为一种标志来记录 true/false 情况；
默认值是 false；
例子：boolean one = true。

char：

char类型是一个单一的 16 位 Unicode 字符；
最小值是 \u0000（即为0）；
最大值是 \uffff（即为65,535）；
char 数据类型可以储存任何字符；
例子：char letter = 'A';。

区分连接符与加号

结果：先输出字符串则后面也是字符串形式；先输出加法运算则正常运算。

原因：在System.out.println()中，如果在string字符串后面是+和变量，会把变量转换成string类型，加号起连接作用，然后把两个字符串连接成一个新的字符串输出；

如果先有变量的加减运算再有字符串，那么会从左到右先计算变量的加减，然后再与后面的string结合成一个新的字符串。也就是说加号只有在两个 string类型或者其中一个是string类型的时候才起到连接作用，否则仍然是运算符。

补充：大数类型

BigInteger可以进行进制转换

String temp = "16";
String s  = new BigInteger(temp,10).toString(13);
System.out.println(s);

BigDecimal可以设置保留小数谓数和四舍五入规则，double和float的精度问题由于二级制存储的原因。

Long类型坑：

当是-128到127的时候是在Long的一个静态内部类的缓存中来取值的，不在的时候才会重新new Long（）

    private static class LongCache {
        private LongCache(){}

        static final Long cache[] = new Long[-(-128) + 127 + 1];

        static {
            for(int i = 0; i < cache.length; i++)
                cache[i] = new Long(i - 128);
        }
    }

其实静态内部类维护了一个cache 的-128到127 的数组的数据。
看到这里大概机会明白为啥== 在数据小的时候比较是对的，当超过数值的时候比较就会在我们的预料之外，其实Long、Internet等等包装类型其实也是一个类。在比较值的时候建议使用equals

类型默认值

引用类型

在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。

对象、数组都是引用数据类型。
所有引用类型的默认值都是null。
一个引用变量可以用来引用任何与之兼容的类型。
例子：Site site = new Site("Runoob")。

Java 常量

常量在程序运行时是不能被修改的。

在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：

final double PI = 3.1415927;

虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。

字面量可以赋给任何内置类型的变量。例如：

byte a = 68;
char a = 'A'

byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。

当使用常量的时候，前缀 0 表示 8 进制，而前
缀 0x 代表 16 进制, 例如：

int decimal = 100;
int octal = 0144;
int hexa =  0x64;

和其他语言一样，Java的字符串常量也是包含在两个引号之间的字符序列。下面是字符串型字面量的例子：

"Hello World"
"two\nlines"
"\"This is in quotes\""

字符串常量和字符常量都可以包含任何Unicode字符。例如：

char a = '\u0001';
String a = "\u0001";

Java语言支持一些特殊的转义字符序列。

自动类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。
转换从低级到高级。

低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double

数据类型转换必须满足如下规则：

不能对boolean类型进行类型转换。
不能把对象类型转换成不相关类的对象。
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
转换过程中可能导致溢出或损失精度，例如：

int i =128;   
byte b = (byte)i;

隐含强制类型转换

整数的默认类型是 int。
浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或者 f。

Java数据类型和不同数据类型在JVM内存分配

1.java数据类型分类

Java语言是强类型（Strongly typed）语言，强类型包含两方面的含义：①所有的变量必须先声明，后使用；②指定类型的变量只能接受类型与之匹配的值。这意味着每个变量和每个表达式都有一个在编译时就确定的类型。

Java语言支持的类型有两类：基本类型(Primitive Type)和引用类型(Reference Type)。基本类型包括boolean类型和数值类型。数值类型有整数类型和浮点类型。整数类型包括byte、short、int、long、char，浮点类型包括float和double。引用类型包括类，接口和数组类型，还有一种特殊的null类型。所谓引用类型就是对一个对象的引用，对象包括实例和数组两种。实际上引用类型变量就是一个指针，只是java语言不在使用指针这个说法。空类型(null type)就是null值的类型，这种类型没有名称，所以不可能声明一个null类型的变量或者转换到null类型。空引用(null)是null类型变量唯一的值。空引用可以转换为任何引用类型。在实际开发中，程序员可以忽略null类型，假定null只是引用类型的一个特殊直接量。（注：空引用null只能被转换为引用类型，不能转换为基本类型，因此不要把null赋给一个基本类型的变量）

声明变量的语法：type varName[=初始值]；

2.java不同数据类型在JVM中内存的存放位置

变量在JVM中内存的分配主要取决于变量的作用范围与变量的数据类型。

基本数据类型是放在栈中还是放在堆中，这取决于基本类型在何处声明，下面对数据类型在内存中的存储问题来解释一下：

2.1.在方法中声明的变量，即该变量是局部变量，每当程序调用方法时，系统都会为该方法建立一个方法栈，其所在方法中声明的变量就放在方法栈中，当方法结束系统会释放方法栈，其对应在该方法中声明的变量随着栈的销毁而结束，这就局部变量只能在方法中有效的原因。在方法中声明的变量可以是基本类型的变量，也可以是引用类型的变量

（1）当声明是基本类型的变量的时，其变量名及值（变量名及值是两个概念）是放在JAVA虚拟机栈中

（2）当声明的是引用变量时，所声明的变量（该变量实际上是在方法中存储的是内存地址值）是放在JAVA虚拟机的栈中，该变量所指向的对象是放在堆类存中的。

2.2.在类中声明的变量是成员变量，也叫全局变量，放在堆中的（因为全局变量不会随着某个方法执行结束而销毁）。

同样在类中声明的变量即可是基本类型的变量也可是引用类型的变量

（1）当声明的是基本类型的变量其变量名及其值放在堆内存中的

（2）引用类型时，其声明的变量仍然会存储一个内存地址值，该内存地址值指向所引用的对象。引用变量名和对应的对象仍然存储在相应的堆中。

3.Java不同数据类型在JVM中何时分配内存

3.1.成员变量：

当系统加载类或创建类的实例时，系统会自动为成员变量分配内存空间，并在分配内存空间后自动为成员变量指定初始值。基本数据类型默认初始值是0，引用数据类型默认初始值是null。
3.2.局部变量：

局部变量定义后，必须经过显示初始化后才能使用。这意味着定义了局部变量后，系统并未为这个变量分配内存空间，直到等到程序为这个变量赋值初始值时，系统才会给局部变量分配内存，并将初始值保存在这块内存中。

与成员变量不同，局部变量不属于任何类或实例，因此它总是保存在其所在方法的栈内存中。如果局部变量时基本类型变量，则直接把变量值存在栈中，如果是引用类型，则存放地址在栈中。

栈内存中的变量无须系统垃圾回收，变量是随方法或代码块的运行结束而结束的。因此，局部变量的作用域是从初始化该变量开始，直到该方法或该代码块运行完成而结束。因为局部变量只保存基本类型的值或对象的引用，因此局部变量所占的内存通常较小。

当我们定义一个成员变量时，成员变量将被放置到堆内存中，成员变量的作用域将扩大到类存在范围或者对象存在范围。这种范围扩大有两个坏处：

①增大了变量的生存时间，将导致更大的系统开销

②扩大了作用域，不利于程序的内聚性。

Java堆和栈的区别和介绍以及JVM的堆和栈

一、Java的堆内存和栈内存

Java把内存划分成两种：一种是堆内存，一种是栈内存。

堆：主要用于存储实例化的对象，数组。由JVM动态分配内存空间。一个JVM只有一个堆内存，线程是可以共享数据的。

栈：主要用于存储局部变量和对象的引用变量，每个线程都会有一个独立的栈空间，所以线程之间是不共享数据的。

在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。

堆内存用来存放由new创建的对象和数组。

在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。

二、栈与堆的共同点和优缺点

栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。
栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据可以共享，详见第3点。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。
Java中的数据类型有两种。

一种是基本类型(primitive types), 共有8种，即int, short, long, byte, float, double, boolean, char(注意，并没有string的基本类型)。这种类型的定义是通过诸如int a = 3; long b = 255L;的形式来定义的，称为自动变量。值得注意的是，自动变量存的是字面值，不是类的实例，即不是类的引用，这里并没有类的存在。如int a = 3; 这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，由于大小可知，生存期可知(这些字面值固定定义在某个程序块里面，程序块退出后，字段值就消失了)，出于追求速度的原因，就存在于栈中。
栈有一个很重要的特殊性，就是存在栈中的数据可以共享。

假设我们同时定义
int a = 3; int b = 3；

编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处理int b = 3；在创建完b的引用变量后，由于在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的情况。
特别注意的是，这种字面值的引用与类对象的引用不同。假定两个类对象的引用同时指向一个对象，如果一个对象引用变量修改了这个对象的内部状态，那么另一个对象引用变量也即刻反映出这个变化。相反，通过字面值的引用来修改其值，不会导致另一个指向此字面值的引用的值也跟着改变的情况。如上例，我们定义完a与 b的值后，再令a=4；那么，b不会等于4，还是等于3。在编译器内部，遇到a=4；时，它就会重新搜索栈中是否有4的字面值，如果没有，重新开辟地址存放4的值；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。

另一种是包装类数据，如Integer, String, Double等将相应的基本数据类型包装起来的类。这些类数据全部存在于堆中，Java用new()语句来显式地告诉编译器，在运行时才根据需要动态创建，因此比较灵活，但缺点是要占用更多的时间。

三、Java堆和栈的区别

java中堆和栈的区别自然是面试中的常见问题，下面几点就是其具体的区别

1、各司其职
最主要的区别就是栈内存用来存储局部变量和方法调用。而堆内存用来存储Java中的对象。无论是成员变量，局部变量，还是类变量，它们指向的对象都存储在堆内存中。

2、独有还是共享
栈内存归属于单个线程，每个线程都会有一个栈内存，其存储的变量只能在其所属线程中可见，即栈内存可以理解成线程的私有内存。而堆内存中的对象对所有线程可见。堆内存中的对象可以被所有线程访问。

3、异常错误
如果栈内存没有可用的空间存储方法调用和局部变量，JVM会抛出java.lang.StackOverFlowError。
而如果是堆内存没有可用的空间存储生成的对象，JVM会抛出java.lang.OutOfMemoryError。

4、空间大小
栈的内存要远远小于堆内存，如果你使用递归的话，那么你的栈很快就会充满。如果递归没有及时跳出，很可能发生StackOverFlowError问题。
你可以通过-Xss选项设置栈内存的大小。-Xms选项可以设置堆的开始时的大小，-Xmx选项可以设置堆的最大值。

这就是Java中堆和栈的区别。理解好这个问题的话，可以对你解决开发中的问题，分析堆内存和栈内存使用，甚至性能调优都有帮助。

四、JVM中的堆和栈

JVM是基于堆栈的虚拟机.JVM为每个新创建的线程都分配一个堆栈.也就是说,对于一个Java程序来说，它的运行就是通过对堆栈的操作来完成的。堆栈以帧为单位保存线程的状态。JVM对堆栈只进行两种操作:以帧为单位的压栈和出栈操作。我们知道,某个线程正在执行的方法称为此线程的当前方法.我们可能不知道,当前方法使用的帧称为当前帧。当线程激活一个Java方法,JVM就会在线程的 Java堆栈里新压入一个帧。这个帧自然成为了当前帧.在此方法执行期间,这个帧将用来保存参数,局部变量,中间计算过程和其他数据.这个帧在这里和编译原理中的活动纪录的概念是差不多的. 从Java的这种分配机制来看,堆栈又可以这样理解:堆栈(Stack)是操作系统在建立某个进程时或者线程(在支持多线程的操作系统中是线程)为这个线程建立的存储区域，该区域具有先进后出的特性。

每一个Java应用都唯一对应一个JVM实例，每一个实例唯一对应一个堆。应用程序在运行中所创建的所有类实例或数组都放在这个堆中,并由应用所有的线程共享.跟C/C++不同，Java中分配堆内存是自动初始化的。Java中所有对象的存储空间都是在堆中分配的，但是这个对象的引用却是在堆栈中分配,也就是说在建立一个对象时从两个地方都分配内存，在堆中分配的内存实际建立这个对象，而在堆栈中分配的内存只是一个指向这个堆对象的指针(引用)而已。
Java 把内存划分成两种：一种是栈内存，另一种是堆内存。在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配，当在一段代码块定义一个变量时，Java 就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java 会自动释放掉为该变量分配的内存空间，该内存空间可以立即被另作它用。

==比较地址
equals比较值

String类型注意问题


 

public class StringTest {

    

    /**程序只创建一个字符串对象“Java”，存放在常量池中，所以s1==s2 为true

     * 

     */

    void test1(){

        String s1="Java";

        String s2="Java";

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

    }

    

    /** 第一个new String("Java"):创建了两个对象，Java创建于常量池中，String对象创建于堆内存中。

     * 第二个new String("Java"):由于常量池中有Java对象，所以只需创建一个对象，String对象创建于堆内存中。

     * s1与s2分别指向String对象堆内存，所以s1==s2 为false

     */

    void test2() {

        String s1=new String("Java");

        String s2= new String("Java");

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

    }

    

    /** 常量的值在编译的时候就确定了，"hello"、"world"都是常量，因此s2的值在编译的时候也确定了，

     * s2指向常量池中的"hello world",所以s1==s2为true

     * 

     */

    void test3() {

        String s1="hello world";

        String s2="hello "+"world";

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

    }

    

    /** s4由两个String变量相加得到，不能在编译时就确定下来，不能直接引用常量池中的"helloworld"对象，

     * 而是在堆内存中创建一个新的String对象并由s4指向

     * 所以s1==s4为false

     * 

     */

    void test4() {

        String s1="helloworld";

        String s2="hello";

        String s3="world";

        String s4=s2+s3;

        System.out.println(s1==s4);

    }

    

    /** s2与s3被final修饰为宏变量，不可更改，编译器在程序使用该变量的地方直接使用该变量的值进行替代，

     * 所以s4的值在编译的时候就为"helloworld"指向常量池中的"helloworld"对象

     * 所以s1==s4为true

     * 

     */

    void test5() {

        String s1="helloworld";

        final String s2="hello";

        final String s3="world";

        String s4=s2+s3;

        System.out.println(s1==s4);

    }

    public static void main(String[] args) {

        StringTest o = new StringTest();

        o.test1();

        o.test2();

        o.test3();

        o.test4();

        o.test5();

        

    }

}

结果


true

false

true

false

true