Java基础思维导图

普通：Byte !=null

jdk7: Objects.requireNonNull  : Objects是final修饰的 

申明为final根据值来自定义equals()和hashCode()绝对使用equals()方法而不是==进行比较没有公开的构造器，而是提供工厂方法

因为像Optional类和LocalDateTime类都是值敏感的。jdk要求把值敏感的类设计成不可变类，否则对象就可以被变更。题

可是回头一看：Optional类是申明为final的！！没法继承啊！

jdk8:Optional.ofNullable  : Optionnal是final修饰的

判空方式

byte：1字节  --默认值：0

java null 在前_java中判断对象为null时，null在前面还是后面

short:    2字节  --默认值：0

CollectionUtils.isEmpty() 为空

CollectionUtils.isNotEmpty() 不为空

1、数据结构判空(map、list、set)分为apache.lang3或者spring框架下：

Objects.isNull() 为空

Objects.nonNull() 不为空

2、对象判空：jdk7

(2). public static boolean isBlank(String str)判断某字符串是否为空或长度为0或由空白符(whitespace)构成下面是示例：StringUtils.isBlank(null) = trueStringUtils.isBlank(“”) = trueStringUtils.isBlank(\" “) = trueStringUtils.isBlank(” “) = trueStringUtils.isBlank(”\\t \ \\f \\") = true //对于制表符、换行符、换页符和回车符StringUtils.isBlank()均识为空白符StringUtils.isBlank(“\\b”) = false //“\\b\"为单词边界符StringUtils.isBlank(“bob”) = falseStringUtils.isBlank(” bob \") = false

4、isBlank()与isEmpty()的区别String a = null;//没分配内存String b = new String(); //分配了内存，内存指针无指向String c = \"\"; //分配了内存，内存指针指向空字符串String d= \" \"; //分配了内存，内存指针指向多个空格组成的字符串

StringUtils.isNotEmpty() 不为空

StringUtils.isEmpty() 为空

StringUtils.isNotBlank() 不为空

StringUtils.isBlank() 为空

3、字符串判空

生成Integer对是有常量池的：在-128~127之间常量，就从缓存的IntegerCache类中获取

int：4字节   --默认值：0

long:8字节   --默认值：0L

整数类型

float：4字节   --默认值：0f

子主题

很多人都知道，在进行金额表示、金额计算等场景，不能使用double、float等类型，而是要使用对精度支持的更好的BigDecimal。

equals()方法会比较值和精度（1.0与1.00返回结果为false），而compareTo()则会忽略精度，精度就是小数有几位

因为BigDecimal是对象，所以不能用==来判断两个数字的值是否相等。

if  (  bigdecimal  =  bigdecimal   )

比较值和精度，不适合比较

if  ( bigdecimal.equals( bigdecimal )  )

错误案例

        BigDecimal bigDecimal = new BigDecimal(1);        System.out.println(\"bigDecimal = \" + bigDecimal);//bigDecimal = 1        BigDecimal bigDecimal1 = new BigDecimal(1);        System.out.println(\"bigDecimal1 = \" + bigDecimal1);//bigDecimal1 = 1        System.out.println(bigDecimal.equals(bigDecimal1));   //true      //  整数类使用bigdecimal，精度一样        BigDecimal bigDecimal2 = new BigDecimal(1);        System.out.println(\"bigDecimal2 = \" + bigDecimal2);//bigDecimal2 = 1        BigDecimal bigDecimal3 = new BigDecimal(1.0);//bigDecimal3 = 1        System.out.println(\"bigDecimal3 = \" + bigDecimal3);        System.out.println(bigDecimal2.equals(bigDecimal3));  //true     //   浮点型在用bigdecimal 初始化是不精确的，但是返回一样        BigDecimal bigDecimal4 = new BigDecimal(\"1\");        System.out.println(\"bigDecimal4 = \" + bigDecimal4);//bigDecimal4 = 1        BigDecimal bigDecimal5 = new BigDecimal(\"1.0\");  //bigDecimal5 = 1.0        System.out.println(\"bigDecimal5 = \" + bigDecimal5);        System.out.println(bigDecimal4.equals(bigDecimal5));//flase

实际例子

public BigDecimal(int val) {    this.intCompact = val;    this.scale = 0;    this.intVal = null;}public BigDecimal(long val) {    this.intCompact = val;    this.intVal = (val == INFLATED) ? INFLATED_BIGINT : null;    this.scale = 0;}

最简单的就是BigDecimal(long) 和BigDecimal(int)，因为是整数，所以标度就是0 ：

当我们使用new BigDecimal(0.1)创建一个BigDecimal 的时候，其实创建出来的值并不是正好等于0.1的，而是0.1000000000000000055511151231257827021181583404541015625 。这是因为doule自身表示的只是一个近似值。那么，无论我们使用new BigDecimal(0.1)还是new BigDecimal(0.10)定义，他的近似值都是0.1000000000000000055511151231257827021181583404541015625这个，那么他的标度就是这个数字的位数，即55。其他的浮点数也同样的道理。对于new BigDecimal(1.0)这样的形式来说，因为他本质上也是个整数，所以他创建出来的数字的标度就是0。所以，因为BigDecimal(1.0)和BigDecimal(1.00)的标度是一样的，所以在使用equals方法比较的时候，得到的结果就是true。

BigDecimal(double)

当我们使用new BigDecimal(\"0.1\")创建一个BigDecimal 的时候，其实创建出来的值正好就是等于0.1的。那么他的标度也就是1。如果使用new BigDecimal(\"0.10000\")，那么创建出来的数就是0.10000，标度也就是5。所以，因为BigDecimal(\"1.0\")和BigDecimal(\"1.00\")的标度不一样，所以在使用equals方法比较的时候，得到的结果就是false。

BigDecimal(string)

BigDecimal(int)BigDecimal(double) BigDecimal(long) BigDecimal(String)

理解

为什么阿里巴巴禁止使用BigDecimal的equals方法做等值比较？

BigDecimal判空

引申知识

span style=\"font-size: inherit;\

double：8字节    --默认值：0d

浮点类型

boolean   --默认值：false

布尔类型

public static void main(String[] args) {        String s1 = new String();        String s2 = null;        String s3 = \"\";        System.out.println(\"s1==s2 = \" + s1==s2);//内存地址比较  false        System.out.println(\"s1 = \" + s1.equals(s2));//值的比较 false        System.out.println(\"s2==s3 = \" + s2==s3);//内存地址比较 false        System.out.println(\"s3.equals(s2) = \" + s3.equals(s2));//值的比较 false        System.out.println(\"s1==s3\" + s1==s3);//内存地址比较 false        System.out.println(\"s1.equals(s3) = \" + s1.equals(s3));//值的比较 true    }

字符串对象与null的值不相等，且内存地址也不相等;

空字符串对象与null的值不相等，且内存地址也不相等;

new String()创建一个字符串对象的默认值为\"\" (String类型成员变量的初始值为null)

在java中变量和引用变量是存在栈中(stack)，而对象(new产生的)都是存放在堆中(heap)：

null表示的是一个对象的值，而并不是一个字符串。例如声明一个对象的引用，String a = null ;\"\"表示的是一个空字符串，也就是说它的长度为0。例如声明一个字符串String str = \"\" ;

1、类型

“==”是运算符，如果是基本数据类型，则比较存储的值；如果是引用数据类型，则比较所指向对象的地址值。

equals是Object的方法，比较的是所指向的对象的地址值，一般情况下，重写之后比较的是对象的值。

“==”和equals 最大的区别是

String str = null ; 表示声明一个字符串对象的引用，但指向为null，也就是说还没有指向任何的内存空间;String str = \"\"; 表示声明一个字符串类型的引用，其值为\"\"空字符串，这个str引用指向的是空字符串的内存空间;

2、内存分配

一、空字符串与null区别

char:2字节  --默认值：\\u0000(null)

字符类型

Java8大基本类型

INumber下的方法只能是实例化之后的对象使用

    int intValue();    long longValue();    float floatValue();    double doubleValue();    default byte byteValue() {        return (byte)this.intValue();    }    default short shortValue() {        return (short)this.intValue();    }

统一extends Number 数字实现类INumber 接口

equals 基本上用于判断当前对象和参数传入的对象是否相同，Object类的默认实现是比较地址。对于两个变量，指向同一个对象地址时，equals才会返回true，与==运算符结果相同。一般这个默认实现是不符合我们需要的比较两个对象相等，需要子类重写这个实现。以Long为例，其equals方法代码实现如下：public boolean equals(Object obj){    if(obj instanceof Long){      return value==((Long)obj).longValue();   }   return false;}

对于Float，equals方法实现跟上面还有点区别，需要注意一下，其equals实现：public boolean equals(Object obj){   return (obj instanceof Float) && (floatToIntBits((Float) obj).value) ==floatToIntBits(value));}上面代码出现了一个floatToIntBits()方法，这里将float的二进制表示看做int。为什么要使用这个方法呢？因为float类型要比较相等的时候，只有当他们表示的二进制完全一样的时候才相等。所以比较两个float相等转成成了二进制对应int值的比较。Double实现euqals方法也类似，有兴趣的可以自己找源码看看。public boolean equals(Object obj) {        return (obj instanceof Double)               && (doubleToLongBits(((Double)obj).value) ==                      doubleToLongBits(value));    }

hashCode 返回一个对象的哈希值。哈希值是一个int类型的数，一般有对象中不变的属性值映射得来。一般在容器类会对对象进行区分。一个对象的哈希值不能改变，相同对象的哈希值相同，不同对象的可以相同，也可以不同，一般是不同。对于hashcode与equals的关系，我这里推荐一个博主的文章，写的比我详细，我这里就在这里引用他的文

在Set中为何要同时重写hashCode()和equals()呢？不重写也可以，但是会丢失数据，比你认为的不重复数据，但是没有重写就添加不进去set集合

//以下为Object类public boolean equals(Object obj) {        return (this == obj);}public native int hashCode();

Object类中equals方法认为的相等是，地址相等。

@Testpublic void testString() {    String s1 = new String(\"123\");    String s2 =\"123\";    System.out.println(s1 == s2);//false    System.out.println(s1.equals(s2));//true}关于s1和s2，他们并不指向同一个实例对象，也就是说他们的地址并不相等。然而，在使用过程中，我们往往只关注String的内容，即字面量，故String类中重写了equals方法，也就是对equals来说，字面量相等，就认为他们相等。其实只是给何为相等重新下了个定义。何为相等，要根据业务场景去随时定义。默认的相等定义就是Object类中的equals方法，即比较地址。当然，关于String类其实还要提到字符串常量池，常量池的对象地址是一样的 如果在 -128 -127之间取常量池，对象的地址一样https://blog.csdn.net/weixin_43615816/article/details/123311738

其实，在Set中，如字符串，仍只需要比较字面量是否相等即可，对于其它对象，可由用户自定义相等规矩（重写equals方法）。那为何还要同时重写hashCode()和equals()，即相等（equals）的对象必须具有相等的哈希码？

原因：当person1和person2这两个对象（equals）相等，即他们equals的结果为true，但他们各自的哈希码(很大概率)不相同（没有重写hashCode），当他们要存入同一个HashSet时，有可能就会因为哈希码不同导致计算得出的HashSet内部数组位置索引不一样，那么person1、person2很可能同时存入同一个HashSet中。

所有的key构成的集合是Set:无序的、不可重复的。所以，key所在的类要重写：equals()和hashCode()。所有的value构成的集合是Collection:无序的、可以重复的。所以，value所在的类要重写：equals()。

HashMap中的重写

很多时候我们常用的key是String类型，那么如果使用一般对象作为key值这个对象需要满足或者具备什么条件呢？1.首先String底层重写了hashcode 和equals 方法，所以可以使用String对象作为key来使用。2.如果自定义对象作为 map 的键，那么也必须重写 hashcode和equals。3.只要重写equals，就必须重写hashcode。

如果自定义对象做为 Map 的键，那么必须重写 hashCode 和 equals；

2.3Set中如何定义相等？

2.2如何定义相等？

也就是说，hashCode()和equals()都是Object类中的方法。在Object中，equals方法的本质就是 == ，即比较地址。在没有重写的equals的类，equals比较的是地址。而String、Date、File等类重写了equals方法，所以比较的是内容（字面量）。

案例

为什么呢？因为set对象对比的是equals和hashCode，如果hashCode没有，两个对象字面量一样，但是hashCode不一样，会将两个添加到set集合中

阿里规范：只要重写equals就必须重写hashCode.

Object对象的colne尽量不使用，因为是浅复制

引申知识：阿里规范

我们也很容易知道Object的方法有：boolean equals(Object obj)int hashcode()String toString()

所有包装类都重写了Object方法

Byte

Integer、Long

Folat

BigDecimal可以使用字符串和 double 类型创建对象，并且建议使用字符串创建，因为在看起来数字相等的情况下，使用字符串的精度更高。

BigDecimal的等值比较应使用CompareTo方法，而不是equals方法说明：equals方法会比较值和精度（1.0与1.00返回结果为false）.而compareTo则会忽略精度

源码：equals:将此BigDecimal与指定的Object进行比较是否相等。与compareTo不同，此方法仅当两个BigDecimal对象的值和比例相等时才认为它们相等（因此，通过此方法进行比较时，2.0 不等于 2.00）。compareTp:将此BigDecimal与指定的BigDecimal进行比较。此方法认为两个值相等但比例不同（如 2.0 和 2.00）的BigDecimal对象是相等的。此方法优先于六个布尔比较运算符（<、==、>、>=、!=、<=）中的每一个的单独方法提供。执行这些比较的建议习惯用法是： (x.compareTo(y) < op > 0) ，其中 < op > 是六个比较运算符之一。

说明：Bigdecimal(double)存在精度损失风险，在精确计算或值比较的场景中可能会导致业务逻辑异常如：BigDecimal g = new BigDecimal(0.1F);实际的存储值为：0.10000000149正例：优先推荐入参为String的构造方法，或使用BigDecimal的valueOf方法，此方法内部其实执行了Double的toString，而Double的toString按double的实际能表达的精度对尾数进行截断。BigDecimal d1 = new BigDecimal(\"0.1\");BigDecimal d2 = BigDecimal.valueOf(0.1)

禁止使用构造方法BigDecimal(double)的方式把double值转化为BigDecimal对象

阿里规范：Decimal(小数的意思)

1.使用BigDecimalextends Number implements Comparable<BigDecimal>

compareTo是实现了compareble接口，我觉的实现接口的普遍都是类要实例化因为实现类的方法被@Override注解修饰使用static修饰会报错“Method does not override method from its superclass”方法不会重写其超类中的方法//2.使用包装类DoubleDouble dL = num1;Double dR = num2;if (dL.compareTo(dR) < 0) System.out.println(\"num1 < num2\");else if (dL.compareTo(dR) == 0) System.out.println(\"num1 == num2\");else System.out.println(\"num1 > num2\");

2.使用包装类Double

3.在误差范围内运行相等

可以将double数据转换成string然后借助string的compareTo方法来间接实现比较两个double数据是否相等。注意这种方法只适用于比较精度相同的数据，并且是只能用于比较正数的大小，负数比较结果异常，不过可以用于比较两数是否相等，此时正负数对结果没有影响。

4.转换成字符串

5.使用doubleToLongBits()方法

在Java中 int类型数据的大小比较可以使用双等号， double类型则不能使用双等号来比较大小，如果使用的话得到的结果将永远是不相等，即使两者的精度是相同的也不可以。下面介绍几种比较double数据是否相等的方法，前三种可以比较正负数，后两种方法只能用于比较两数是否想等以及正数的大小。

Java中double类型大小比较的五种方法

1、常量池指的是在编译期确定，并被保存在已编译的字节码文件中的一些数据，它包括类、方法、接口等中的常量，存放字符串常量和基本类型常量（public static final）。2、栈（stack）主要保存基本数据类型（或者叫内置类型）（char、byte、short、int、long、float、double、boolean）和对象的引用，数据可以共享，速度仅次于寄存器（register），快于堆。3、堆（heap）：用于存储对象3、==  ：引用是否指向同一个对象4、equals（）：比较里面的数值是否相等时

第1种：String a=\"abc\";String b=\"abc\";System.out.print(a==b);结果：true原因：编译时，String a=\"abc\" 会把\"abc\"放到常量池中，再定义b时，因为常量池中已存在“abc”，所有不会再创建，运行时JVM(JAVA虚拟机)则认为这两个变量赋的是同一个对象，所以返回true。

第2种：String a=new String(\"abc\");String b=new String(\"abc\");System.out.print(a==b);结果：false第二种中用构造器创建的对象是不会被放入常量池中，这句话是不对的。事实上，只要有引号的引用它就会在常量池中创建字符串，所以常量池中是存在abc的，只不过new的过程在堆中又创建了字符串abc。

第3种String a=\"abc\";String b=new String(\"abc\");System.out.print(a==b);结果：false原因：同上

第4种String a=\"abcdef\";System.out.print(a==\"abcdef\");结果：true原因：运行出现的字符串常量，若是在常量池中出现过，则JVM会认为同一个对象，以节省内存开销，所以这两个字符串会被认为是同一个对象。

第5种String a=\"abcdef\";String b=\"\";String c=a+b;System.out.print(c==\"abcdef\");结果：false原因：编译时，先将\"abcedf\"放在常量池中，而c的值则是在运行时在堆里创建的。所以为false。

String a=\"abc\"与String b=new String（\"abc\"）的区别

String a=\"abc\";  String b=\"abc\";  System.out.println(a==b);答案是：true因为相同的字符串内容，在地址上是一样。在Java中，String是有一个String pool的，里面存放了可以共享的字符串对象，在声明一个String对象后，会首先去找是否存在相同的String内容，如果有的话是不会创建新的对象的。在这里b实际上是引用了a的对象的值，他自己并没有创建对象，所以这里的答案是true。但是如果我们接着String c=new String(“abc”);再System.out.println(a==c);那答案就是false，因为这二者的地址并不是一致的。为什么呢？因为这里是 new String  新创建对象。之前 “abc” 是编译器自动处理优化，因此可以去查找字符串池

等号是最简单也最容易理解的，如果等号的两边是基本数据类型，比如int，double，那么等号就用来单纯的比较他们的数值大小如果等号两边放的是两个对象，那么就会比较他们在内存当中的地址。

1.等号——\"==\"：

注意这里是String类型，其他同理

可以观察出，这里实际上是获取的字符串（也可以是其他对象）的长度，然后作减法，这里的减法就是ASCII码的减法，所以compareTo()会返回数字，如果两个字符串内容相同，会返回0，字符串a大于字符串b，会返回相差的ASCII码的正数，字符串a小于字符串b，会返回相差的ASCII码的负数。所以 System.out.println(a.compareTo(b))的答案是：0

2.compareTo()

public boolean equals(Object anObject) {  if (this == anObject) {        return true;    }    if (anObject instanceof String) {        String anotherString = (String)anObject;        int n = value.length;        if (n == anotherString.value.length) {            char v1[] = value;            char v2[] = anotherString.value;            int i = 0;            while (n-- != 0) {                if (v1[i] != v2[i])                    return false;                i++;            }            return true;        }    }    return false;}

3.equals()

compareTo()会返回二者的差值，即返回的是一个数字；而equals就简单一些，只返回true或者false。最后，compareTo()和equals()都可以判断其他基本数据类型，比如说Integer，Java的源码中对这两者方法都做了一些重载，可以根据参数的类型去自动匹配相应的方法，他们的原理也非常简单，只是一些简单的减法或者（？：）这类判断。

4.compareTo()和equals的区别

Java中“==”、“compareTo()”和“equals()”的区别

Double

new Date()返回的是系统的毫秒时间public Date() {        this(System.currentTimeMillis());    }this（）调用的是本地的构造函数，也就是下面这个函数，参数类型是 long

public static native long currentTimeMillis();返回类型是long类型System.currentTimeMillis()自然就可以使用下面的构造函数了public Date(long date) {        fastTime = date;    }

首先结论：yyyy-MM-dd HH:mm:ss是最标准的写法下面展示不同出现的结果月份如果小写的话 就是yyyy-mm-dd HH:mm:ss这样子就会月份和分钟混了，两个都是小写mm，最后两个都显示分钟MM是月份，mm是分钟产生如下问题2019-18-03 12：18：33  //18问题小时如果小写的话 就是yyyy-MM-dd hh:mm:ss这样子如果是下午两点半 大写的HH会表示为14:30 小写的hh会表示为2:302019-18-03   2：30：33HH为24小时制，hh为12小时制2019-18-03   14：30：33

yyyy-MM-dd HH:mm:ss大小写区别

编写 stringToDate

SimpleDateFormat

public abstract class DateFormat extends Format

Format的直接子类包括DateFormat、NumberFormat和MessageFormat。下面一一进行介绍链接 ： https://www.jianshu.com/p/c8f16cab35e1

子类：SimpleDateFormat

接口 ： DateFormat

1.1 有时候我们在处理小数保留几位小数时，想到了DecimalFormat这个类的使用，百度搜一把可能用到以下方式。复制代码 1     public static void main(String[] args) { 2         String str=\"3.145\"; 3         System.out.println(round1(str)); 4     } 5  6     static String round1(String str){ 7         double a=Double.parseDouble(str); 8         DecimalFormat df=new DecimalFormat(\"###.00\"); 9         return df.format(a);10     }复制代码1.2 初看好像没什么问题，四舍五入保留两位小数，最后输出3.15。当然精度要求不高，也无需计较。当涉及到精确统计时，这里的坑来了将上面的字符串改为“5”前面为奇数，如“3.155”，就瓜了，输出3.15。显然这里没满足要求，不是我们学校里的四舍五入。再上一段代码。1     static String round2(String str){2          double a=Double.parseDouble(str);3          DecimalFormat df=new DecimalFormat(\"###.00\");4          df.setRoundingMode(RoundingMode.HALF_UP);5          return df.format(a);6     }这里可以看到这个setRoundingMode()方法可以设定四舍五入的模式，原来四舍五入不光有我们学校里学的那种，还有其他模式。DecimalFormat默认情况下，它使用 RoundingMode.HALF_EVEN，此舍入模式也称为“银行家舍入法”，主要在美国使用。RoundingMode.HALF_UP这个模式才是我们学校里学的标准四舍五入模式。以上代码虽然舍了学校型模式仍然不准确，应该将double类型改为BigDecimal类型。

一、DecimalFormat四舍五入的坑

2.1 String直接格式化1     static String round3(String str){2          double d=Double.parseDouble(str);3          return String.format(\"%.2f\

二、学校型四舍五入几种正确使用

Java DecimalFormat四舍五入的坑及正确用法

子类：DecimalFormat

接口 ：NumberFormat

MessageFormat form = new MessageFormat(\"The disk \\\"{1}\\\" contains {0}.\");

接口 ：MessageFormat

String result1 = String.format(\

String类中的format方法

总结1.Format中的子类都是不同步，所以需要注意线程安全问题2.可能在某些地方我解释的还是不太清楚。学习最重要的是多去尝试，多编写代码测试，如果仅仅靠看就能学会的话，那你就看吧、

Java中强大的 接口 ：Format

分配一个Date对象并对其进行初始化，以便它表示由字符串s指示的日期和时间，这就像由parse方法解释一样。已弃用从 JDK 1.1 版开始，由DateFormat.parse(String s)取代。参数：s – 日期的字符串表示形式。也可以看看：DateFormat ， parse(String)@Deprecated    public Date(String s) {        this(parse(s));    }

public int compareTo(Date anotherDate) {        long thisTime = getMillisOf(this);        long anotherTime = getMillisOf(anotherDate);        return (thisTime<anotherTime ? -1 : (thisTime==anotherTime ? 0 : 1));    }

时间比较的时候，先获取毫毛值在进行比较

java.util.Date

public interface Comparable<T> {   public int compareTo(T o)}

Java API 的Comparable 接口如下：

String.valueOf()

应用场景：1、BigInteger适合保存比较大的整型2、BigDecimal适合保存精度更高的浮点型(小数)

Decimal英文意思是小数BigDecimal意思是大的小数

//当我们编程中，需要处理很大的整数，long不够用        //可以使用BigInteger的类来搞定        long l = 234459897895499999999999999999999l;//编译器报 “Long number too large”        System.out.println(\"l=\" + l);BigInteger bigInteger = new BigInteger(\"234459897895499999999999999999999\");        System.out.println(bigInteger);        //1.在对BigInteger进行加减乘除的时候，需要使用对应的方法，不能直接进行 + - * /        BigInteger bigInteger2 = new BigInteger(\"100\");        BigInteger add = bigInteger.add(bigInteger2);        System.out.println(add);//+        BigInteger subtract = bigInteger.subtract(bigInteger2);        System.out.println(subtract); //减        BigInteger divide = bigInteger.divide(bigInteger2);        System.out.println(divide);//除

BigInteger

//当我们需要保存一个精度很高的数时，double不够用        //可以用BigDecimal       //double d=19999.2323223423493423423432423;        //System.out.println(d);//输出 19999.2323223423 精度缺失        BigDecimal bigDecimal = new BigDecimal(\"19999.2323223423493423423432423\");        BigDecimal bigDecimal2 = new BigDecimal(\"1.1\

BigDecimal

BigDecimal.valueOf()

valueOf(）方法进行转换成相应包装类型

parseByte

parseInt

parseLong

parseFloat

parseDouble

parse+引用类型

8大引用类型转换

8大引用类型

当不希望类被继承时；

当不希望父类的某个方法被子类覆盖、重写时；

当不希望类的某个属性值被修改时；

当不希望某个局部变量被修改时。

使用场景

1.final修饰的属性又叫常量，一般用大写字母和下划线命名；2.final修饰的属性必须赋初始值，且一旦赋值不能被修改；（在定义时、构造器、代码块中都可以进行赋值）3.如果final修饰的属性是静态的，则初始化的位置只能是定义时和静态代码块中，不能在构造器中赋值；4.final类不能继承，但是可以实例化对象；5.如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承。6.一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法了。7.final和static搭配使用，效率更高，底层编译器做了优化处理。class Demo{ public static final int i = 16; static{         system.out.println(\"我想hj了\")； }}8.包装类（Integer，Double，Float，Boolean等都是final），String也是final类。

注意事项和细节：

final可以修饰类、属性、方法和局部变量。

按时间

按项目

具体工作任务与完成情况

工作亮点

工作不足

亮点与不足

个人方面

团队协作方面

改进措施

下一阶段工作计划

Java基础思维导图