← 返回学习路线

SYSTEM

数据

Java基础数据system
src/content/notes/system/数据.md

基础

数据

变量类型

成员变量 局部变量 静态变量
定义位置 在类中,方法外 方法中或者方法的形参 在类中,方法外
初始化值 有默认初始化值 无,赋值后才能使用 有默认初始化值
调用方法 对象调用 对象调用,类名调用
存储位置 堆中 栈中 方法区(JDK8 以后移到堆中)
生命周期 与对象共存亡 与方法共存亡 与类共存亡
别名 实例变量 类变量,静态成员变量

静态变量只有一个,成员变量是类中的变量,局部变量是方法中的变量

初学时笔记内容参考视频:https://www.bilibili.com/video/BV1TE41177mP,随着学习的深入又增加很多知识


数据类型

基本类型

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

byte:

  • byte 数据类型是 8 位、有符号的,以二进制补码表示的整数,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 位 4 字节、有符号的以二进制补码表示的整数
  • 最小值是 -2,147,483,648(-2^31)、最大值是 2,147,483,647(2^31 - 1)
  • 一般地整型变量默认为 int 类型
  • 默认值是 0
  • 例子:int a = 100000, int b = -200000

long:

  • long 数据类型是 64 位 8 字节、有符号的以二进制补码表示的整数
  • 最小值是 -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 理论上不分大小写,但是若写成 I 容易与数字 1 混淆,不容易分辩

float:

  • float 数据类型是单精度、32 位、符合 IEEE 754 标准的浮点数
  • float 在储存大型浮点数组的时候可节省内存空间
  • 默认值是 0.0f
  • 浮点数不能用来表示精确的值,如货币
  • 例子:float f1 = 234.5F

double:

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

boolean:

  • boolean 数据类型表示一位的信息
  • 只有两个取值:true 和 false
  • JVM 规范指出 boolean 当做 int 处理,boolean 数组当做 byte 数组处理,这样可以得出 boolean 类型单独使用占了 4 个字节,在数组中是 1 个字节
  • 默认值是 false
  • 例子:boolean one = true

char:

  • char 类型是一个单一的 16 位两个字节的 Unicode 字符
  • 最小值是 \u0000(即为 0)
  • 最大值是 \uffff(即为 65535)
  • char 数据类型可以存储任何字符
  • 例子:char c = 'A',char c = '张'

上下转型
  • float 与 double:

    Java 不能隐式执行向下转型,因为这会使得精度降低,但是可以向上转型

    //1.1字面量属于double类型,不能直接将1.1直接赋值给 float 变量,因为这是向下转型
    float f = 1.1;//报错
    //1.1f 字面量才是 float 类型
    float f = 1.1f;
    float f1 = 1.234f;
    double d1 = f1;
    
    double d2 = 1.23;
    float f2 = (float) d2;//向下转型需要强转
    int i1 = 1245;
    long l1 = i1;
    
    long l2 = 1234;
    int i2 = (int) l2;
  • 隐式类型转换:

    字面量 1 是 int 类型,比 short 类型精度要高,因此不能隐式地将 int 类型向下转型为 short 类型

    使用 += 或者 ++ 运算符会执行类型转换:

    short s1 = 1;
    s1 += 1;	//s1++;
    //上面的语句相当于将 s1 + 1 的计算结果进行了向下转型
    s1 = (short) (s1 + 1);

引用类型

引用数据类型:类,接口,数组都是引用数据类型,又叫包装类

包装类的作用:

  • 包装类作为类首先拥有了 Object 类的方法
  • 包装类作为引用类型的变量可以存储 null 值
基本数据类型                包装类(引用数据类型)
byte                      Byte
short                     Short
int                       Integer
long                      Long

float                     Float
double                    Double
char                      Character
boolean                   Boolean

Java 为包装类做了一些特殊功能,具体来看特殊功能主要有:

  • 可以把基本数据类型的值转换成字符串类型的值

    1. 调用 toString() 方法
    2. 调用 Integer.toString(基本数据类型的值) 得到字符串
    3. 直接把基本数据类型 + 空字符串就得到了字符串(推荐使用)
  • 把字符串类型的数值转换成对应的基本数据类型的值(重要)

    1. Xxx.parseXxx(“字符串类型的数值”) → Integer.parseInt(numStr)
    2. Xxx.valueOf(“字符串类型的数值”) → Integer.valueOf(numStr) (推荐使用)
    public class PackageClass02 {
        public static void main(String[] args) {
            // 1.把基本数据类型的值转成字符串
            Integer it = 100 ;
            // a.调用toString()方法。
            String itStr = it.toString();
            System.out.println(itStr+1);//1001
            // b.调用Integer.toString(基本数据类型的值)得到字符串。
            String itStr1 = Integer.toString(it);
            System.out.println(itStr1+1);//1001
            // c.直接把基本数据类型+空字符串就得到了字符串。
            String itStr2 = it + "";
            System.out.println(itStr2+1);// 1001
    
            // 2.把字符串类型的数值转换成对应的基本数据类型的值
            String numStr = "23";
            int numInt = Integer.valueOf(numStr);
            System.out.println(numInt+1);//24
    
            String doubleStr = "99.9";
            double doubleDb = Double.valueOf(doubleStr);
            System.out.println(doubleDb+0.1);//100.0
        }
    }

类型对比
  • 有了基本数据类型,为什么还要引用数据类型?

    引用数据类型封装了数据和处理该数据的方法,比如 Integer.parseInt(String) 就是将 String 字符类型数据转换为 Integer 整型

    Java 中大部分类和方法都是针对引用数据类型,包括泛型和集合

  • 引用数据类型那么好,为什么还用基本数据类型?

    引用类型的对象要多储存对象头,对基本数据类型来说空间浪费率太高。逻辑上来讲,Java 只有包装类就够了,为了运行速度,需要用到基本数据类型;优先考虑运行效率的问题,所以二者同时存在是合乎情理的

  • Java 集合不能存放基本数据类型,只存放对象的引用?

    不能放基本数据类型是因为不是 Object 的子类。泛型思想,如果不用泛型要写很多参数类型不同的但功能相同的函数(方法重载)

  • ==

    == 比较基本数据类型:比较的是具体的值 == 比较引用数据类型:比较的是对象地址值


装箱拆箱

自动装箱:可以直接把基本数据类型的值或者变量赋值给包装类

自动拆箱:可以把包装类的变量直接赋值给基本数据类型

public class PackegeClass {
    public static void main(String[] args) {
        int a = 12 ;
        Integer a1 = 12 ;  // 自动装箱
        Integer a2 = a ;   // 自动装箱
        Integer a3 = null; // 引用数据类型的默认值可以为null

        Integer c = 100 ;
        int c1 = c ;      // 自动拆箱

        Integer it = Integer.valueOf(12);  	// 手工装箱!
        // Integer it1 = new Integer(12); 	// 手工装箱!
        Integer it2 = 12;

        Integer it3 = 111 ;
        int it33 = it3.intValue(); // 手工拆箱
    }
}

自动装箱反编译后底层调用 Integer.valueOf() 实现,源码:

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        // 【缓存池】,本质上是一个数组
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

自动拆箱调用 java.lang.Integer#intValue,源码:

public int intValue() {
    return value;
}

缓存池

new Integer(123) 与 Integer.valueOf(123) 的区别在于:

  • new Integer(123):每次都会新建一个对象

  • Integer.valueOf(123):会使用缓存池中的对象,多次调用取得同一个对象的引用

    Integer x = new Integer(123);
    Integer y = new Integer(123);
    System.out.println(x == y);    // false
    Integer z = Integer.valueOf(123);
    Integer k = Integer.valueOf(123);
    System.out.println(z == k);   // true

valueOf() 方法的实现比较简单,就是先判断值是否在缓存池中,如果在的话就直接返回缓存池的内容。编译器会在自动装箱过程调用 valueOf() 方法,因此多个值相同且值在缓存池范围内的 Integer 实例使用自动装箱来创建,那么就会引用相同的对象

基本类型对应的缓存池如下:

  • Boolean values true and false
  • all byte values
  • Short values between -128 and 127
  • Long values between -128 and 127
  • Integer values between -128 and 127
  • Character in the range \u0000 to \u007F (0 and 127)

在 jdk 1.8 所有的数值类缓冲池中,Integer 的缓存池 IntegerCache 很特殊,这个缓冲池的下界是 -128,上界默认是 127,但是上界是可调的,在启动 JVM 时通过 AutoBoxCacheMax=<size> 来指定这个缓冲池的大小,该选项在 JVM 初始化的时候会设定一个名为 java.lang.Integer.IntegerCache 系统属性,然后 IntegerCache 初始化的时候就会读取该系统属性来决定上界

Integer x = 100;				// 自动装箱,底层调用 Integer.valueOf(1)
Integer y = 100;
System.out.println(x == y);   	// true

Integer x = 1000;
Integer y = 1000;
System.out.println(x == y);   	// false,因为缓存池最大127

int x = 1000;
Integer y = 1000;
System.out.println(x == y);		// true,因为 y 会调用 intValue 【自动拆箱】返回 int 原始值进行比较

输入数据

语法:Scanner sc = new Scanner(System.in)

  • next():遇到了空格,就不再录入数据了,结束标记:空格、tab 键
  • nextLine():可以将数据完整的接收过来,结束标记:回车换行符

一般使用 sc.nextInt() 或者 sc.nextLine() 接受整型和字符串,然后转成需要的数据类型

  • Scanner:BufferedReader br = new BufferedReader(new InputStreamReader(System.in))
  • print:PrintStream.write()

使用引用数据类型的API

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    while (sc.hasNextLine()) {
        String msg = sc.nextLine();
    }
}