Java数据类型相关

2023-12-14 22:46:40

数据类型

Java有哪些数据类型

定义:Java语言是强类型语言,对于每一种数据都定义了明确的具体的数据类 型,在内存中分配了不同大小的内存空间。

分类:

基本数据类型

  • 数值型

????????整数类型(byte,short,int,long)

????????浮点类型(float,double)

  • 字符型(char)
  • 布尔型(boolean)

引用数据类型

  • 类(class)
  • 接口(interface)
  • 数组([])

Java基本数据类型图

Java中各种数据默认值

Byte,short,int,long默认是都是0

Boolean默认值是false

Char类型的默认值是’’

Float与double类型的默认是0.0

对象类型的默认值是null

超过 long 整型的数据应该如何表示?

基本数值类型都有一个表达范围,如果超过这个范围就会有数值溢出的风险。

在 Java 中,64 位 long 整型是最大的整数类型。

long l = Long.MAX_VALUE;

System.out.println(l + 1); // -9223372036854775808

System.out.println(l + 1 == Long.MIN_VALUE); // true

BigInteger 内部使用 int[] 数组来存储任意大小的整形数据。

相对于常规整数类型的运算来说, BigInteger 运算的效率会相对较低。

String 属于基础的数据类型吗?

String 不属于基础类型,基础类型有 8 种:byte、boolean、char、short、int、float、long、double,除了基本类型(primitive type)和枚举类型(enumeration type),剩下的都是引用类型(reference type)。

用最有效率的方法计算 2 乘以 8

2 << 3(左移 3 位相当于乘以 2 的 3 次方,右移 3 位相当于除以 2 的 3 次 方)。

Math.round(11.5) 等于多少?Math.round(-11.5) 等于多少

Math.round(11.5)的返回值是 12,Math.round(-11.5)的返回值是-11。四舍 五入的原理是在参数上加0.5 然后进行下取整。

float f=3.4;是否正确

不正确。3.4 是双精度数,将双精度型(double)赋值给浮点型(float)属于 下转型(down-casting,也称为窄化)会造成精度损失,因此需要强制类型转 换float f =(float)3.4; 或者写成 float f =3.4F;。

short s1 = 1; s1 = s1 + 1;有错吗?

对于 short s1 = 1; s1 = s1 + 1;由于 1 是 int 类型,因此 s1+1 运算结果也是 int型,需要强制转换类型才能赋值给 short 型。 而 short s1 = 1; s1 += 1;可以正确编译,因为 s1+= 1;相当于 s1 = (short(s1 + 1);其中有隐含的强制类型转换。

3*0.1 == 0.3返回值是什么

false,因为有些浮点数不能完全精确的表示出来.

为什么浮点数运算的时候会有精度丢失的风险?

浮点数运算精度丢失代码演示:

float a = 2.0f - 1.9f;

float b = 1.8f - 1.7f;

System.out.println(a);// 0.100000024

System.out.println(b);// 0.099999905

System.out.println(a == b);// false

为什么会出现这个问题呢?

这个和计算机保存浮点数的机制有很大关系。我们知道计算机是二进制的,而且计算机在表示一个数字时,宽度是有限的,无限循环的小数存储在计算机时,只能被截断,所以就会导致小数精度发生损失的情况。这也就是解释了为什么浮点数没有办法用二进制精确表示。

就比如说?进制下的 0.2 就没办法精确转换成?进制小数:

// 0.2 转换为?进制数的过程为,不断乘以 2,直到不存在小数为止,

// 在这个计算过程中,得到的整数部分从上到下排列就是二进制的结果。

0.2 * 2 = 0.4 -> 0

0.4 * 2 = 0.8 -> 0

0.8 * 2 = 1.6 -> 1

0.6 * 2 = 1.2 -> 1

0.2 * 2 = 0.4 -> 0(发?循环)

...

那针对浮点型数据运算出现的误差的问题,你怎么解决?

BigDecimal 可以实现对浮点数的运算,不会造成精度丢失。通常情况下,大部分需要浮点数精确运算结果的业务场景(比如涉及到钱的场景)都是通过 BigDecimal 来做的。

BigDecimal a = new BigDecimal("1.0");

BigDecimal b = new BigDecimal("0.9");

BigDecimal c = new BigDecimal("0.8");

BigDecimal x = a.subtract(b);

BigDecimal y = b.subtract(c);

System.out.println(x); /* 0.1 /

System.out.println(y); / 0.1 /

System.out.println(Objects.equals(x, y)); / true */

类型转换

自动装箱与拆箱

装箱:将基本类型用它们对应的引用类型包装起来;

拆箱:将包装类型转换为基本数据类型;

在Java SE5之前,如果要生成一个数值为10的Integer对象,必须这样进行:

Integer i = new Integer(10);

而在从Java SE5开始就提供了自动装箱的特性,如果要生成一个数值为10的Integer对象,只需要这样就可以了:

Integer i = 10;

注意:如果频繁拆装箱的话,也会严重影响系统的性能。我们应该尽量避免不必要的拆装箱操作。

private static long sum() {

?// 应该使用 long 而不是 Long

?Long sum = 0L;

?for (long i = 0; i

? ?sum += i;

?return sum;

}

八种基本数据类型的大小,以及他们的包装类

基本类型和包装类型的区别?

成员变量包装类型不赋值就是 null ,而基本类型有默认值且不是 null 。

包装类型可用于泛型,而基本类型不可以。

基本数据类型的局部变量存放在 Java 虚拟机栈中的局部变量表中,基本数据类型的成员变量(未被 static 修饰 )存放在 Java 虚拟机的堆中。包装类型属于对象类型,我们知道几乎所有对象实例都存在于堆中。

相对于对象类型, 基本数据类型占用的空间非常小。

为什么说是几乎所有对象实例呢? 这是因为 HotSpot 虚拟机引入了 JIT 优化之后,会对对象进行逃逸分析,如果发现某一个对象并没有逃逸到方法外部,那么就可能通过标量替换来实现栈上分配,从而避免堆上分配内存

注意 : 基本数据类型存放在栈中是一个常见的误区! 基本数据类型的成员变量如果没有被static 修饰的话(不建议这么使用,应该要使用基本数据类型对应的包装类型),就存放在堆中。

class BasicTypeVar{

?private int x;

}

包装类型的缓存机制了解么?

Java 基本数据类型的包装类型的大部分都用到了缓存机制来提升性能。

Byte , Short , Integer , Long 这 4 种包装类默认创建了数值 [-128,127] 的相应类型的缓存数据, Character 创建了数值在 [0,127] 范围的缓存数据, Boolean 直接返回 True or False 。

Integer 缓存源码:

public static Integer valueOf(int i) {

?if (i >= IntegerCache.low && i

? ?return IntegerCache.cache[i + (-IntegerCache.low)];

?return new Integer(i);

}

private static class IntegerCache {

?static final int low = -128;

?static final int high;

?static {

?// high value may be configured by property

?int h = 127;

}

}

Character 缓存源码:

public static Character valueOf(char c) {

?if (c

?return CharacterCache.cache[(int)c];

}

?return new Character(c);

}

private static class CharacterCache {

?private CharacterCache(){}

?static final Character cache[] = new Character[127 + 1];

?static {

?for (int i = 0; i < cache.length; i++)

? ?cache[i] = new Character((char)i);

}

}

Boolean 缓存源码:

public static Boolean valueOf(boolean b) {

?return (b ? TRUE : FALSE);

}

如果超出对应范围仍然会去创建新的对象,缓存的范围区间的大小只是在性能和资源之间的权衡。

两种浮点数类型的包装类 Float , Double 并没有实现缓存机制。

Integer i1 = 33;

Integer i2 = 33;

System.out.println(i1 == i2);// 输出 true

Float i11 = 333f;

Float i22 = 333f;

System.out.println(i11 == i22);// 输出 false

Double i3 = 1.2;

Double i4 = 1.2;

System.out.println(i3 == i4);// 输出 false

下面我们来看一下问题。下面的代码的输出结果是 true 还是 false 呢?

Integer i1 = 40;

Integer i2 = new Integer(40);

System.out.println(i1==i2);

Integer i1=40 这一行代码会发生装箱,也就是说这行代码等价于 Integer i1=Integer.valueOf(40) 。因此, i1 直接使用的是缓存中的对象。而 Integer i2 = new Integer(40) 会直接创建新的对象。

因此,答案是 false 。你答对了吗?

记住:所有整型包装类对象之间值的?较,全部使用 equals 方法比较。

什么是隐式转换,什么是显式转换

显示转换就是类型强转,把一个大类型的数据强制赋值给小类型的数据;隐式转换就是大范围的变量能够接受小范围的数据;隐式转换和显式转换其实就是自动类型转换和强制类型转换。

Char类型能不能转成int类型?能不能转化成string类型,能不能转成double类型

Char在java中也是比较特殊的类型,它的int值从1开始,一共有2的16次方个数据;

Char类型可以隐式转成int,double类型,但是不能隐式转换成string;

如果char类型转成byte,short类型的时候,需要强转。

int 和 Integer 有什么区别

Java 是一个近乎纯洁的面向对象编程语言,但是为了编程的方便还是引入了基本数据类型,但是为了能够将这些基本数据类型当成对象操作,Java 为每一个基本数据类型都引入了对应的包装类型(wrapper class),int 的包装类就是 Integer,从 Java 5 开始引入了自动装箱/拆箱机制,使得二者可以相互转换。

Java 为每个原始类型提供了包装类型:

原始类型: boolean,char,byte,short,int,long,float,double

包装类型:Boolean,Character,Byte,Short,Integer,Long,Float,Double

Integer a= 127 与 Integer b = 127相等吗

对于对象引用类型:==比较的是对象的内存地址。

对于基本数据类型:==比较的是值。如果整型字面量的值在-128到127之间,那么自动装箱时不会new 新的Integer 对象,而是直接引用常量池中的Integer对象,超过范围 a1==b1的结果是false

public static void main(String[] args) {
  Integer a = new Integer(3);
  Integer b = 3; // 将3自动装箱成Integer类型
  int c = 3;
  System.out.println(a == b); // false 两个引用没有引用同一对象
  System.out.println(a == c); // true a自动拆箱成int类型再和c比较
System.out.println(b == c); // true

 Integer a1 = 128;
 Integer b1 = 128;
 System.out.println(a1 == b1); // false

 Integer a2 = 127;
 Integer b2 = 127;
 System.out.println(a2 == b2); // true
 }

以下代码输出什么

public class Main {
public static void main(String[] args) {
Double i1 = 100.0;
Double i2 = 100.0;
Double i3 = 200.0;
Double i4 = 200.0;
System.out.println(i1==i2);
System.out.println(i3==i4);
}
}

运行结果:

false

false

原因: 在某个范围内的整型数值的个数是有限的,而浮点数却不是。

文章来源:https://blog.csdn.net/xuemengrui12/article/details/135003657
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。