gaspersic/freeCodeCamp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fix Portuguese translation for ArrayList (#26670)

Browse Source
This commit is contained in:
Luiza
2018-11-02 08:32:41 -07:00
committed by Juliano Rafael
parent fef88345fd
commit 140dab8489
2 changed files with 87 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
guide/portuguese/java/abstract-class/index.md
View File

@ -4,23 +4,44 @@ localeTitle: Classes Abstratas em Java
---
Vamos discutir classes abstratas. Antes de mergulhar neste tutorial, é melhor que você tenha entendido conceitos de classes e herança.
Classes abstratas são classes que podem ser subclassificadas (isto é, estendidas), mas não podem ser instanciadas. Você pode pensar neles como uma **versão** de **classe** de interfaces ou como uma interface com código real anexado aos métodos.
Classes abstratas são classes que podem ser herdadas (isto é, estendidas), mas não podem ser instanciadas. Você pode pensar neles como uma **versão** de **classe** de interfaces ou como uma interface com código real anexado aos métodos.
Considere o seguinte exemplo para entender classes abstratas: Você tem uma classe Vehicle que define certas funcionalidades básicas (métodos) e certos componentes (variáveis ​​de objeto) que uma máquina deve ter, para ser classificada como veículo. Você não pode criar um objeto de Veículo porque um veículo em si é um conceito abstrato. No entanto, você pode estender a funcionalidade da classe de veículo para criar um carro ou uma motocicleta.
Considere o seguinte exemplo para entender classes abstratas: Você tem uma classe Veículo que define certas funcionalidades básicas (métodos) e certos componentes (variáveis ​​de objeto) que uma máquina deve ter, para ser classificada como veículo. Você não pode criar um objeto de tipo Veículo porque um veículo em si é um conceito abstrato. No entanto, você pode estender a funcionalidade da classe de veículo para criar um carro ou uma motocicleta.
\`\` \`java classe abstrata Veículo { // variável usada para declarar o não. de rodas em um veículo rodas int privadas;
``` java
abstract class Veiculo {
// Variável para definir o tipo de motor usado Motor privado;
// variável usada para declarar o não. de rodas em um veículo
private int rodas;
// um método abstrato que apenas declara, mas não define o início // funcionalidade porque cada veículo usa um mecanismo de partida diferente Resumo void start (); }
// Variável para definir o tipo de motor
private Motor motor;
carro de classe pública estende veículo { … }
// um método abstrato que apenas declara, mas não define o mecanismo de partida
// funcionalidade porque cada veículo usa um mecanismo de partida diferente
abstract void start ();
classe pública motocicleta estende veículo { … }
}
public class Carro extends Veiculo
{
...
}
public class Motocicleta extends Veiculo
{
...
}
```
You cannot create an object of Vehicle class anywhere in your program. You can however, extend the abstract vehicle class and create objects of the child classes;
Você não pode criar um objeto usando a classe Veiculo. Porém, você pode extender a classe Veiculo, e, então, criar um objeto desta classe que extendeu Veiculo.
``` java
Veiculo veiculo = new Veiculo (); // Inválido
Veiculo carro = new Carro(); // válido
Veiculo mBike = new Motocicleta (); // válido
Carro carro = new Carro(); // válido
Motocicleta mBikeObj = new Motocicleta(); // válido
```
Java Veículo newVehicle = new Vehicle (); // Inválido Veículo car = new Car (); // válido Veículo mBike = new Motorcycle (); // válido
Car carObj = carro novo (); // válido Motocicleta mBikeObj = nova motocicleta (); // válido \`\` \`

63
guide/portuguese/java/arraylist/index.md
View File

@ -4,20 +4,67 @@ localeTitle: ArrayList
---
# ArrayList
ArrayList é uma parte de algo chamado de _estrutura de coleção_ .
ArrayList é uma parte de algo chamado de _estrutura de Coleção (Collection)_ .
A _estrutura de coleta_ consiste em todas as interfaces e classes que podem conter um conjunto de valores (semelhante a [matrizes](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html) ). **ArrayList** é uma classe que está nesta hierarquia e é conhecida como um _**objeto Collection**_ . Ele implementa a interface _List_ , que por sua vez implementa a interface _Collection_ . Essa interface _Collection_ pode ser encontrada no pacote `java.util` . Você precisará importar este pacote.
A _estrutura de Coleção_ consiste de todas as interfaces e classes que podem conter um conjunto de valores (semelhante a [arrays](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html) ). **ArrayList** é uma classe que está nesta hierarquia e é conhecida como um _**objeto Collection**_. ArrayList implementa a interface _List_, que por sua vez implementa a interface _Collection_ . Essa interface _Collection_ pode ser encontrada no pacote `java.util`. Você precisará importar este pacote.
ArrayList é uma classe usada para criar matrizes dinâmicas. É mais lento que os arrays regulares, mas permite muita manipulação. Pode ser inicializado para ter um tamanho específico ou terá um tamanho padrão de 10 unidades.
`java ArrayList<String> names = new ArrayList<>(); ArrayList<Integer> ages = new ArrayList<>(5);`
``` java
ArrayList<String> nomes = new ArrayList<>();
ArrayList<Integer> idades = new ArrayList<>(5);
```
No snippet acima, o ângulo breackets `<>` toma um tipo de dados genérico como argumento especificando o tipo de dados dos elementos no ArrayList. Os primeiros `names` ArrayList são especificados como contendo elementos _String_ . Assim, só será permitido conter elementos String. Seu tamanho não é especificado, portanto, ele terá um tamanho padrão de 10. A segunda `ages` ArrayList especificou que ele só conterá inteiros. Mas ArrayList não pode conter primitivos, ele só contém objetos. Assim, para torná-lo armazenar números inteiros, flutuantes, etc., podemos usar classes wrapper. `names` terão um tamanho especificado de 5.
No snippet acima, `<>` toma um tipo de dados genérico como argumento especificando o tipo de dados dos elementos no ArrayList. No primeiro exemplo, o ArrayList `nomes` são especificados como contendo elementos _String_. Assim, só será permitido conter elementos String. Seu tamanho não é especificado, portanto, ele terá um tamanho inicial de 10. O segundo exemplo, o ArrayList `idades`, especificou que ele só conterá inteiros. Mas ArrayList não pode conter primitivos, ele só contém objetos. Assim, para poder armazenar números inteiros, reais, etc., podemos usar classes wrapper. `idades` terão um tamanho inicial especificado: 5.
Como ArrayList implementa _List_ , um ArrayList pode ser criado usando a seguinte sintaxe: `java List<Integer> students = new ArrayList<>();`
Como ArrayList implementa _List_ , um ArrayList pode ser criado usando a seguinte sintaxe:
Um ArrayList é dinâmico, o que significa que ele aumentará de tamanho se necessário e, da mesma forma, diminuirá em tamanho se os elementos forem excluídos dele. É isso que faz com que seja melhor usar do que os arrays normais.
``` java
List<Integer> estudantes = new ArrayList<>();
```
Um ArrayList nos permite acessar elementos aleatoriamente. ArrayList é semelhante ao _Vector de_ várias formas. Mas é mais rápido que Vetores. A principal coisa a notar é que - Os vetores são mais rápidos que os arrays, mas os ArrayLists não são.
Um ArrayList é dinâmico, o que significa que ele aumentará de tamanho se necessário e, da mesma forma, diminuirá de tamanho se os elementos forem excluídos dele. É esta dinamicidade que faz com que seja melhor usar do que os arrays normais quando queremos que o array cresça ou dimunua de tamanho.
Para criar/remover todos os elementos de um ArrayList
```java
variavel.clear();
```
Nos podemos remover elementos existentes em uma lista
```java
variavel.remove(posicao);
```
Para acessar um elemento presente na lista
```java
variavel.get(posicao);
```
Nos podemos modificar um elemento presente na lista também
```java
variavel.set(posicao, elemento);
```
Nos podemos inverter a ordem dos elementos no ArrayList
```java
import java.util.Collections; // package
Collections.reverse(variavel);
```
Ordenar em ordem ascendente
```java
Collections.sort(variavel);
```
Ordenar em ordem descendente
```java
Collections.reverseOrder();
```
Um ArrayList nos permite acessar elementos aleatoriamente. ArrayList é semelhante ao _Vector_ de_ várias formas. Mas é mais rápido que _Vector_. A principal coisa a notar é que - Objetos _Vector_ são mais rápidos que objetos que são arrays, mas objectos _ArrayList_ não são.
Então, quando se trata de escolher entre os dois - se a velocidade é crítica, então _Vector_ devem ser considerados, caso contrário, _ArrayList_ são melhores quando se trata de armazenar grande número de elementos e acessá-los de forma eficiente.
## More Information
- [ArrayList Documentation](https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html)
Então, quando se trata de escolher entre os dois - se a velocidade é crítica, então os vetores devem ser considerados, caso contrário, ArrayLists são melhores quando se trata de armazenar grande número de elementos e acessá-los de forma eficiente.