数据类型

最新推荐文章于 2023-04-04 18:52:08 发布

编程搬运工

最新推荐文章于 2023-04-04 18:52:08 发布

阅读量194

点赞数

分类专栏： Java基础知识

本文链接：https://blog.csdn.net/qq_42857603/article/details/81607782

版权

Java基础知识专栏收录该内容

27 篇文章 0 订阅

订阅专栏

Java语言把数据类型分为基本类型和引用类型

数据类型

基本类型:byte short int long float double char boolean
引用类型:类类型接口类型数组类型
计算机中:
1字节=8位
0000 0001

※ 整数类型

byte, short, int和long都是整数类型，并且都是有符号整数。与有符号整数对应的是无符号整数，两者的区别在于把二进制数转换为十进制整数的方式不一样。

. 有符号整数把二进制数的首位作为符号数，当首位是0时，对应十进制的正整数，当首位是1时，对应十进制的负整数。对于一个字节的二进制数, 它对应的十进制数的取值范围是-128 - 127。
. 无符号整数把二进制数的所有位转换为正整数。对于一个字节的二进制数, 它对应的十进制数的取值范围是0-255。

在Java语言中，为了区分不同进制的数据，八进制数以“0”开头，十六制以“0x”开头。
例如:
一个字节的二进制数八进制数十六进制数有符号十进制数无符号十进制数
————————————————————————————————-
0000 0000 0000 0x00 0 0
1111 1111 0377 0xFF -1 255
0111 1111 0177 0x7F 127 127
1000 0000 0200 0x80 -128 128

整形型: 默认数据类型是int
byte (8位)
byte a = 10;

short (16位)
short a = 20;

int (32位)
int a = 30;

long (64位)
long a = 40L;
long b = 50l;
声明的时候后面要加大写L或者小写l,建议加上大写的L,因为小写的l和数字1很像似。

具体表示数大小：
1）byte 8位
Max
0000 0000
0111 1111
+1
1000 0000 2^7-1
Min
1000 0000
符号位不变，取反加一
1111 1111
+1
1000 0000 -2^7

2）short 16位 2^15-1 -2^15
3）int 32位 2^31-1 -2^31
4）long 64位 2^63-1 -2^63

※ 浮点型数据
java中表示小数的数据类型
浮点型:默认数据类型是double

float (32位)
float a = 10.3f;

double (64位)
double a = 10.8d;

boolean 8位（true/false)
char 16位(java中采用unicode编码,所以是俩个字节表示一个字符,那也就是说在其他字符编码中可能不是使用俩个字节表示一个字符)

※ boolean类型
boolean类型的值为 true或者false,在JVM中会转换为0或者1
0代表的是false 1代表的是true
boolean flag = ture;
boolean bool = false;

※ char类型
注意: char是字符和字符串String是不一样的
字符串String是类,而字符char是基本数据类型
字符串String是由一个一个的字符char组成的

1) 字符编码

Java语言对文本字符采用Unicode字符编码。由于计算机内存只能存取二进制数据，因此必须为各个字符进行编码。
所谓字符编码，是指用一串二进制数据来表示特定的字符。常见的字符编码包括：

a. ASCII字符编码
ASCII–Amecian Standard Code for Information Interchange(美国信息交换标准代码). 主用于表达现代英语
和其他西欧语言中的字符。它是现今最通用的单字节编码系统，它只用一个字节的7位，一共表示128个字符。

b. ISO-8859-1字符编码
又称为Latin-1, 是国际标准化组织(ISO)为西欧语言中的字符制定的编码，用一个字节(8位)来为字符编码，与
ASCII字符编码兼容。所谓兼容，是指对于相同的字符，它的ASCII字符编码和ISO-8859-1字符编码相同。

c. GB2312字符编码
它包括对简体中文字符的编码，一共收录了7445个字符(6763个汉字+682个其他字符. 它与ASCII字符编码兼容。

d. GBK字符编码
对GB2312字符编码的扩展，收录了21886个字符(21003个字符+其它字符), 它与GB2312字符编码兼容。

e. Unicode字符编码：
由国际Unicode协会编制，收录了全世界所有语言文字中的字符，是一种跨平台的字符编码。
UCS(Universal Character Set)是指采用Unicode字符编码的通用字符集。
Unicode具有两种编码方案：
. 用2个字节(16位)编码，被称为UCS-2, Java语言采用;
. 用4个字节(32位)编码，被称为UCS-4;

f. UTF字符编码
有些操作系统不完全支持16位或32位的Unicode字符编码，UTF(UCS Transformation Format)字符编码能够把
Unicode字符编码转换为操作系统支持的编码，常见的UTF字符编码包括UTF-8, UTF-7和UTF-16.

2) char的几种可能取值

Java语言采用Unicode字符编码，字符占2个字节。
字符a的二进制数据形式为 0000 0000 0110 0001
十六进制数据形式为 0x0061
十进制数据形式为 97

以下5种赋值方式是等价的：
字符用单引号引着(英文输入法下面的单引号)
字符串用双引号引着

char c = ‘a’;
char c = ‘\u0061’; //设定”a”的十六进制数据的Unicode字符编码
char c = 0x0061; //设定”a”的十六进制数据的Unicode字符编码 0x开头的数字位16进制
char c = 97; //设定”a”的十进制数据的Unicode字符编码
char c = 0141; //设定”a”的八进制数据的Unicode字符编码0开头的数字位16进制
其他一些例子:
char a1 = ‘a’; //一个字母
char a2 = ‘中’; //一个中文字符
char a3 = ‘\u0060’ //unicode编码

3) 转义字符

Java编程人员在给字符变量赋值时，通常直接从键盘输入特定的字符，而不会使用Unicode字符编码，因为很难记住各种字符的Unicode字符编码值。

对于有些特殊字符，比如单引号，如不知道它的Unicode字符编码，直接从键盘输入编译错误：

char c = ”’; //编码出错

为了解决这个问题，可采用转义字符来表示单引号和其他特殊字符：

char c = ‘\”;
char c = ‘\’;

转义字符以反斜杠开头，常用转义字符：
\r 回车符
\n 换行符，将光标定位到下一行的开头；
\t 垂直制表符，将光标移到下一个制表符的位置；
\ 反斜杠字符
\’ 单引号字符
\” 双引号字符

※ 变量的申明和赋值：

程序的基本功能是处理数据
程序用变量来表示数据；
程序中必须先定义变量才能使用；
定义变量是指设定变量的数据类型和变量的名字，定义变量的基本语法为：

数据类型变量名[=变量值]；

Java语言要求变量遵循先定义，再初始化，然后使用的规则。变量的初始化是指自从变量定义以后，首次给它赋初始
值的过程。例：

int a; //定义变量a
a = 1; //初始化变量a
a++; //使用变量a（先使用a的值，再加）
int b=a; //定义变量b, 初始化变量b, 使用变量a的值;
b++; //使用变量b

※ 基本类型间的转换:

隐式转换:(不需要我们做什么,JVM自动转换)
byte a = 10;
int b = a;

显示转换:(需要我们手动写上转换的类型)
int a1 = 10;
byte b1 =(byte)a1;

byte a = 1;
byte b = 2;

int c = a+b;
byte c2 = (byte)a+b;（相加后隐式转换成int类型）

float a = 8.9f;
double b = a;

float a; 变量的声明
float a = 8.9f; 变量的声明并且赋值
double b = 10 - a;

double a = 8.9;
double b = 10 - a;

报错:
double a = 8.9;
float b = 10 - a;
符号位不同会出现资源丢失。

※ 类型转换

1）隐式转换:自动转换
基本类型:精度小可以自动转换为精度大的
byte b = 1;
int a = b;
引用类型:子类类类型可以自动转换为父类类型
Student s = new Student();
Object o = s;
2）显式转换:强制类型转换
基本类型:精度大的可以强制类型转换为精度小的,但是可能损失精度
int a = 1;
byte b = (byte)a;
引用类型:父类类型可以强制类型转换转换为子类类型，但是可能出现类型转换错误
Object类是 Student类的父类
//这个是正确的
Object o = new Student();
Student s = (Student)o;
//这个会报错
Object o1 = new Object();
Student s1 = (Student) o1;

※ 基本数据类型对应的包装类型

为了将数据变为对象可以使用，我们将数据类型进行包装成相应的类。

boolean     Boolean
byte        Byte
short       Short
char        Character
int         Integer
long        Long
float       Float
double      Double

※ 把基本数据类型转化为包装类型（装箱）
int n=10;
Integer nn=new Integer(n);

※ 把包装类型转化为基本数据类型（拆箱）
int s=nn.intValue();

装箱和拆箱的过程都是自动的
需要什么类型直接定义（自动完成）
Integer n=10；
int s=n;
Boolean f=true;
boolean h=f;
注：具体查看Java.lang包下的各个包装类。

※ Integer

此处依Integer为例：

package com.briup.ObjetEquals;

public class TeaTest {
    public static void main(String[] args) {
        //获取int类型的最大值
        System.out.println(Integer.MAX_VALUE);
        //获取int类型的最小值
        System.out.println(Integer.MIN_VALUE);
        //获取int类型的位数
        System.out.println(Integer.SIZE);
        //获取Integer包装的类型
        System.out.println(Integer.TYPE);
        int n=97;
        //装箱（把基本数据类型转化为包装类型）
        Integer in=new Integer(n);
        float f=in.floatValue();
        System.out.println(f);
        //拆箱（把包装类型转化为基本数据类型）
        int xx=in.intValue();
        System.out.println(xx);
        System.out.println(in);
        String num="97";
        Integer ns=new Integer(num);

        System.out.println(ns);
        System.out.println(ns.toString());
        //把基本数据类型转化为十六进制
        System.out.println(Integer.toString(n,16 ));
        //把基本数据类型转化为八进制
        System.out.println(Integer.toString(n,8));
    }
}

package com.briup.ObjetEquals;

import java.util.Properties;

public class SecondTest {
    public static void main(String[] args) {
        /*//装箱和拆箱自动完成
        int n=10;
        //装箱
        Integer t=n;
        //拆箱
        int t1=t;*/
        Integer m=56;
  //bitCount统计int类型的二进制1的数量
        System.out.println(Integer.bitCount(7));//0111
        System.out.println(Integer.bitCount(10));//1010

    //将数字类型的字符串转化为包装类
        Integer nn=Integer.decode("123");
    System.out.println(nn);
    Integer n=new Integer(12);
    Integer n1=new Integer(12);

        //比较的也是值，equals重写了
    System.out.println(n.equals(n1));
        //获取JVM运行所有系统参数
    Properties pro=System.getProperties();
    for(Object key:pro.keySet()){
            System.out.println(key+"--"+pro.get(key));
    }

        //获取JVM的系统参数
        Integer n=Integer.getInteger("sun.java.command");
    System.out.println("----"+n);

    //获取int类型二进制的最高位1表示的值
    System.out.println(Integer.highestOneBit(10));//1010 1000
    System.out.println(Integer.highestOneBit(7));//0111 0100
    System.out.println(Integer.lowestOneBit(7));//0111 0100
        String str="97";

//将字符串类型的数字转化为int类型（默认是10进制）
    int n=Integer.parseInt(str);
    System.out.println(n);

//将某个类型（二进制，八进制 十六进制，10进制）
        //的转化为int进制
       int n1=Integer.parseInt("61",16);
       System.out.println(n1);

        //将10进制转化为二进制
        System.out.println(Integer.toBinaryString(12));
        //等价前面的parseInt()方法;
        System.out.println(Integer.valueOf("0111", 2));
    }
}