Java基本数据类型学习

最新推荐文章于 2023-05-10 00:03:14 发布

weixin_53445035

最新推荐文章于 2023-05-10 00:03:14 发布

阅读量139

点赞数

分类专栏：学习日记文章标签：字符串 java

本文链接：https://blog.csdn.net/weixin_53445035/article/details/111303509

版权

学习日记专栏收录该内容

8 篇文章 0 订阅

订阅专栏

Java基本数据类型

Java数据类型

Java中的数据类型分为两类,分别是***基本数据类型*** 和 引用数据类型 ,这里先介绍基本数据类型

基本数据类型分类

Java中的基本数据类型分为三类,数值型,布尔型和字符型
数值型数据分为两类,分别是整数类型和浮点数类型
整数类型的默认值为0
浮点数类型的默认值是0.0
布尔型数据的默认值是false
字符型数据的默认值是**’\u0000’**
整数类型包含四种数据类型,按数据储存范围从小到大依次为byte,short,int,和long
浮点类型包含两种数据类型,按数据储存范围从小到大依次为是float和double
int型的保存范围为**-2147483648~2147483647**
boolean型的保存范围为true和false

如何给一个变量赋值

数据类型变量名称 = 内容 ;

例子

int num = 10 ;
boolean flag = true ;
double number = 10.1 ;
char c = '葱' ;
String str = "葱头哥" ;

整数类型

整数类型包括

byte类型 1字节

short类型 2字节

int类型 4字节

long类型 8字节

提示一个字节包含八个位(bit)
整数类型的默认类型为int型,当数据的数值大于int类型的范围时,就会发生数据溢出现象

数据溢出现象与解决方法

观察数据溢出现象

public class JavaDemo {
    public static void main ( String args [] ) {
        int max = 2147483647 ;	// 把int类型的最大数值赋值给变量max
        int min = -2147483648 ;	// 把int类型的最小数值赋值给变量min
        System.out.println( max + 1 ) ;
        System.out.println( min - 1 ) ;
    }
}
/* 以下为代码执行后输出的内容
 * -2147483648	 max + 1 的结果
 * 2147483647	 min - 1 的结果
 */

观察后可发现,int类型的最大数值加一,结果为int类型的最小数值

int类型的最小数值减一,结果为int类型的最大数值

这种现象就是数据溢出

数据溢出的原因

拿int型数据为例,byte型数据的保存范围为**-128~127**

我们知道,计算机是由许多晶体管组成的,晶体管只有两种状态,通电和断电,分别用1和0表示,因此任何保存在计算机中的数据,归根结底都是由"0"和"1"来表示

byte型数据共有256个,其中的每一个数字与 0000 0000 ~ 1111 1111(=255)中的每一个数字一一对应

(byte)0 ~127 用 0000 0000 ~ 0111 1111 来表示

(byte)-128 ~ -1 用 1000 0000 ~ 1111 1111 来表示,也就是说128 ~ 255 这些数字在计算机内部用来表示 -1 ~ -128,对应关系为-x 与 256 - x 对应

根据以上信息,

我们可以推测出127 + 1 = 128 即二进制的 0b1000 0000 ,但是因为在Java内部 0b 1000 0000 用来表示 -128,因此计算的结果会显示为 -128
当我们计算-128 - 1的时候,实际执行的运算是 0b 1000 0000 - 1即 ,128 - 1 , 实际的结果是 127

因此会有如下现象

public class JavaDemo {
    public static void main ( String args[] ) {
        byte max = 127 ;
        byte min = -128 ;
        System.out.println( max + 1 ) ;
        System.out.println( min - 1 ) ;
    }
}
执行结果:
128
-129
/* 我们发现此时并没有出现数据溢出,因为Java中整型的默认保存类型为int型,
计算结果超出了byte型的保存范围,自动转化为int型,想要观察数据溢出,则需要
把计算结果强制转化为byte型 */

public class JavaDemo {
    public static void main ( String args[] ) {
        byte max = 127 ;
        byte min = -128 ;
        System.out.println( (byte)(max + 1) ) ;
        System.out.println( (byte)(min - 1) ) ;
    }
}
执行结果:
-128
127

数据溢出解决方法

方法一将int型常量转换成long型常量,在数字后加"L"或者"l"即可,建议加"L",因为"l"和数字"1"容易混淆

方法二将int型变量转换成long型变量,使用"(long) 变量名称"即可

方法一代码如下所示

public class JavaDemo {
    public static void main ( String args [] ) {
        int max = 2147483647 ;
        int min = -2147483648 ;
        System.out.println( max + 1L ) ;
        System.out.println( min - 1l ) ;
    }
}
/* 以下为代码的输出结果
 * 可以观察到在常量1后加上"L"或者"l"后
 * 输出的结果就是正确结果
 * 2147483648
 * -2147483649
 */

方法二代码如下所示

public class JavaDemo {
    public static void main ( String args [] ) {
        long max = 2147483647 ;
        long min = -2147483648 ;
        System.out.println( max + 1 ) ;
        System.out.println( min - 1 ) ;
    }
}
/* 以下为代码执行后输出的结果
 * 2147483648
 * -2147483649
 * 观察后发现本次计算的结果正确
 */

整数类型的进制

二进制/八进制/十进制/十六进制的数字在Java中都默认保存为int型

二进制用0b表示,比如0b11表示十进制的数字3
八进制用0+数字表示,比如010表示十进制的数字8

十六进制用0x表示,比如0x10表示十进制的数字16

下面用代码验证一下

public class JavaDemo {
    public static void main(String[] args) {
        int a0 = 10;
        int a1 = 0b1;
        int a2 = 010;
        int a3 = 0x10;
        int a4 = 0xA;
        int a5 = 0xB;
        int a6 = 0xC;
        int a7 = 0xD;
        int a8 = 0xE;
        int a9 = 0xF;
        System.out.println("10 = "+ a0);
        System.out.println("0b1 = "+ a1);
        System.out.println("010 = "+ a2);
        System.out.println("0x10 = "+ a3);
        System.out.println("0xA = "+ a4);
        System.out.println("0xB = "+ a5);
        System.out.println("0xC = "+ a6);
        System.out.println("0xD = "+ a7);
        System.out.println("0xE = "+ a8);
        System.out.println("0xF = "+ a9);
    }
}
执行结果:
10 = 10
0b1 = 1
010 = 8
0x10 = 16
0xA = 10
0xB = 11
0xC = 12
0xD = 13
0xE = 14
0xF = 15

浮点类型

Java中任意一个小数常量对应的类型为double,所以在定义浮点型常量的时候尽量定义为double
如果想要定义一个float变量,必须进行强制转换,否则程序将会报错

public class JavaDemo {
    public static void main ( String args [] ) {
        float x = 10.1 ;
        System.out.println( x ) ;
    }
}
程序执行后报错:
JavaDemo.java:3: 错误: 不兼容的类型: 从double转换到float可能会有损失
        float x = 10.1 ;
                  ^
1 个错误

正确的定义float型变量的操作如下

public class JavaDemo {
    public static void main ( String args [] ) {
        float x = (float) 10.1 ;
        float y = 111.2F ;
        System.out.println( x ) ;
        System.out.println( y ) ;
    }
}
执行结果:
10.1
111.2

整型数据不能整除时,使用int型数据输出的结果会抹去小数位,想要得到准确数据,需要把两个中至少一个强制转换为浮点型,则输出的结果为浮点型数据

public class JavaDemo {
    public static void main ( String args [] ) {
        int x = 10 ;
        int y = 3 ;
        System.out.println( x/y ) ;
    }
}
执行结果:
3

结果为整形数据,并非准确计算结果

public class JavaDemo {
    public static void main ( String args [] ) {
        int x = 10 ;
        int y = 3 ;
        System.out.println( (double) x/y ) ;
        System.out.println( x/ (float) y ) ;
    }
}
执行结果:
3.3333333333333335
3.3333333

结果为double型数据和float型数据,我们发现计算结果同Python一样存在不确定尾数

浮点数类型的bug

观察如下代码

public class JavaDemo {
    public static void main(String[] args) {
        float a = 1896541896418915641F;
        double b = a + 1;
        float c = 0.1F ;
        double d = 0.1 ;
        System.out.println(a == b);
        System.out.println(c == d);
    }
}

执行结果:

true
false

实际上,a和b明显不相等,c和d明显相当,但是Java却给出了截然相反的结论

这是浮点数类型的特点决定的,在今后的比较中,最好完全不要对浮点数进行比较

var关键字的使用

Java为静态语言,为了迎合市场需求,JDK1.10后Java出现动态语言支持

例子

public class JavaDemo {
    public static void main ( String args [] ) {
        var x = 10 ;
        var y = 3.14 ;
        System.out.println( x ) ;
        System.out.println( y ) ;
    }
}

字符类型

字符型变量的定义

char 变量名称 = ‘字符’ ;

public class JavaDemo {
    public static void main ( String args [] ) {
        char c = '吴' ;
        System.out.println( c ) ;
    }
}

英文字母和阿拉伯数字的Unicode编码范围

Java中的所有字符都使用的Unicode编码,此类编码可以表示所有字符,包括中文字符Unicode编码占两个字节,能够表示65536个字符(2^16)

大写字母 65(‘A’)~90(‘Z’)

小写字母 97(‘a’)~122(‘z’)

数字 48(‘0’)~57(‘9’)

char与int的相互转换

char与int型常量的强制转换,可利用此特点进行大小写字母的转换

public class JavaDemo {
    public static void main ( String args [] ) {
        int num = (int) 'a' ;
        char c = (char) 65 ;
        char C = (char) (65 + 32) ;
        char Z =  (char) ((int) 'z' +32) ;
        System.out.println( num ) ;
        System.out.println( c ) ;
        System.out.println( C ) ;
    }
}
执行结果:
97
A
a

定义中文字符的乱码问题解决方法

定义中文字符编译时会出现如下错误,可以在Javac 后跟上 -encoding UTF-8即可解决

C:\Users\86131\Desktop>javac JavaDemo.java
JavaDemo.java:3: 错误: 编码 GBK 的不可映射字符 (0xB4)
        char c = '鍚?' ;
                   ^
JavaDemo.java:3: 错误: 未结束的字符文字
        char c = '鍚?' ;
                 ^
JavaDemo.java:3: 错误: 未结束的字符文字
        char c = '鍚?' ;
                    ^
3 个错误

C:\Users\86131\Desktop>javac -encoding UTF-8 JavaDemo.java

C:\Users\86131\Desktop>java JavaDemo
吴

注意字符与字符串的区别

C:\Users\86131\Desktop>javac -encoding UTF-8 JavaDemo.java
JavaDemo.java:3: 错误: 未结束的字符文字
        char c = '吴安师大' ;
                 ^
JavaDemo.java:3: 错误: 未结束的字符文字
        char c = '吴安师大' ;
                      ^
JavaDemo.java:3: 错误: 不是语句
        char c = '吴安师大' ;
                   ^
3 个错误

布尔类型

布尔型是一种逻辑结果,主要储存两类数据:true和false

例子

public class JavaDemo {
    public static void main ( String args [] ) {
        boolean flag = true ;
        if ( flag ) {
            System.out.println("判断结果为true时执行此语句") ;
        }
    }
}
执行结果:
判断结果为true时执行此语句

字符串

字符串的定义

String 变量名称 = “字符串” ;

例子

public class JavaDemo {
    public static void main ( String args [] ) {
        String str = "这是一个字符串" ;
        System.out.println(str) ;
    }
}
执行结果:
这是一个字符串

字符串的连接

public class JavaDemo {
    public static void main ( String args [] ) {
        int x = 10 ;
        int y = 11 ;
        boolean flag = true ;
        String str = "结果为" + x + y ;
        String str1 = "结果为" + (x + y) ;
        String str2 = "结果为:" + x * y ;
        String str3 = "结果为" + flag ;
        String str4 = "结果为" + flag + x ;
        System.out.println( str ) ;
        System.out.println( str1 ) ;
        System.out.println( str2 ) ;
        System.out.println( str3 ) ;
        System.out.println( str4 ) ;
    }
}
执行结果:
结果为1011
结果为21
结果为:110
结果为true
结果为true10

java中没有把字符串*N次等于把字符串赋值N遍的操作,这样操作在Java中会报错
对于上面代码执行结果的分析

字符串与整数或者浮点数进行加法运算,输出结果为字符串

若整数之间用括号先进行数值运算,则数值运算后的结果与原字符串相加产生新字符串

若表达式中存在乘法运算,则按四则运算顺序,先进行乘法运算,而后进行字符串连接运算

字符串与布尔型数据相加,结果为字符串

布尔型数据不可与整型或者浮点型数据进行运算