Tipo de dados básico
8 tipos de dados básicos
Eles são:
- 6 tipos de números: byte, short, int, long, float, double
- 1 tipo de caractere: char
- 1 tipo booleano: booleano
Bytes ocupados por oito tipos de dados básicos
| tipo básico | Mordeu | Byte | Padrões |
|---|---|---|---|
| boleano | 1 | falso | |
| byte | 8 | 1 | 0 |
| Caracteres | 16 | 2 | 'u0000' |
| baixo | 16 | 2 | 0 |
| int | 32 | 4 | 0 |
| grandes | 64 | 8 | 0L |
| flutuador | 32 | 4 | 0f |
| em dobro | 64 | 8 | 0d |
3. Método de conversão básico e de string
Veja a cirurgia plástica como exemplo
3.1. Conversão de inteiro para string
String str = String.valueOf(int i);
String str = Integer.toString(int i);
String str = “ ” + i ;
3.2. Converter uma string em um inteiro
int i = Integer.parseIn(String str)
int i = Integer.valueOf().intValue()
//说明：
//Integer.parseIn和Integer.valueOf 不同，
//前者生成的是整型，而后者是一个对象，所以要通过intValue()来获得对象的值
tipo de embalagem
Tipos de embalagem correspondentes a oito tipos de dados básicos
booleano ->
Byte booleano -> Byte
char -> Caractere
curto -> Short
int -> Integer
longo -> Long
float -> Float
double -> Double
Conversão de tipo de dados básico e tipo de embalagem
1. Conversão de tipos de dados básicos para tipos de embalagem (boxing)
Integer a = new Integer (1);
Integer b = 1;//jdk1.5 之后可以通过这种方式自动装箱
Integer c = Integer.valueOf(1);
2. Conversão do tipo de embalagem para o tipo de dados básicos (desembalagem)
int a1 = a.intValue();
int b1 = b;//自动拆箱
Double c1;
double c2= double(c1);//通过强制转换
8 tipos básicos de classes de embalagens e pools constantes
A maioria das classes de wrapper de tipos básicos de Java implementam tecnologia de pool constante, ou seja, Byte, Short, Integer, Long, Character, Boolean; as primeiras quatro classes de wrapper criam o tipo correspondente de dados de cache do valor [-128, 127] por padrão , Character cria dados de cache com um valor na faixa de [0,127], e Boolean retorna True ou False diretamente. Se exceder o intervalo correspondente, ainda criará um novo objeto.
As duas classes de empacotamento do tipo número de ponto flutuante Float e Double não implementam tecnologia de pool constante.
Integer i1 = 33;
Integer i2 = 33;
System.out.println(i1 == i2);// 输出 true
Integer i11 = 333;
Integer i22 = 333;
System.out.println(i11 == i22);// 输出 false
Double i3 = 1.2;
Double i4 = 1.2;
System.out.println(i3 == i4);// 输出 false
Cenários de aplicação:
Integer i1=40；Java encapsulará diretamente o código durante a compilaçãoInteger i1=Integer.valueOf(40);, usando assim os objetos no pool constante.Integer i1 = new Integer(40);Neste caso, um novo objeto é criado.
Integer i1 = 40;
Integer i2 = new Integer(40);
System.out.println(i1==i2);//输出 false
Deixe-me dar um exemplo mais difícil:
Integer i1 = 40;
Integer i2 = 40;
Integer i3 = 0;
Integer i4 = new Integer(40);
Integer i5 = new Integer(40);
Integer i6 = new Integer(0);
System.out.println("i1=i2 " + (i1 == i2));
System.out.println("i1=i2+i3 " + (i1 == i2 + i3));
System.out.println("i1=i4 " + (i1 == i4));
System.out.println("i4=i5 " + (i4 == i5));
System.out.println("i4=i5+i6 " + (i4 == i5 + i6));
System.out.println("40=i5+i6 " + (40 == i5 + i6));
Resultado:
i1=i2 true
i1=i2+i3 true
i1=i4 false
i4=i5 false
i4=i5+i6 true
40=i5+i6 true
Explicação:
Instrução i4 == i5 + i6, porque +este operador não é aplicável a objetos Inteiros, primeiro, i5 e i6 são desempacotados automaticamente e os valores são adicionados, ou seja i4 == 40. Então, o objeto Integer não pode ser comparado diretamente com o valor, então i4 desempacotamento automático converteu o valor int de 40, esta declaração na 40 == 40comparação numérica final .
BigDecimal
O "Alibaba Java Development Manual" menciona: O julgamento equivalente entre números de ponto flutuante, tipos de dados básicos não podem ser comparados com == e os tipos de dados de pacotes não podem ser julgados com iguais. Considere o seguinte exemplo:
float a = 1.0f - 0.9f;
float b = 0.9f - 0.8f;
System.out.println(a);// 0.100000024
System.out.println(b);// 0.099999964
System.out.println(a == b);// false
Com conhecimentos matemáticos básicos, sabemos claramente que o resultado não é o que queremos (perda de precisão) .Como podemos resolver este problema?
Um método muito comum é usar BigDecimal para definir o valor de um número de ponto flutuante e, em seguida, executar operações aritméticas no número de ponto flutuante.
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 */
Comparação de tamanho BigDecimal
a.compareTo(b) : Retorno -1 significa que a é menor que b, 0 significa que a é igual a b, 1 significa que a é maior que b
BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("0.9");
System.out.println(a.compareTo(b));// 1
BigDecimal mantém algumas casas decimais
Por setScaleretém várias casas decimais e maneiras de definir regras de retenção. Existem muitas regras de retenção, não é necessário lembrar, o IDEA solicitará.
BigDecimal m = new BigDecimal("1.255433");
BigDecimal n = m.setScale(3,BigDecimal.ROUND_HALF_DOWN);
System.out.println(n);// 1.255
Nota
- Quando usamos BigDecimal, a fim de evitar perda de precisão, é recomendável usar seu método de construção BigDecimal (String) para criar objetos.
- BigDecimal é usado principalmente para manipular números de ponto flutuante (grandes), BigInteger é usado principalmente para manipular números inteiros grandes (mais do que tipo longo).
- A realização de BigDecimal usa BigInteger, a diferença é que BigDecimal adiciona o conceito de casas decimais