A diferença entre tamanho e comprimento em Java

1. A propriedade length dos Arrays em Java
2. Exemplo de .length em um Array em Java
3. Exemplo do método size() em um array em Java
4. Encontre o comprimento usando o método length() em Java
5. Java Collections size() Método
6. A diferença entre tamanho e comprimento em Java

Este tutorial apresenta a diferença entre tamanho e comprimento em Java. Também listamos alguns códigos de exemplo para ajudá-lo a entender o tópico.

Java tem um método size() e uma propriedade length. Um iniciante pode pensar que eles são intercambiáveis ​​e executam a mesma tarefa porque eles têm o mesmo som. Em Java, tamanho e comprimento são duas coisas diferentes. Aqui, aprenderemos as diferenças entre os dois.

A propriedade length dos Arrays em Java

Os arrays armazenam um número fixo de dados do mesmo tipo de maneira ordenada. Todas as matrizes em Java têm um campo de comprimento que armazena o espaço alocado para os elementos dessa matriz. É um valor constante usado para descobrir a capacidade máxima do array.

• Lembre-se de que este campo não nos dará o número de elementos presentes na matriz, mas o número máximo de elementos que podem ser armazenados (independentemente de os elementos estarem presentes ou não).

Exemplo de .length em um Array em Java

No código abaixo, primeiro inicializamos um array de comprimento 7. O campo de comprimento desta matriz mostra 7, embora não tenhamos adicionado nenhum elemento. Este 7 indica apenas a capacidade máxima.

public class Main {
  public static void main(String[] args) {
    int[] intArr = new int[7];
    System.out.print("Length of the Array is: " + intArr.length);
  }
}

Produção:

Length of the Array is: 7

Agora, vamos adicionar 3 elementos ao array usando seu índice e então imprimir o campo de comprimento. Ainda mostra 7.

public class Main {
  public static void main(String[] args) {
    int[] intArr = new int[7];
    intArr[0] = 20;
    intArr[1] = 25;
    intArr[2] = 30;
    System.out.print("Length of the Array is: " + intArr.length);
  }
}

Produção:

Length of the Array is: 7

O campo de comprimento é constante porque os arrays têm tamanhos fixos. Devemos definir o número máximo de elementos que armazenaremos no array (a capacidade do array) durante a inicialização e não podemos exceder esse limite.

Exemplo do método size() em um array em Java

Não há método size() para matrizes; ele retornará um erro de compilação. Veja o exemplo abaixo.

public class SimpleTesting {
  public static void main(String[] args) {
    int[] intArr = new int[7];
    System.out.print("Length of the Array is: " + intArr.size());
  }
}

Produção:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Cannot invoke size() on the array type int[]

	at SimpleTesting.main(SimpleTesting.java:7)

Encontre o comprimento usando o método length() em Java

As strings Java são simplesmente uma coleção ordenada de caracteres e, ao contrário dos arrays, têm um método length() e não um campo length. Este método retorna o número de caracteres presentes na string.

Veja o exemplo abaixo.

public class Main {
  public static void main(String[] args) {
    String str1 = "This is a string";
    String str2 = "Another String";
    System.out.println("The String is: " + str1);
    System.out.println("The length of the string is: " + str1.length());
    System.out.println("\nThe String is: " + str2);
    System.out.println("The length of the string is: " + str2.length());
  }
}

Produção:

The String is: This is a string
The length of the string is: 16

The String is: Another String
The length of the string is: 14

Observe que não podemos usar a propriedade length em strings e o método length não é aplicável em arrays. O código a seguir mostra os erros se os usarmos indevidamente.

public class SimpleTesting {
  public static void main(String[] args) {
    String str1 = "This is a string";
    System.out.println("The length of the string is: " + str1.length);
  }
}

Produção:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	length cannot be resolved or is not a field

	at SimpleTesting.main(SimpleTesting.java:7)

Da mesma forma, não podemos usar o método string length() em matrizes.

public class SimpleTesting {
  public static void main(String[] args) {
    int[] intArray = {1, 2, 3};
    System.out.println("The length of the string is: " + intArray.length());
  }
}

Produção:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Cannot invoke length() on the array type int[]

	at SimpleTesting.main(SimpleTesting.java:7)

Java Collections size() Método

size() é um método da classe java.util.Collections. A classe Collections é usada por muitas coleções diferentes (ou estruturas de dados) como ArrayList, LinkedList,HashSet e HashMap.

O método size() retorna o número de elementos atualmente presentes na coleção. Ao contrário da propriedade length dos arrays, o valor retornado pelo método size() não é constante e muda de acordo com o número de elementos.

Todas as coleções do Collection Framework em Java são alocadas dinamicamente, portanto o número de elementos pode variar. O método size() é usado para controlar o número de elementos.

No código abaixo, é claro que quando criamos um novo ArrayList sem nenhum elemento nele, o método size() retorna 0.

import java.util.ArrayList;
import java.util.List;
public class Main {
  public static void main(String[] args) {
    List<Integer> list = new ArrayList<Integer>();
    System.out.println("The ArrayList is: " + list);
    System.out.println("The size of the ArrayList is: " + list.size());
  }
}

Produção:

The ArrayList is: []
The size of the ArrayList is: 0

Mas esse valor muda à medida que adicionamos ou removemos elementos. Depois de adicionar três elementos, o tamanho aumenta para 3. Em seguida, removemos dois elementos e o tamanho da lista passa a ser 1.

import java.util.ArrayList;
import java.util.List;
public class Main {
  public static void main(String[] args) {
    List<Integer> list = new ArrayList<Integer>();
    System.out.println("The ArrayList is: " + list);
    System.out.println("The size of the ArrayList is: " + list.size());
    list.add(20);
    list.add(40);
    list.add(60);
    System.out.println("\nAfter adding three new elements:");
    System.out.println("The ArrayList is: " + list);
    System.out.println("The size of the ArrayList is: " + list.size());
    list.remove(0);
    list.remove(1);
    System.out.println("\nAfter removing two elements:");
    System.out.println("The ArrayList is: " + list);
    System.out.println("The size of the ArrayList is: " + list.size());
  }
}

Produção:

The ArrayList is: []
The size of the ArrayList is: 0

After adding three new elements:
The ArrayList is: [20, 40, 60]
The size of the ArrayList is: 3

After removing two elements:
The ArrayList is: [40]
The size of the ArrayList is: 1

A diferença entre tamanho e comprimento em Java

Embora o tamanho e o comprimento às vezes possam ser usados ​​no mesmo contexto, eles têm significados totalmente diferentes em Java.

O campo length das matrizes é usado para denotar a capacidade máxima do array. Por capacidade máxima, queremos dizer o número máximo de elementos que podem ser armazenados nele. Este campo não considera o número de elementos presentes na matriz e permanece constante.

O método length() de strings é usado para denotar o número de caracteres presentes nas strings. O método size() do Collections Framework é usado para visualizar o número de elementos atualmente presentes nessa coleção. As Collections têm um tamanho dinâmico, por isso o valor de retorno de size() pode variar.