From 140dab84897bb210e59cdef005694ef98ab62f1f Mon Sep 17 00:00:00 2001 From: Luiza Date: Fri, 2 Nov 2018 08:32:41 -0700 Subject: [PATCH] Fix Portuguese translation for ArrayList (#26670) --- guide/portuguese/java/abstract-class/index.md | 43 +++++++++---- guide/portuguese/java/arraylist/index.md | 63 ++++++++++++++++--- 2 files changed, 87 insertions(+), 19 deletions(-) diff --git a/guide/portuguese/java/abstract-class/index.md b/guide/portuguese/java/abstract-class/index.md index 45dcd410f5..3eb3346d20 100644 --- a/guide/portuguese/java/abstract-class/index.md +++ b/guide/portuguese/java/abstract-class/index.md @@ -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 { … } -``` -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; +} +public class Carro extends Veiculo +{ + ... +} + +public class Motocicleta extends Veiculo +{ + ... +} ``` +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 Veículo newVehicle = new Vehicle (); // Inválido Veículo car = new Car (); // válido Veículo mBike = new Motorcycle (); // válido +``` java -Car carObj = carro novo (); // válido Motocicleta mBikeObj = nova motocicleta (); // válido \`\` \` \ No newline at end of file + + 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 + + ``` diff --git a/guide/portuguese/java/arraylist/index.md b/guide/portuguese/java/arraylist/index.md index 474ec97d2d..32e386bca7 100644 --- a/guide/portuguese/java/arraylist/index.md +++ b/guide/portuguese/java/arraylist/index.md @@ -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 names = new ArrayList<>(); ArrayList ages = new ArrayList<>(5);` +``` java +ArrayList nomes = new ArrayList<>(); +ArrayList 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 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 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. \ No newline at end of file