个人全栈之路-Java基础之数据存储

时间 2019-11-07

标签个人之路 java 基础数据存储栏目 Java 繁體版

原文原文链接

个人全栈之路-Java基础之数据存储

个人全栈之路

2.1 标识符

标识符是在程序开发时给包，类、接口、注解，变量，方法命名的字符序列。
标识符在命名时须要遵照相关的规则和规范:html

标识符的命名规则:java

标识符不能是Java的关键字和保留字，关键字是Java中被赋予赋予特殊含义的单词，例如public static void等等。保留字是现有Java版本还没有使用，可是将来的Java版本可能会作关键字使用的单词，例如goto,const。可是能够包含关键字，保留字。
标识符能够由字母、数字、下划线组成，可是不能以数字开头

平常开发中应该严格遵照标识符的命名规则，不然程序会出现编译错误。程序员

标识符的命名规范:web

包名统一使用小写，点分隔符之间有且仅有一个天然语义的英语单词。包名统一使用单数形式，可是类名若是有复数含义，类名可使用复数形式。，例如com.taobao
类名单词首字母大写，多个单词首字母也要大写，例如HelloWorld
变量名、方法名首字母小写，后面单词首字母大写，例如myName,testVarriable()
常量名单词字母所有大写，多个单词使用下划线隔开，例如ORDER_TYPE
虽然Java支持Unicode字符集，可是标识符不能是中文，同时禁止使用中英文混合命名，更不容许直接使用中文的命名方式,建议命名时见名知意。

因为软件开发是团队协做，标识符的命名规范不遵照不会出现错误，可是遵照标识符的命名规范能够提升程序的可读性，便于后期维护，所以平常开发中也应该严格遵照。数据库

package net.ittimeline.java.core.foundational.syntax; //包的命名

/** * Java标识符 * * @author liuguanglei 18601767221@163.com * @create 2019-07-22 16:21 * @website www.ittimeline.net * @since JDK11 */
public class IdentifierTest {


    public static void main(String[] args) {

        CustomerInfo customerInfo = new CustomerInfo();
        customerInfo.setCustomerName("tony");

        System.out.println("customerInfo name is " + customerInfo.getCustomerName());

        System.out.println("customerInfo id card id " + CustomerInfo.CUSTOMER_ID_CARD);


    }
}

/** * 类的命名 */
class CustomerInfo {
    /** * 成员变量的命名 */
    private String customerName;

    /** * 常量的命名 */
    public static final String CUSTOMER_ID_CARD = "430904458902219877";


    /** * 方法的命名 * * @return */
    public String getCustomerName() {
        return this.customerName;
    }

    public void setCustomerName(String customerName) {
        this.customerName = customerName;
    }


}

2.2 变量

2.2.1 变量的概述

变量表明内存的某个存储区域，该区域的数据能够在同一类型以内随着业务逻辑不断发生变化，例如银行的利率，游戏中人物的位置等等。
变量做为最基本的存储数据的单元，由变量名、变量类型和变量值组成。经过操做变量，就能够方便的操做内存中的数据。编程

2.2.2 变量的定义和使用

Java是强类型的语言，变量在定义时必需要明确变量的数据类型。变量定义的语法格式为 数据类型变量名=变量值;,数据类型能够是Java的基本数据类型和引用数据类型两种。变量名必须遵照标识符的命名规则和规范，=表示赋值，即将"="右边的值赋值给左边的变量,Java中的相等性使用"=="表示，变量的值能够是对应变量数据类型取值范围内的值。例如 int age=28;数组

变量的定义也能够是先声明，再进行赋值dom

//先声明一个整数变量
int number; 
//将整数变量number赋值为10
number=10;

变量定义后，Java会根据变量的数据类型在内存中开辟对应的空间存储数据。测试

变量在使用前必须声明并赋初始值，若是使用了未声明的变量，程序会发生编译错误，若是使用了未赋值的变量，程序会发生运行时错误。大数据

package net.ittimeline.java.core.foundational.syntax;

/** * Java变量的使用 * <p> * 变量的声明格式 * <p> * 变量类型 变量名=变量值; * 变量必须初始化赋值后才能使用 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-22 16:55 * @website www.ittimeline.net * @since JDK11 */
public class VarriableTest {


    public static void main(String[] args) {

        //变量的声明赋值
        int age = 28;
        System.out.println("current age = " + age);

        //修改变量的值
        //同一时刻，变量只有一个值，新值会覆盖旧值
        age = 29;
        System.out.println("next year age = " + age);

        //若是使用了未声明的变量，会发生编译错误
        //编译时找不到变量name的声明
        // System.out.println("my name is "+name);

        String name;

        //局部变量声明以后还要初始化赋值才能使用
        //System.out.println("my name is "+name);
    }

}

在使用变量时，只能在定义时的做用域内使用。在同一个做用域下不能定义重复的变量名。

package net.ittimeline.java.core.foundational.syntax;

/** * 变量做用域测试 * * @author liuguanglei ittimelinedotnet@gmail.com * @version 2019/9/2 16:38 * @website ittimeline.net * @since JDK11 */
public class VarriableScopeTest {

    public static void main(String[] args) {

        //这里会发生编译错误，由于整数变量age在test方法中定义，只能在test方法中使用
        // System.out.println(" my age is "+age);

    }

    public static void test() {
        int age = 28;
        //这里会发生编译错误，在同一个做用域下，不能定义重复的变量
     // int age = 29;

    }
}

2.2.4 变量的分类

变量按照其做用域能够分为局部变量、成员变量以及类变量。
在方法中声明的变量叫作局部变量，做用域和生命周期从属于方法

package net.ittimeline.java.core.foundational.syntax.variable;

/** * 局部变量的使用 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-26 10:39 * @website www.ittimeline.net * @since JDK11 */
public class LocalVariableTest {

    public static void main(String[] args) {

        {
            int age = 29;


        }

        //这里没法使用代码块中的aqe变量，由于age只能在{}做用域内访问
        //System.out.println("age = "+age);

        int score = 100;

        System.out.println("score = " + score);
    }
}

成员变量是在方法外部、类中定义，并未使用static修饰的变量，成员变量的做用域和生命周期从属于对象，
访问成员变量时须要实例化对象，而后经过对象.成员变量名访问。

package net.ittimeline.java.core.foundational.syntax.variable;

/** * 成员变量的使用 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-26 10:40 * @website www.ittimeline.net * @since JDK11 */
public class MemberVariableTest {

    /** * 方法外部，类中声明两个成员变量 */
    String name;
    int age;

    public static void main(String[] args) {
        //实例化MemberVariableTest对象
        MemberVariableTest memberVariableTest = new MemberVariableTest();
        //经过对象的引用memberVariableTest.name访问成员变量
        memberVariableTest.name = "tony";
        memberVariableTest.age = 29;

        System.out.println("name is " + memberVariableTest.name + " age is " + memberVariableTest.age);
    }
}

类变量是在方法外部、类中定义，使用static修饰的变量，做用域和生命周期从属于类。访问类变量经过类名.成员变量名。

package net.ittimeline.java.core.foundational.syntax.variable;

/** * 静态变量的使用 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-26 10:40 * @website www.ittimeline.net * @since JDK11 */
public class StaticVarriableTest {


    public static void main(String[] args) {


        System.out.println(User.ID_CARD);

        //静态变量能够直接由类名.变量名访问
        System.out.println(User.remark);
    }
}


class User {

    static final String ID_CARD = "421023199302888588";

    /** * 静态变量由Java负责初始化 */
    static String remark;

}

成员变量和类变量由Java根据变量的负责初始化，局部变量由程序员手动初始化。

package net.ittimeline.java.core.foundational.object;

/** * Java成员变量的初始化机制 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-22 10:15 * @website www.ittimeline.net * @since JDK11 */
public class DefaultInitialization {

    char c;
    int i;

    DefaultInitialization() {

        System.out.println(" i = " + i);
        System.out.println(" c = [" + c + ']');
    }


    public static void main(String[] args) {

        DefaultInitialization defaultInitialization = new DefaultInitialization();

    }
}

2.2.5 变量的交换

在Java中，变量的交换有三种方式实现，分别是使用中间变量、算术运算以及异或运算三种方式实现。

package net.ittimeline.java.core.foundational.syntax.variable;

/** * 变量交换 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-26 10:17 * @website www.ittimeline.net * @since JDK11 */
public class VariableSwapTest {


    public static void main(String[] args) {

        int left = 5;
        int right = 10;


        //经过引入中间变量tmp实现变量的交换
        System.out.println("经过引入中间变量tmp实现变量的交换");
        System.out.println("交换变量以前");
        println(left, right);
        // tmp=5 left=5
        int tmp = left;
        //left=10,right=10
        left = right;
        right = tmp;

        System.out.println("交换变量以后");
        println(left, right);


        //经过算术运算+ -实现交换
        System.out.println("经过算术运算实现交换");
        left = 5;
        right = 10;
        System.out.println("交换变量以前");
        println(left, right);
        //left=15 right=10
        left = left + right;
        //right=5 left=15
        right = left - right;
        //left=10 right=5
        left = left - right;
        System.out.println("交换变量以后");
        println(left, right);


        //经过异或运算实现变量交换
        System.out.println("经过异或运算实现变量交换");
        left = 5;
        right = 10;
        System.out.println("交换以前");
        println(left, right);

        left = left ^ right;
        right = left ^ right;
        left = left ^ right;
        System.out.println("交换以后");
        println(left, right);


    }

    /** * 输出left和变量的值 * * @param left * @param right */
    public static void println(int left, int right) {
        System.out.println("left = " + left + " right = " + right);
    }


}

2.3 数据类型

在计算机底层数据都是使用二进制表示的，使用起来不太方便，所以引入数据类型的概念，数据类型用于对不一样的数据进行分类，其缘由在于

不一样的类型所能存储的数据类型不一样，
不一样表示的数据范围(极限)也不一样
不一样的数据类型在内存中占据的空间(字节数量)也不一样
不一样的数据类型参与不一样的运算。

Java的数据类型分为基本数据类型(Primitive Type)和引用数据类型(Reference Type)两大类，以下列表所示，目前只讨论基本数据类型

其中基本数据类型都有数组类型，数组就是一片连续的存储空间。
而基本数据类型不具备面向对象的编程机制，也没有对象的特性:没有成员变量、方法能够被调用，所以Java八种基本数据类型对应的引用类型，也被称为包装类，以下表格所示。

基本数据类型	byte	short	int	float	double	boolean	char
包装类	Byte	Short	Integer	Float	Double	Boolean	Character

在平常开发中经常使用的基本类型有byte,int,long和boolean。

2.4 JDK1.5新特性自动拆箱和装箱

JDK1.5之后提供了自动拆箱和自动装箱的特性实现了基本数据类型和包装类的转换。

自动拆箱:将引用数据类型(例如Long)转换为基本数据类型(例如long)
自动装箱:将基本数据类型(例如byte)转换为引用数据类型(例如Byte)

package net.ittimeline.java.core.foundational.object;

/** * JDK5新特性:自动拆箱和自动装箱 * 自动拆箱:引用数据类型转换为基本数据类型 * 自动装箱:基本数据类型转换为引用数据类型 * Java八种基本数据类型以及包装类想换转换 * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-22 10:40 * @website www.ittimeline.net * @since JDK11 */
public class AutoboxingTest {


    public static void main(String[] args) {

        //自动装箱
        Byte by = 1;
        //自动拆箱
        byte bt = by;
        System.out.println("byte = " + bt);

        Short sh = 1;
        short s = sh;
        System.out.println("short = " + s);

        Integer in = 1;
        int i = in;
        System.out.println("int = " + i);

        Long lo = 1L;
        long l = lo;
        System.out.println("long = " + l);

        Boolean bo = true;
        boolean b = bo;
        System.out.println("boolean = " + b);

        Character ch = 'x';
        char c = ch;
        System.out.println("char = " + c);

        Float fl = 1.0f;
        float f = fl;
        System.out.println("float = " + f);

        Double db = 1.0d;
        double d = db;
        System.out.println("double = " + d);
    }
}

2.5 整型

2.5.1 Java整型的极限

整型是平常生活中经常使用的类型，例如人的年龄，大楼的层数等等。
Java中的整型按照占据不一样内存大小，能够分为byte,short,int,long四种类型。
其中整数默认是int类型，long类型的变量值须要加L后缀。
能够经过查看其包装类Byte的源码获取其表示数据的范围

以及Byte占据的位数和字节数

其余类型可使用一样的方式经过查看包装类的源码获取存储数据的表示范围以及占据的字节带小。

使用四种整数类型的包装类获取其对应的数据存储范围以及占据的字节数量。

package net.ittimeline.java.core.foundational.syntax.type.integer;

/** * 整数的极限以及内存大小 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-26 12:59 * @website www.ittimeline.net * @since JDK11 */
public class IntegerLimitsTest {


    public static void main(String[] args) {

        //这里的%d表示整数占位符，会被对应的数值替换
        System.out.printf("byte所能存储的最大值是%d,所能存储的最小值是%d，占据的字节数量是%d \n",Byte.MAX_VALUE,Byte.MIN_VALUE,Byte.BYTES);
        System.out.printf("short所能存储的最大值是%d,所能存储的最小值是%d，占据的字节数量是%d \n",Short.MAX_VALUE,Short.MIN_VALUE,Short.BYTES);
        System.out.printf("int所能存储的最大值是%d,所能存储的最小值是%d，占据的字节数量是%d \n",Integer.MAX_VALUE,Integer.MIN_VALUE,Integer.BYTES);
        System.out.printf("long所能存储的最大值是%d,所能存储的最小值是%d，占据的字节数量是%d \n",Long.MAX_VALUE,Long.MIN_VALUE,Long.BYTES);
    }
}

在使用对应的数据类型时，须要注意不要超过其存储的极限(即最大值和最小值)，不然程序会发生错误。

2.5.2 大整数BigInteger

平常开发中使用的整数是byte,int,long以及对应的包装类,整数默认是int，而long类型的常量值后面须要添加L后缀，若是想要使用比Long更大范围的数据，可使用java.math包中的BigInteger类。

package net.ittimeline.java.core.foundational.syntax.type.integer;

import java.math.BigInteger;

/** * Java * Java整型有byte short int long 四种类型,经常使用的有byte,int和long * 整数默认是int * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-22 18:54 * @website www.ittimeline.net * @since JDK11 */
public class IntegerTest {

    public static void main(String[] args) {

        byte bt=-128;
        System.out.println("bt = "+bt);
        //
        int INT_MAX_VALUE=Integer.MAX_VALUE;
        System.out.println("int max value is "+INT_MAX_VALUE);
        //long类型的变量值若是超过了int的表示范围,须要使用L后缀
        //全球人口数量
        long totalPopulation=76_0000_0000L;
        System.out.println("totalPopulation = "+totalPopulation);

        //若是想要表示宇宙的星球数量,假如是1万亿亿 long类型也不可以存储
        //long starQuantity=1_0000_0000_0000_0000_0000L;

        //此时可使用JDK提供的BigInteger来存储大整数
        String starQuantityStr="100000000000000000000";
        BigInteger starQuantity=new BigInteger(starQuantityStr);
        System.out.println("starQuantity = "+starQuantity);

    }

}

2.5.3 整数的四种进制类型

在Java中，整数支持四种进制类型，分别是二进制、八进制、十进制和十六进制。其中JDK1.7之后支持二进制，以0b开头，而八进制是以0开头，十六进制是以0x开头

package net.ittimeline.java.core.foundational.syntax.type.integer;

/** * 整数的四种进制类型 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-26 13:10 * @website www.ittimeline.net * @since JDK11 */
public class IntegerRadix {

    public static void main(String[] args) {

        byte binary=0b1100;
        System.out.println("二进制变量binary = "+binary);


        short oct=012;
        System.out.println("八进制进制变量oct = "+oct);


        int value=12;
        System.out.println("十进制变量value = "+value);

        long hex=0x12;
        System.out.println("十六进制变量hex = "+hex);
    }
}

在平常企业开发中基本使用的都是十进制的整数，可是在JDK源码以及其余场景中中会使用到其余进制,
Integer类就使用了十六进制的常量来表示int的取值范围。

2.5.4 数值字面量使用下划线

若是Java源文件中存在着很长的数字字面量(即变量值)，不易阅读，此时可使用JDK7之后新增的特性:数值字面量使用下划线来分割数值，使其更加容易阅读。
咱们能够在整数和浮点数的数值之间使用下划线，编译器在编译时会删除这些下划线。

package net.ittimeline.java.core.foundational.syntax.type.integer;

/** * 数值字面量使用下划线 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-26 14:51 * @website www.ittimeline.net * @since JDK11 */
public class IntegerFloatUnderScoreTest {
    public static void main(String[] args) {

        //很长的变量值，不容易阅读
        long number=12000000000000L;
        //数值使用下划线分割，更加容易阅读，编译器在编译时会删除下划线
        System.out.println("number = "+ number);
        number=12_0000_0000_0000L;
        //所以在输出number变量的值时不会看到下划线
        System.out.println("number = "+ number);

        double value=3.1415_926;
        System.out.println("value = "+value);
    }
}

2.6 浮点型

2.6.1 浮点型的两种表示方式

浮点数就是生活中经常使用的小数，例如银行的利率，股市的涨跌等等都是浮点数。
Java中的浮点数类型分为单精度浮点型float和双精度浮点型double两种，默认是double类型，若是想要使用float类型，变量值后面加上f后缀，浮点数可使用十进制和科学计数法两种表示方式。

package net.ittimeline.java.core.foundational.syntax.type.floats;

/** * Java浮点型 * 数学意义上的小数就是浮点型 * float和double是Java的两种浮点类型 * 浮点数默认是double，若是想使用float，变量值后面跟f后缀 * <p> * 浮点数在进行运算时存在着偏差 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-22 19:21 * @website www.ittimeline.net * @since JDK11 */
public class FloatTest {

    public static void main(String[] args) {


        //float类型的变量值后面要加上f后缀,不然会出现编译错误
        float flt = 12.0f;
        //浮点类型默认是double
        double dbl = 12.0;

        //使用科学计数法表示浮点数
        double value = 1.2e1;

        System.out.println("flt = " + flt);
        System.out.println("dbl = " + dbl);
        System.out.println("value = " + value);


        double source = 3.1415926;
        //3.1415926 等价于 31415926e-7
        double target = 31415926e-7;

        System.out.println("source =" + source);
        System.out.println("target =" + target);


    }

}

2.6.2 浮点型的极限以及存储方式

float占据四个字节(Byte)，也就是32位(bit)，double占据八个字节(Byte)，也就是64位，而因为浮点数的存储机制和整数的不同，Java的浮点数准守IEEE754标准，采用二进制的科学计数法表示浮点数。
对于float,第一位是符号位，接下来八位表示指数，接下来23位表示尾数。
对于double，第一位是符号位，接下来11尾数表示指数，接下来52表示尾数。

float所能表示的最大值会比占据8个字节的long都要大。

package net.ittimeline.java.core.foundational.syntax.type.floats;;

/** * 浮点类型的极限 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-26 15:09 * @website www.ittimeline.net * @since JDK11 */
public class FloatLimitsTest {

    public static void main(String[] args) {

        //这里的%e表示整数占位符，会被对应的科学计数法替换
        System.out.printf("float所能存储的最大值是%e,所能存储的最小值是%e，占据的字节数量是%d \n",Float.MAX_VALUE,Float.MIN_VALUE,Float.BYTES);
        //使用科学计数法表示float最大值
        float floatMaxExponent=3.402823e+38f;
        //使用十进制小数表示float最大值
        Float floatMax=340282300000000000000000000000000000000f;

        System.out.println("floatMaxExponent = "+floatMaxExponent);
        System.out.println("floatMax = "+floatMax);

        //因为浮点数的存储机制不一样占据四个字节的float表示的数据极限比占据八个字节的Long还要大
        System.out.printf("long所能存储的最大值是%d,所能存储的最小值是%d，占据的字节数量是%d \n",Long.MAX_VALUE,Long.MAX_VALUE,Long.BYTES);
        System.out.printf("double所能存储的最大值是%e,所能存储的最小值是%e，占据的字节数量是%d \n",Double.MAX_VALUE,Double.MIN_VALUE,Double.BYTES);
    }
}

2.6.3 浮点数精度问题

单精度的float有效位数是7位，即小数点后能保留7位，第八位会进行四舍五入处理。
双精度的double有效位数是16位，即小数点后保留16位，第十七位会进行四舍五入处理。

若是在使用float或者double的小数时，超过了有效位数进行相关的运算时会获得错误的结果。

package net.ittimeline.java.core.foundational.syntax.type.floats;;

/** * 浮点数运算的精度问题 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-26 15:13 * @website www.ittimeline.net * @since JDK11 */
public class FloatPrecisionTest {

    public static void main(String[] args) {


        float floatValue=1.123_456_789f;
        //输出结果是1.1234568 1.123456789，小数点后截取7位，第8位会进行四舍五入
        System.out.println("floatValue = "+floatValue);

        double doubleValue=1.111_222_333_444_555_666_777;
        //输出结果是1.1112223334445557 1.111222333444555666777,小数点后截取16位，第17位会进行四舍五入
        System.out.println("doubleValue = "+doubleValue);



        //浮点类型的数据在运算时运算结果会有偏差

        float floatSource=2.0f;
        //float类型的浮点数小数有效位数是7位
        float floatTarget=1.2_222_222f;
        //0.7777778
        float floatResult=floatSource-floatTarget;
        System.out.println("float source = "+floatSource);
        System.out.println("float target = "+floatTarget);
        //运算结果为 0.7777778 由于float的有效位数是7位
        System.out.println("float result = "+floatResult);

        //double类型的 2.0-1.1获取的计算结果是错误的
        double doubleSource=2.0;
        double doubleTarget=1.1;
        double doubleResult=doubleSource-doubleTarget;
        System.out.println("double source = "+doubleSource);
        System.out.println("double target = "+doubleTarget);
        //运算结果为 0.8_999_999_999_999_999 由于double的有效位数是16位
        System.out.println("double result = "+doubleResult);


        //若是数据超过了有效位数，在进行相关运算时(例如这里的关系运算:相等)也会获得错误的结果
        double source=1.000_000_000_000_000_001;
        double target =1.000_000_000_000_000_002;

        System.out.println("source == target ? "+(source==target));

    }
}

若是想要获取更高的精度，例如金融计算的业务场景中，会使用到更高精度，此时可使用java.math包中的BigDecimal来完成。

package net.ittimeline.java.core.foundational.syntax.type;

import java.math.BigDecimal;

/** * 无损精度计算 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-26 16:37 * @website www.ittimeline.net * @since JDK11 */
public class BigDecimalTest {


    public static void main(String[] args) {

        //使用字符串构建BigDecimal对象
        BigDecimal sourceBigDecimal = new BigDecimal("2.0");
        BigDecimal targetTargetDecimal = new BigDecimal("1.1");
        //调用BigDecimal提供的subtract方法实现减法运算 解决了浮点数double计算的精度问题
        BigDecimal resultBigDecimal = sourceBigDecimal.subtract(targetTargetDecimal);
        System.out.println("resultBigDecimal = " + resultBigDecimal);


        double source=1.000_000_000_000_000_001;
        double target =1.000_000_000_000_000_002;

        BigDecimal doubleSourceBigDecimal=new BigDecimal(source);
        BigDecimal doubleTargetBigDecimal=new BigDecimal(target);
        /** * 使用BigDecimal对象提供的equals方法判断是否相等 这里的结果是true * 在使用BigDecimal时不能使用double构造BigDecimal对象，不然会获得错误的结果 */
        System.out.println("doubleSource equals doubleTarget ？ "+doubleSourceBigDecimal.equals(doubleTargetBigDecimal));



        //将上面的数字转换为字符串以后就能获取精确的运算结果
        String sourceStr="1.000000000000000001";
        String targetStr="1.000000000000000002";
        //只能使用String构造BigDecimal才能获取精确的运算结果
        BigDecimal strSourceBigDecimal=new BigDecimal(sourceStr);
        BigDecimal strTargetBigDecimal=new BigDecimal(targetStr);

        System.out.println("strSource equals strTarget ？ "+strSourceBigDecimal.equals(strTargetBigDecimal));

    }
}

2.7 布尔型

布尔类型只有boolean一个类型，并且其取值只能是true或则false。在平常开中boolean经常和关系、逻辑运算以及条件判断语句一块儿使用。

package net.ittimeline.java.core.foundational.syntax.type;

/** * 布尔型 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-26 10:15 * @website www.ittimeline.net * @since JDK11 */
public class BooleanTest {

    public static void main(String[] args) {



        //产生2个0-1之间的随机小数
        double source=Math.random();
        double target=Math.random();

        System.out.println("source = "+source);
        System.out.println("target = "+target);
        // >就是关系运算
        boolean result=source>target;
        System.out.println("result = "+result);
        //这里等价于result==true
        if(result){
            System.out.println("source > target");
        }else{
            System.out.println("source < target");
        }
    }
}

2.8 字符型

Java中的字符使用char表示，用于存储单个字符,字符型的变量值使用''包含。
因为Java使用16位的Unicode做为编码方式，而Unicode是国际组织制定的能够容纳世界上全部文字和符号的字符编码方案，所以Java程序支持各类语言的字符。

除此之外char还能使用Unicode表示字符，因为其占据2个字节空间大小，其表示范围是\u0000 - \uFFFF。在平常开发中还会使用到一些经常使用的转义字符，例如实现换行的\n以及实现路径转义的\等等。

字符在计算机底层都是以数字的方式存储的，例如字符'a'底层的数字是97，'A'底层的数字是65，字符'0'的底层数字是48，而后依次递增。

package net.ittimeline.java.core.foundational.syntax.type;

/** * 字符型 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-26 10:15 * @website www.ittimeline.net * @since JDK11 */
public class CharacterTest {

    public static void main(String[] args) {

        //Java支持Unicode标准，能够存储世界上全部国家的语言文字
        //英文
        char english='L';
        //中文
        char chinese='刘';
        //日文
        char japan='お';
        //韩文
        char korean='안';

        System.out.println("english = "+english);
        System.out.println("chinese = "+chinese);
        System.out.println("japan = "+japan);
        System.out.println("korean = "+korean);

        char A='\u0041';
        //大写字母A对应的数字是65
        System.out.println("unicode \\u0041 对应的字符是 = "+A);
        char a='\u0061';
        //小写的字母a对应的数字是97
        System.out.println("unicode \\u0061对应的字符是 = "+a);
        //字符0对应的数字是48
        char zero='\u0030';
        System.out.println("unicode \\u002F对应的字符是"+zero);



        char newLine='\n';
        System.out.print("hello"+newLine+"world");

        char path='\\';
        System.out.println("path = "+path);

    }
}

2.9 数据类型转换

2.9.1 数据类型自动转换

Java中的八种基本数据类型除了boolean以外，在进行算术运算时，会按照以下的规则进行自动类型转换。

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

当byte,short,char三种类型的变量运算时结果类型为int

byte和byte运算的结果类型是int
byte和short运算的结果类型是int
byte和char运算的结果类型是int
char和char运算的结果类型是int
char和short运算的结果类型是int
int和int运算的结果类型是int
byte,short,int,long和float运算结果类型是float
byte,short,int,long,float和double运算结果类型是double

即表示范围小的变量会自动提高为表示范围大的变量，这里的表示范围指的是数据类型对应的取值范围，而不是数据类型占用的内存空间,例如float取值范围要大于long的取值范围。

自动类型转换能够在必定程度上避免进行运算的时候结果超过数据类型的极限而形成程序错误。

package net.ittimeline.java.core.foundational.syntax.convert;

/** * 自动类型转换 * 八种基本数据类型除了boolean以外在进行运算时会进行自动类型转换 * * 在进行运算时，容量小的数据类型的变量与容量大的大数据类型的变量作运算时，结果自动提高为容量大的数据类型,防止运算时超过极限值。 * 此时容量大小指的是，数据类型表示数的范围大小，而不是占用内存大小，好比float容量大于long的容量 * byte -> short-> int-> long-> float ->double * byte,short,char->int->long->float->double * * byte、short、char运算后的结果类型必须是int * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-27 08:53 * @website www.ittimeline.net * @since JDK11 */
public class AutoConvert {
    public static void main(String[] args) {

        //byte和int运算的结果是int
        byte byteVal=12;
        int intVal=12;
        //若是用byte存储运算结果，会编译失败
        int intResult=byteVal+intVal;
        System.out.println("intResult = "+intResult);


        float floatResult=byteVal+intVal;
        System.out.println("floatResult = "+floatResult);

        //容量小的变量值自动转换为容量大的变量
        short  shortVal=12;
        double dblValue=shortVal;


        char ch='a';
        int intNewValue=123;
        int intNewResult=ch+intNewValue;
        System.out.println("intNewResult = "+intNewResult);


         byte sourceByte=12;
         char targetChar=12;
         int  resultInt=sourceByte+targetChar;


        //short和char运算结果类型是int
        short shortNewVal=29;
        char newChar='b';
        int result=shortNewVal+newChar;

        // byte和byte运算也是int
        byte source=12;
        byte target=12;
        int sourceTarget=source+target;
        System.out.println("sourceTarget = "+sourceTarget);


        //int
        int maxTarget=Integer.MAX_VALUE;
        int maxSource=Integer.MAX_VALUE;

        //这里已经超出了int表示的最大值，所以输出的结果是错误的
        int maxResult=maxSource+maxTarget;
        System.out.println("maxResult = "+maxResult);

    }
}

2.9.2 数据类型强制类型转换

而在某些应用场景下咱们还可能会使用到强制类型转换，例如数据库查询返回的结果是long类型，可是须要强制转换为int类型。
强制类型转换是自动类型转换的逆运算，使用强转符()实现，若是强转的变量超过目标类型的最大值会损失精度。

package net.ittimeline.java.core.foundational.syntax.convert;

/** * 强制类型转换 * 强制类型转换是自动类型转换的逆运算 * 须要使用强转符:() * 强制类型转换可能会丢失精度 * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-27 09:08 * @website www.ittimeline.net * @since JDK11 */
public class NarrowConvert {


    public static void main(String[] args) {

        double dblVal=12.8;
        System.out.println("dblVal = "+dblVal);
        //强制类型转换 (强转类型)
        int intVal=(int)dblVal;
        //强制转换可能会损失精度
        System.out.println("intVal = "+intVal);

        //若是转换的变量值(例如这里的12)在强制转换类型的表示范围以内(例如这里的byte)则不会损失精度
        long longVal=12;
        byte byteVal=(byte)longVal;
        System.out.println("longVal = "+longVal+ " byteVal = "+byteVal);


        int sourceVal=128;
        byte targetVal=(byte)sourceVal;

        //这里会损失精度，由于128已经超过了byte存储的最大值
        System.out.println("sourceVal = "+sourceVal+ " targetVal = "+targetVal);



    }
}

在给变量赋值时，若是变量的值没有超过变量类型的极限，赋值时也会发送自动类型转换，可是若是赋值时变量的值超过了变量类型的极限，那么此时就须要使用到强制类型转换实现。

package net.ittimeline.java.core.foundational.syntax.convert;

/** * 类型转换的特殊状况 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-27 09:18 * @website www.ittimeline.net * @since JDK11 */
public class ConvertFeature {

    public static void main(String[] args) {
        //整型常量默认为int,浮点常量默认为double


        //虽然long类型的变量值必须加上L后缀，可是这里的123就是int,这里实际上就是发生了自动类型转换
        long longSourceVal=123;

        System.out.println("int max"+Integer.MAX_VALUE);
        // 由于2147483648超过了int表示的最大值，因此这里必须加上L后缀
        long bigSource=2147483648L;
        System.out.println(" bigLongSource = "+bigSource);



        //3.14默认是double类型，在赋值是必须使用强制类型转换
        //由于将表示范围大的值赋值给表示范围小的变量必须强制类型转换
        float fltVal= (float) 3.14;

        //整型默认的是int类型
        byte byteVal=12;
        int result=byteVal+1;

        //浮点型默认是double
        double dblVal=12.3+byteVal;
        System.out.println("dblVal = "+dblVal);



    }
}

2.10 String

2.10.1 字符串变量

平常开发中最经常使用的数据类型是String，它用于存储字符串，使用" "包含起来，String位于java.lang包下，属于引用类型的一种,底层是字符数组。

String类型变量的定义以及与char类型的比较

package net.ittimeline.java.core.foundational.syntax.type;

/** * 字符串变量 * <p> * String用于存储字符串(多个字符)，属于引用数据类型 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-27 09:22 * @website www.ittimeline.net * @since JDK11 */
public class StringTest {

    public static void main(String[] args) {
        //String类型的变量定义 变量值使用""包含
        String str = "Hello World";

        String charConent = "c";
        System.out.println("charContent = " + charConent);

        //空字符
        char emptyC = ' ';
        System.out.println("emptyC= [" + emptyC + "]");
        //空字符串
        String emptyStr = " ";
        System.out.println("emptyStr= [" + emptyStr + "]");
    }
}

2.10.2 字符串链接

String能够和八种基本数据类型使用加号(+)作链接运算,运算的结果类型是String。
String类型与基本数据类型的链接运算，若是加号先后有String类型的变量，那么此时的加号就是表示链接，若是+先后没有String，此时的加号表示算术运算的加法。

package net.ittimeline.java.core.foundational.syntax.type;

/** * 字符串与八种基本数据类型的运算 * 字符串能够和八种基本数据类型进行链接运算,使用+表示链接，运算的结果类型是String类型 * +符号先后有String表示链接，没有String表示算术运算的加法 * * @author liuguanglei ittimelinedotnet@gmail.com * @create 2019-07-27 09:29 * @website www.ittimeline.net * @since JDK11 */
public class StringOperatorTest {
    public static void main(String[] args) {

        String info="";
        int age=18;
        String name="刘光磊";
        double height=176.0;
        boolean isMarry=false;
        long id=362352355643454356L;

        info="id : "+id+"姓名:"+name+"\n年龄:"+age+"\n身高:"+height+"\n是否已婚"+isMarry;
        System.out.println("******我的信息******");
        System.out.println(info);


        //判断+表示字符串链接仍是算术运算的加法
        char charVal='a';
        int number=10;
        String str="hello";
        //第一个加法先后都不是String，所以表示加法，而不是字符串链接，而a表示97，第二个加法后面是String，所以表示字符串链接
        //最后的运算结果是107hello
        System.out.println(charVal+number+str);
        //第一个加法后面是String,运算结果是ahello10
        System.out.println(charVal+str+number);
        //第一个加法后面是String，运算结果是ahello10
        System.out.println(charVal+(str+number));
        //第一个加法先后都不是String,所以加号表示算术运算符的加法运算，最后的运算结果是107hello
        System.out.println((charVal+number)+str);

        String star="*";
        char tab='\t';
        String content=star+tab+star;
        System.out.println("content ="+content);

    }

}

2.11 数据在内存中的存储方式

数据在内存中有三种表现方式:原码、反码和补码
数据在内存中都是以二进制的补码存储，在理解补码以前首先得理解原码以及反码。

原码就是一个数据自己的二进制表现形式，而数值能够分为有符号和无符号两种。
有符号数其二进制表示最高位(最左边)是符号位，1表示负数，0表示正数。

例如无符号数15的原码使用一个字节表示为0000 1111
例若有符号15的原码使用一个字节表示为0000 1111
例若有符号-15的原码使用一个字节表示为1000 1111

反码
无符号数的反码等于原码
例如无符号数15的反码等于原码，即无符号数15的反码用一个字节表示为0000 1111

有符号数正数的反码也等于原码
例若有符号正数15的反码等于原码，即有符号数15的反码用一个字节表示为0000 1111

有符号负数的反码是原码最高位不变，其余位取反
例若有符号负数-15的反码是原码最高位不变，其余位取反用一个字节表示为1111 0000

补码
无符号数的补码等于反码
例如无符号数15的补码等于反码，即无符号数15的补码使用一个字节表示为0000 1111

有符号正数的补码等于反码
例若有符号正数15的补码等于反码，即有符号正数15的补码使用一个字节表示为0000 1111

有符号负数的补码等于反码加1
例若有符号负数-15的补码等于反码1111 0000加1，即有符号负数15的补码使用一个字节表示为11111 0001

数值	是否有符号	原码	反码	补码
15	否	0000 1111	0000 1111	0000 1111
15	是	0000 1111	0000 1111	0000 1111
-15	是	1000 1111	1111 0000	1111 0001

无符号数以及有符号正数，计算机存储的是原码，由于原码等于反码有符号负数计算机存储的是补码，补码等于原码取反加1，原码等于补码取反加1。

个人全栈之路-Java基础之数据存储

个人全栈之路-Java基础之数据存储

2.1 标识符

2.2 变量

2.2.1 变量的概述

2.2.2 变量的定义和使用

2.2.4 变量的分类

2.2.5 变量的交换

2.3 数据类型

2.4 JDK1.5新特性 自动拆箱和装箱

2.5 整型

2.5.1 Java整型的极限

2.5.2 大整数BigInteger

2.5.3 整数的四种进制类型

2.5.4 数值字面量使用下划线

2.6 浮点型

2.6.1 浮点型的两种表示方式

2.6.2 浮点型的极限以及存储方式

2.6.3 浮点数精度问题

2.7 布尔型

2.8 字符型

2.9 数据类型转换

2.9.1 数据类型自动转换

2.9.2 数据类型强制类型转换

2.10 String

2.10.1 字符串变量

2.10.2 字符串链接

2.11 数据在内存中的存储方式

2.4 JDK1.5新特性自动拆箱和装箱