Guia de classe de inteiro Java

Neste artigo falaremos sobre a classe Integer. Vamos considerar estas questões:

• o que são classes wrapper;
• autoempacotamento/descompactação de primitivos;
• operação da classe Integer, seus métodos e constantes.

Classes wrapper de tipos primitivos

Como você sabe, Java possui vários tipos de dados, que podem ser divididos em dois blocos:

• primitivo;
• referência.

Existem vários tipos de dados primitivos em Java:

• inteiros - byte, curto, int, longo;
• números de ponto flutuante (reais) - float, double;
• tipo de dados lógicos - booleano;
• tipo de dados de caractere - char.

Cada tipo de dados primitivo possui sua própria classe wrapper. Um tipo de dados de referência que envolve seu irmão primitivo em um objeto Java. Abaixo estão os tipos de dados primitivos e suas classes wrapper correspondentes: Do ponto de vista prático, as primitivas e suas classes wrapper têm muito em comum. A maioria das operações é executada de forma idêntica. No entanto, as classes wrapper possuem diversas características que não são características das primitivas. Primeiro, existem as classes: ao trabalhar com classes wrapper, trabalhamos com objetos. Em segundo lugar (tudo o que se segue segue do ponto um), esses objetos podem ser nulos. Terceiro, as classes wrapper fornecem diversas constantes e métodos que facilitam o trabalho com um tipo de dados específico. Neste artigo, veremos mais de perto como trabalhar com a classe Integer.

O inteiro

A classe Integer é uma classe wrapper do tipo primitivo int. Esta classe contém um único campo do tipo int. Como uma classe wrapper, Integer fornece vários métodos para trabalhar com inteiros, bem como vários métodos para converter int em String e String em int. Abaixo veremos vários exemplos de trabalho com a turma. Vamos começar com a criação. A mais comumente usada (e mais fácil de usar) é a seguinte opção de criação:

Integer a = 3;

Ou seja, a inicialização de uma variável Inteira neste caso é semelhante à inicialização de uma variável Int. Além disso, uma variável inteira pode ser inicializada com o valor de uma variável int:

int i = 5;
Integer x = i;
System.out.println(x); // 5

No caso acima, o empacotamento automático ocorre implicitamente. Falaremos mais sobre isso abaixo. Além das opções de inicialização listadas acima, uma variável Integer pode ser criada como outros objetos, usando um construtor e a palavra-chave new:

Integer x = new Integer(25);
System.out.println(x);

No entanto, leva mais tempo para escrever e mais para ler, por isso esta opção é a menos comum. Você pode fazer com variáveis ​​inteiras tudo o que pode fazer com variáveis ​​int. Eles podem ser: Porém, com tudo isso, é preciso ter cuidado e lembrar que Inteiro é um tipo de dados de referência, e uma variável desse tipo pode ser nula. Neste caso (se a variável for nula), é melhor abster-se de operações aritméticas (e quaisquer outras em que nulo não seja um bom presságio). Aqui está um exemplo:

Integer a = null;
Integer b = a + 1; // Здесь мы упадем с "Exception in thread "main" java.lang.NullPointerException"
System.out.println(b);

A maioria das operações de comparação são realizadas da mesma forma que no tipo primitivo int:

Integer a = 1;
Integer b = 2;

System.out.println(a > b);
System.out.println(a >= b);
System.out.println(a < b);
System.out.println(a <= b);

Saída:

false
false
true
true

Destaca-se a operação de comparação de duas variáveis ​​​​Inteiras. E a questão aqui é que Integer é um tipo de dados de referência e suas variáveis ​​armazenam referências a valores, e não aos próprios valores (objetos). Manifestações deste fato podem ser observadas ao executar o seguinte fragmento de código:

Integer a = 1;
Integer b = 1;
Integer c = new Integer(1);

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

O resultado da primeira igualdade será verdadeiro e o da segunda será falso. Isso acontece porque no primeiro caso comparamos duas variáveis ​​(“a” e “b”) que armazenam referências ao mesmo objeto. E no segundo caso, comparamos duas variáveis ​​que se referem a dois objetos diferentes (quando criamos a variável “c” criamos um novo objeto). Vamos dar outro exemplo interessante:

Integer a = 1;
Integer b = 1;

Integer x = 2020;
Integer y = 2020;

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

Como podemos ver, o resultado da primeira comparação é verdadeiro e o resultado da segunda é falso. É tudo uma questão de cache. Todos os números inteiros no intervalo de -128 a 127 inclusive (esses valores podem ser personalizados) são armazenados em cache. Portanto, quando criamos uma nova variável e atribuímos a ela um valor inteiro entre -128 e 127, não estamos criando um novo objeto, mas sim atribuindo à variável uma referência a um objeto já criado no cache. Agora, sabendo deste fato, o exemplo acima não parece tão místico. As variáveis ​​aeb referem-se ao mesmo objeto - um objeto do cache. E durante a inicialização das variáveis ​​​​xey, criamos um novo objeto a cada vez, e essas variáveis ​​​​armazenavam referências a diferentes objetos. E como você sabe, o operador == compara os valores das variáveis, e os valores das variáveis ​​de referência são referências. Para verificar com precisão a igualdade entre duas variáveis ​​​​Inteiras, você deve usar (não importa quão trivial possa parecer) o método equals. Vamos reescrever o exemplo acima:

Integer a = 1;
Integer b = 1;

Integer x = 2020;
Integer y = 2020;

System.out.println(a.equals(b)); // true
System.out.println(x.equals(y)); // true

Autoempacotar e descompactar Inteiro

O que é embalagem e desembalagem automática? Ao criar novas variáveis ​​Inteiras, utilizamos a seguinte construção:

Integer a = 2020;

Desta forma criamos um novo objeto sem usar o novo operador chave. Isto é possível graças ao mecanismo de autopacking do tipo primitivo int. O procedimento inverso ocorre ao atribuir uma variável int primitiva ao valor de uma variável de referência inteira:

Integer a = 2020;
int x = a;

Neste caso, parece que atribuímos uma referência (ou seja, a referência a um objeto é o valor da variável “a”) a uma variável primitiva. Mas, na verdade, graças ao mecanismo de descompactação automática, o valor 2020 foi escrito na variável “x”.A compactação/descompactação automática é um fenômeno muito comum em Java. Muitas vezes isso acontece por si só, às vezes até sem o conhecimento do programador. Mas você ainda precisa saber sobre esse fenômeno. Temos um artigo interessante sobre esse assunto no Javarush .

Constantes de classe inteira

A classe Integer fornece várias constantes e métodos para trabalhar com números inteiros. Nesta seção examinaremos mais de perto alguns deles na prática. Vamos começar com as constantes. A tabela abaixo mostra todas as constantes da classe: Vejamos os valores de todas essas constantes executando o seguinte código:

public static void main(String[] args) {
        System.out.println(Integer.SIZE);
        System.out.println(Integer.BYTES);
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.TYPE);
}

Como resultado, obtemos a seguinte saída:

32
4
2147483647
-2147483648
int

Métodos da classe Integer

Agora vamos dar uma olhada rápida nos métodos mais usados ​​da classe Integer. Portanto, os “principais” são encabeçados por métodos para converter um número de uma string ou converter uma string de um número. Vamos começar convertendo uma string em um número. O método parseInt é usado para esses fins , a assinatura está abaixo:

• 
  static int parseInt(String s)

Este método converte String em int. Vamos demonstrar como esse método funciona:

int i = Integer.parseInt("10");
System.out.println(i); // 10

Se a conversão não for possível — por exemplo, passamos uma palavra para o método parseInt — uma NumberFormatException será lançada. O método parseInt(String s) tem um irmão sobrecarregado:

• 
  static int parseInt(String s, int radix)

Este método converte o parâmetro s em int. O parâmetro radix indica em qual sistema numérico o número em s foi originalmente escrito, que deve ser convertido para int. Exemplos abaixo:

System.out.println(Integer.parseInt("0011", 2)); // 3
System.out.println(Integer.parseInt("10", 8));   // 8
System.out.println(Integer.parseInt("F", 16));   // 15

Os métodos parseInt retornam um tipo de dados primitivo int. Esses métodos têm um análogo - o método valueOf . Algumas variações deste método simplesmente chamam parseInt internamente. A diferença do parseInt é que o resultado de valueOf será um inteiro, não um int. Vejamos a seguir todas as opções deste método e um exemplo de como ele funciona:

• static Integer valueOf(int i) - retorna um Inteiro cujo valor é i;
• static Integer valueOf(String s) - semelhante a parseInt(String s), mas o resultado será Integer;
• static Integer valueOf(String s, int radix) - semelhante a parseInt(String s, int radix), mas o resultado será Integer.

Exemplos:

int a = 5;
Integer x = Integer.valueOf(a);
Integer y = Integer.valueOf("20");
Integer z = Integer.valueOf("20", 8);

System.out.println(x); // 5
System.out.println(y); // 20
System.out.println(z); // 16

Vimos métodos que permitem converter String em int/Integer. O procedimento inverso é obtido usando os métodos toString . Você pode chamar o método toString em qualquer objeto Integer e obter sua representação de string:

Integer x = 5;
System.out.println(x.toString()); // 5

No entanto, devido ao fato de que o método toString é frequentemente chamado implicitamente em objetos (por exemplo, ao enviar um objeto ao console para impressão), esse método raramente é usado explicitamente pelos desenvolvedores. Existe também um método estático toString, que recebe um parâmetro int e o converte em uma representação de string. Por exemplo:

System.out.println(Integer.toString(5)); // 5

No entanto, como o método toString não estático, usar explicitamente um método estático é raro. Mais interessante é o método estático toString, que utiliza 2 parâmetros inteiros:

• static String toString(int i, int radix) - converterá i em uma representação de string no sistema numérico de base.

Exemplo:

System.out.println(Integer.toString(5, 2)); // 101

A classe Integer possui alguns métodos para encontrar o máximo/mínimo de dois números:

• static int max(int ​​​​a, int b) retornará o maior valor entre as variáveis ​​​​passadas;
• static int min(int a, int b) retornará o menor valor entre as variáveis ​​passadas.

Exemplos:

int x = 4;
int y = 40;

System.out.println(Integer.max(x,y)); // 40
System.out.println(Integer.min(x,y)); // 4

Conclusão

Neste artigo, vimos a classe Integer. Conversamos sobre que tipo de classe é essa e o que são classes wrapper. Analisamos a aula de um ponto de vista prático. Vimos exemplos de operações aritméticas, incluindo operações de comparação. Demos uma olhada nas complexidades da comparação de duas variáveis ​​inteiras e examinamos o conceito de objetos armazenados em cache. Também mencionamos o fenômeno de compactação/descompactação automática de tipos de dados primitivos. Além disso, conseguimos observar alguns métodos da classe Integer, bem como algumas constantes. Eles deram exemplos de conversão de números de um sistema numérico para outro.

Trabalho de casa

1. Estude quais outros métodos da classe Integer existem (você pode estudá-los no site com a documentação oficial ), escreva nos comentários qual dos métodos que você estudou (excluindo os indicados no artigo) é mais útil na sua opinião ( será usado por você com mais frequência). E também forneça razões para sua opinião.

   PS Não há respostas corretas aqui, mas esta atividade permitirá que você estude melhor a aula.

2. Resolva um pequeno problema simples para consolidar o material.

   Temos dois números:

   1100001001 - no sistema numérico binário
   33332 - no sistema numérico quinário

   É necessário, utilizando apenas métodos da classe Integer, determinar o máximo entre dois números dados e, em seguida, exibir a diferença entre o valor máximo e mínimo no sistema numérico ternário.

3. Converta o valor inteiro máximo possível para o sistema numérico octal e exiba o número de dígitos no número resultante (conte o número programaticamente).