Java String Array - Tutorial com exemplos de código

java string array tutorial with code examples

Experimente Nosso Instrumento Para Eliminar Problemas

Selecione O Sistema Operacional Escolha Um Programa De Projeção (Opcionalmente)

Descreva Seu Problema

Este tutorial em Java String Array explica como declarar, inicializar e criar strings em Java e conversões que podemos realizar em String Array:

Arrays são uma importante estrutura de dados em Java que são usados para armazenar diferentes tipos de dados, desde os primitivos aos definidos pelo usuário. Já vimos os fundamentos de Arrays e as outras operações principais que podem ser executadas em Arrays.

Em um de nossos tutoriais anteriores, discutimos os vários tipos de dados que um Array pode conter.

=> Treinamento A-Z de Java para iniciantes

Java String Array e vários métodos

Um dos tipos de dados que os arrays podem conter é uma string. Nesse caso, a matriz é chamada de matriz String.

O que você aprenderá:

O que é um array de strings em Java?
Conclusão
- Leitura recomendada

O que é um array de strings em Java?

Podemos ter um array com strings como seus elementos. Assim, podemos definir um String Array como um array contendo um número fixo de strings ou valores de string. Array de strings é uma estrutura mais comumente usada em Java. Se você se lembra, até mesmo o argumento da função ‘principal’ em Java é um String Array.

Array de strings é um array de objetos. Isso ocorre porque cada elemento é uma String e você sabe que em Java, String é um objeto. Você pode fazer todas as operações na matriz String, como classificação, adição de um elemento, junção, divisão, pesquisa, etc.

Neste tutorial, discutiremos o array de strings em Java em detalhes, juntamente com as várias operações e conversões que podemos realizar em arrays de strings.

Declarando um array de strings

Um String Array pode ser declarado de duas maneiras, ou seja, com um tamanho ou sem especificar o tamanho.

A seguir, estão as duas maneiras de declarar um array de strings.

String() myarray ; //String array declaration without size String() myarray = new String(5);//String array declaration with size

Na primeira declaração, um String Array é declarado como uma variável normal sem qualquer tamanho. Observe que antes de usar este array, você terá que instanciá-lo com new.

Na segunda declaração, um String Array é declarado e instanciado usando new. Aqui, um array String ‘myarray’ com cinco elementos é declarado. Se você imprimir diretamente os elementos deste array, verá todos os valores nulos, pois o array não foi inicializado.

Vamos implementar um programa que mostra uma declaração String Array.

 public class Main { public static void main(String() args) { String() myarray; //declaration of string array without size String() strArray = new String(5); //declaration with size //System.out.println(myarray(0)); //variable myarray might not have been initialized //display elements of second array System.out.print(strArray(0) + ' ' +strArray(1)+ ' ' + strArray(2)+ ' ' + strArray(3)+ ' ' +strArray(4)); } }

Resultado:

Declarando uma matriz de string - saída

O programa acima mostra duas maneiras de declarar um String Array. Conforme mencionado anteriormente, a primeira declaração não tem tamanho e instanciação. Portanto, antes de usar esse array, você deve instanciá-lo usando new. No programa acima, o array myarray é usado sem instanciação e, portanto, resulta em erro do compilador (instrução comentada).

A segunda declaração é com o tamanho. Portanto, quando elementos individuais deste array String são impressos, os valores de todos os elementos são nulos, pois o array não foi inicializado.

Inicializando um array de strings

Depois que o String Array é declarado, você deve inicializá-lo com alguns valores. Caso contrário, os valores padrão atribuídos aos elementos String são nulos. Assim, após a declaração, procedemos à inicialização do array.

Uma matriz String pode ser inicializada in-line junto com a declaração ou pode ser inicializada após ser declarada.

Primeiro, vamos ver como um array String pode ser inicializado inline.

 String() numarray = {“one”, “two”, “three”}; String() strArray = new String() {“one”, “two”, “three”, “four”};

No String Array acima, as inicializações são inicializações inline. O String Array é inicializado ao mesmo tempo em que é declarado.

Você também pode inicializar o String Array da seguinte maneira:

String() strArray = new String(3); strArray(0) = “one”; strArray(1) = “two”; strArray(2) = “three”;

Aqui, o String Array é declarado primeiro. Então, na próxima linha, os elementos individuais recebem valores. Depois que o String Array é inicializado, você pode usá-lo em seu programa normalmente.

Comprimento / tamanho de um array de cordas

Você sabe que, para obter o tamanho da matriz, as matrizes têm uma propriedade chamada ‘comprimento’. Isso também é válido para String Arrays.

O tamanho ou comprimento da matriz (qualquer matriz) fornece o número de elementos presentes na matriz. Portanto, para obter o comprimento do array denominado myarray, você pode fornecer a seguinte expressão.

int len = myarray.length;

Vamos implementar um programa que produzirá o comprimento de um array de strings.

 public class Main { public static void main(String() args) { //declare and initialize a string array String() numArray = {'one','two', 'three', 'four', 'five'}; int len = numArray.length; //get the length of array //display the length System.out.println('Length of numArray{'one','two', 'three', 'four', 'five'}:' + len); } }

Resultado:

Tamanho de uma matriz de string - Saída

A propriedade length é útil quando você precisa iterar por meio de uma matriz de string para processá-la ou simplesmente imprimi-la.

Iterando e imprimindo um array de strings

Até agora, discutimos a declaração, inicialização e propriedade de comprimento de um String Array, e agora é hora de percorrermos cada elemento do array e também imprimir os elementos do String Array.

Como acontece com todos os arrays, você pode iterar em um String Array usando for loop e for aprimorado.

Dado abaixo é um Implementação Java que demonstra o uso de um loop for aprimorado para percorrer / iterar a matriz e imprimir seus elementos.

 public class Main { public static void main(String() args) { //declare and initialize a string array String() numArray = {'one','two', 'three', 'four', 'five'}; System.out.println('String Array elements displayed using for loop:'); // for loop to iterate over the string array for(int i=0; i Resultado: 
  
 No programa acima, tanto o loop for quanto o loop for aprimorado são usados para percorrer a matriz de strings. Observe que, no caso do loop for aprimorado, não é necessário especificar o limite ou a condição final. No caso do loop ‘for’, você precisa especificar a condição inicial e final.
 Adicionar ao String Array
 Assim como os outros tipos de dados, você também pode adicionar elementos para String Arrays. Nesta seção, vamos ver os vários métodos para adicionar um elemento à matriz de string.
 Usando pré-alocação
 Neste método, você cria uma matriz com um tamanho maior. Por exemplo, se você tiver que armazenar 5 elementos na matriz, criará uma matriz com tamanho 10. Dessa forma, você pode adicionar facilmente novos elementos no final da matriz.
  Um exemplo que implementa a adição de um elemento à matriz pré-alocada é mostrado abaixo. 
 import java.util.*; public class Main { public static void main(String() args) { String() colorsArray = new String(5); // initial array values colorsArray(0) = 'Red'; colorsArray(1) = 'Green'; colorsArray(2) = 'Blue'; System.out.println('Original Array:' + Arrays.toString(colorsArray)); intnumberOfItems = 3; // try to add new value at the end of the array String newItem = 'Yellow'; colorsArray(numberOfItems++) = newItem; System.out.println('Array after adding one element:' + Arrays.toString(colorsArray)); } }  Resultado: 
  
 Observe que o espaço não ocupado na matriz é definido como Nulo. A desvantagem desse método é que há desperdício de espaço, pois você pode criar uma grande matriz que pode permanecer desocupada.
 Usando um novo array
 Neste método, você cria uma nova matriz com um tamanho maior do que a matriz original para que possa acomodar o novo elemento. Depois de criar a nova matriz, todos os elementos da matriz original são copiados para esta matriz e, em seguida, o novo elemento é adicionado ao final da matriz.
  Um programa de exemplo para adicionar um elemento usando a nova matriz é mostrado abaixo. 
estágios no ciclo de vida de desenvolvimento de software
 importjava.util.*; public class Main { public static void main(String() args) { //original array String() colorsArray = {'Red', 'Green', 'Blue' }; System.out.println('Original Array: ' + Arrays.toString(colorsArray)); //length of original array int orig_length = colorsArray.length; //new element to be added to string array String newElement = 'Orange'; //define new array with length more than the original array String() newArray = new String( orig_length + 1 ); //add all elements of original array to new array for (int i=0; i  Resultado: 
  
 Essa abordagem resulta claramente em sobrecarga de memória e desempenho, pois você precisa manter dois arrays no programa.
 Usando ArrayList
 Você também pode adicionar um elemento à matriz String usando ArrayList como uma estrutura de dados intermediária.
  Um exemplo é mostrado abaixo. 
 import java.io.*; import java.lang.*; import java.util.*; class Main { public static void main(String() args) { // define initial array String numArray() = { 'one', 'two', 'three', 'four', 'five', 'six' }; // print the original array System.out.println('Initial Array:
' + Arrays.toString(numArray)); // new element to be added String newElement = 'seven'; // convert the array to arrayList ListnumList = new ArrayList( Arrays.asList(numArray)); // Add the new element to the arrayList numList.add(newElement); // Convert the Arraylist back to array numArray = numList.toArray(numArray); // print the changed array System.out.println('
Array with value ' + newElement + ' added:
' + Arrays.toString(numArray)); } }  Resultado: 
  
 Conforme mostrado no programa acima, a matriz de string é primeiro convertida em uma ArrayList usando o método asList. Em seguida, o novo elemento é adicionado ao ArrayList usando o método add. Depois que o elemento é adicionado, o ArrayList é convertido de volta para a matriz.
 Esta é uma abordagem mais eficiente quando comparada às discutidas anteriormente.
 String Array contém
 No caso de você querer saber se uma determinada string está presente na matriz de string ou não, você pode usar o método 'contém'. Para isso, você precisa primeiro converter a matriz de string em ArrayList, pois esse método pertence a ArrayList.
  A implementação a seguir mostra o uso do método 'contém'. 
 import java.io.*; import java.lang.*; import java.util.*; class Main { public static void main(String() args) { String() words = new String(){'C++', 'Java', 'C', 'Python'}; // Convert String Array to List Listwordslist = Arrays.asList(words); String tochk = 'Java'; if(wordslist.contains(tochk)){ System.out.println('The word ' + tochk + ' present in string array'); } else System.out.println('The word ' + tochk + ' not present in string array' ); } }  Resultado: 
  
 Primeiro, verificamos se a matriz de string fornecida contém a string ‘Java’. Conforme está presente, uma mensagem apropriada é exibida. Em seguida, alteramos a string a ser verificada para ‘C #’. Nesse caso, o método ‘contém’ retorna falso.
  
 Observe que, para o método contém, a string passada como um argumento sempre diferencia maiúsculas de minúsculas. Assim, na implementação acima, se fornecermos ‘java’ como um argumento para o método contém, ele retornará falso.
 Classificar um array de string
 Já vimos um tópico detalhado sobre ‘Classificação em matrizes’. Os métodos para classificar um array de strings são iguais aos dos outros arrays.
  A seguir, é fornecida uma implementação do método ‘sort’ da classe ‘Arrays’, que classifica as strings na matriz em ordem alfabética. 
 import java.util.*; class Main { public static void main(String() args) { String() colors = {'red','green','blue','white','orange'}; System.out.println('Original array: '+Arrays.toString(colors)); Arrays.sort(colors); System.out.println('Sorted array: '+Arrays.toString(colors)); } } Resultado: 
  
 A saída do programa acima mostra a matriz de entrada original, bem como a matriz de saída que é classificada em ordem alfabética.
 Procure por uma string na matriz de strings
 Além do método ‘contém’ que acabamos de discutir, você também pode pesquisar uma string específica em um String Array percorrendo cada elemento do String Array. Aqui, você vai comparar cada elemento da String Array com a string a ser pesquisada.
 A pesquisa é encerrada quando a primeira ocorrência da string é encontrada e o índice correspondente da string na matriz é retornado. Se a string não for encontrada até o final da matriz da string, uma mensagem apropriada será exibida.
  Essa implementação é mostrada no seguinte programa Java. 
 import java.util.*; class Main { public static void main(String() args) { String() strArray = { 'Book', 'Pencil', 'Eraser', 'Color', 'Pen' }; boolean found = false; int index = 0; String searchStr = 'Pen'; for (int i = 0; i  Resultado: 
  
 O programa acima procura a string ‘Pen’ em uma determinada matriz de strings e retorna seu índice correspondente quando ele é encontrado.
 Converter String Array em String
 Vamos discutir as maneiras de converter array de string em string. Discutiremos três métodos diferentes para fazer isso com um exemplo de cada um.
 Usando o método toString
 O primeiro método usa o método ‘toString’ da classe ‘Arrays’. Ele pega o array de strings como argumento e retorna a representação de string do array.
  O programa Java a seguir mostra o uso do método toString. 
 import java.util.*; public class Main { public static void main(String args()) { //declare a string String() str_Array = {'This','is','Software','Testing','Help'}; System.out.println('String array converted to string:' + Arrays.toString(str_Array)); } }  Resultado: 
  
 O programa acima usa o método ‘toString’ para exibir a representação de string da matriz de string fornecida.
 Usando o método StringBuilder.Append ()
 A próxima abordagem de conversão de array de string em string é usar a classe ‘StringBuilder’. Você deve criar um objeto do tipo StringBuilder e usar o método ‘Append’ de StringBuilder para anexar os elementos da matriz de string ao objeto StringBuilder, um por um.
 Depois que todos os elementos da matriz são anexados ao objeto StringBuilder, você pode usar o método ‘toString’ neste objeto para finalmente obter a representação da string.
 import java.util.*; public class Main { public static void main(String args()) { //string array String() str_Array = {'This','is','Software','Testing','Help'}; System.out.print('Original string array:'); //print string array for(String val:str_Array) System.out.print(val + ' '); System.out.println('
'); //construct a stringbuilder object from given string array StringBuilder stringBuilder = new StringBuilder(); for (int i = 0; i  Resultado: 
  
 O programa acima mostra a conversão de array de string em string usando a classe StringBuilder.
 Usando operação de união
 Você também pode usar a operação de 'junção' da classe String para transformar a matriz de string em uma representação de string.
 A operação de 'junção' leva dois argumentos, o primeiro é o separador ou delimitador da string e o segundo argumento é a matriz da string. A operação de junção então retorna a string separada por um separador especificado (primeiro argumento).
  Verifique o programa a seguir que demonstra o uso da operação de junção para obter uma string de um String Array. 
 import java.util.*; public class Main { public static void main(String args()) { //string array String() str_Array = {'This','is','Software','Testing','Help'}; System.out.println('Original string array:'); //print the string array for(String val:str_Array) System.out.print(val + ' '); System.out.println('
'); //form a string from string array using join operation String joinedString = String.join(' ', str_Array); //print the string System.out.println('String obtained from string array:' + joinedString); } }  Resultado: 
o gateway padrão não está disponível constantemente
  
 Converter String em String Array
 Vamos ver a operação reversa de converter uma string em uma matriz de string. Existem dois métodos para fazer essa conversão.
 Usando Operação Dividida
 O primeiro método de converter uma string em um array de string é usar a operação de divisão da classe String. Você pode dividir a string em um delimitador especificado (vírgula, espaço, etc.) e retornar a matriz de string recém-gerada.
  A implementação a seguir demonstra o uso da operação de divisão. 
 public class Main { public static void main(String args()) { //declare a string String myStr = 'This is Software Testing Help'; //use split function to split the string into a string array String() str_Array = myStr.split(' ', 5); System.out.println('String Array after splitting the string '' + myStr + '':'); //display the string array for (int i=0;i
 O programa acima usa a função de divisão para dividir a string com base no espaço e retorna uma matriz de string de 5 elementos.
 Usando o padrão Regex
 O próximo método para converter a string em uma matriz de string é usar expressões regulares. Você pode especificar um padrão e então dividir a string dada de acordo com o padrão especificado.
 Você pode usar Classe Regex Pattern pertencente ao pacote java.util.
  A seguir, é fornecido um exemplo de uso de padrões para converter string em String Array. 
 import java.util.Arrays; import java.util.regex.Pattern; public class Main { public static void main(String args()) { //declare a string String myStr = 'This is Java series tutorial'; System.out.println('The original string:' + myStr + '
'); String() str_Array = null; //split string on space(' ') Pattern pattern = Pattern.compile(' '); //use pattern split on string to get string array str_Array = pattern.split(myStr ); //print the string array System.out.println('String Array after splitting the string using regex pattern:'); for (int i=0;i
 No programa acima, o padrão que especificamos é um caractere de espaço. Assim, a string é dividida em espaços e retorna a matriz da string. Como você já pode deduzir, o uso de expressões regulares e padrões é uma forma muito mais eficiente de programação.
 Converter String Array em Lista
 Você também pode converter a matriz de string em uma lista. Listamos alguns métodos para fazer isso
 Usando código personalizado
 O primeiro método é usar o código personalizado para converter a matriz de string em lista. Neste método, uma matriz de string é percorrida e cada elemento é adicionado à lista usando o método add da lista.
  O programa a seguir mostra essa implementação. 
 import java.util.*; public class Main { public static void main( String() args ) { //a string array String() numArray = { 'One', 'Two', 'Three', 'Four', 'Five' }; System.out.println('The string array:' + Arrays.toString(numArray)); //define arraylist with size same as string array Liststr_ArrayList = new ArrayList(numArray.length); //add string array elements to arraylist for (String str:numArray) { str_ArrayList.add(str ); } System.out.println('
Arraylist created from string array:'); //print the arraylist for (String str : str_ArrayList) { System.out.print(str + ' ' ); } } }  Resultado: 
  
 Conforme mostrado no programa acima, uma lista é criada primeiro. Em seguida, usando o loop for-each, cada elemento do array string é adicionado à lista. Finalmente, a lista é impressa.
 Usando o método Collections.addAll ()
 O segundo método de conversão de matriz de string em uma lista é usando o método ‘addAll’ da estrutura de coleções. O método addAll () pega a ArrayList e a matriz de string como entrada e copia o conteúdo da matriz de string para ArrayList.
  O programa a seguir mostra o uso do método addAll para converter a matriz de string em lista. 
 import java.util.*; public class Main { public static void main( String() args ) { //a string array String() vehiclesArray = { 'moped', 'car', 'SUV', 'bicycle', 'bus' }; System.out.println('The string array:' + Arrays.toString(vehiclesArray)); //define arraylist with size same as string array List str_ArrayList = new ArrayList(vehiclesArray.length); //add string array elements to arraylist using Collections.addAll method Collections.addAll(str_ArrayList, vehiclesArray ); System.out.println('
Arraylist created from string array:'); //print the arraylist for (String str : str_ArrayList) { System.out.print(str + ' ' ); } } }  Resultado: 
  
 No programa acima, convertemos um determinado array de strings em uma lista usando o método Collections.addAll.
 Usando Arrays.asList ()
 Finalmente, a classe Array fornece o método ‘asList ()’ que converte a matriz de string fornecida na lista diretamente.
como abrir arquivos .jar com java
  A seguir está um programa Java que usa asList. 
 import java.util.*; public class Main { public static void main( String() args ) { //a string array String() vehiclesArray = { 'moped', 'car', 'SUV', 'bicycle', 'bus' }; System.out.println('The string array:' + Arrays.toString(vehiclesArray)); //Convert array to list using asList method List str_ArrayList = Arrays.asList(vehiclesArray ); System.out.println('
Arraylist created from string array:'); //print the arraylist for (String str : str_ArrayList) { System.out.print(str + ' ' ); } } }  Resultado: 
  
 Conforme mostrado acima, o método asList da classe Arrays converte a matriz em lista e retorna essa lista.
 Converter a lista em string
 Na seção anterior, vimos alguns métodos para converter array de string em lista. Agora, vamos ver os métodos para converter a lista em uma matriz de string.
 Usando ArraList.get ()
 O primeiro método é obter um método de ArrayList que retorna os elementos individuais da lista. Você pode percorrer o ArrayList e chamar o método get que retornará um elemento que pode então ser atribuído ao local da matriz.
  O programa a seguir mostra essa implementação. 
 import java.util.*; public class Main { public static void main( String() args ) { //ArrayList initialization ArrayList str_ArrayList= new ArrayList(); //add items to the arraylist str_ArrayList.add('str1'); str_ArrayList.add('str2'); str_ArrayList.add('str3'); str_ArrayList.add('str4'); str_ArrayList.add('str5'); //ArrayList to Array Conversion String str_Array() = new String(str_ArrayList.size()); for(int j =0;j Resultado: 
  
 O programa acima mostra a conversão de ArrayList em array de string usando o método get.
 Usando o método ArrayList.toArray ()
 ArrayList fornece um método ‘toArray ()’ que retorna uma representação de matriz de ArrayList. Portanto, você pode obter uma matriz de string de uma string ArrayList usando este método.
  Verifique o seguinte programa que usa o método toArray. 
 import java.util.*; public class Main { public static void main( String() args ) { //ArrayList initialization ArrayList str_ArrayList= new ArrayList(); //add items to the arraylist str_ArrayList.add('Mumbai'); str_ArrayList.add('Delhi'); str_ArrayList.add('Pune'); str_ArrayList.add('Chennai'); str_ArrayList.add('Kolkata'); //ArrayList to Array Conversion using toArray method String str_Array()=str_ArrayList.toArray(new String(str_ArrayList.size())); //print array elements System.out.println('String array obtained from string arraylist:'); for(String ary: str_Array){ System.out.print(ary + ' '); } } }  Resultado: 
  
 Primeiro, os elementos são adicionados ao ArrayList e, em seguida, usando o método ‘toArray’, a lista é convertida em uma matriz de string.
 Converter String Array em Int Array
 Às vezes, você pode precisar fazer operações em números. Nesse caso, se o array de strings tiver conteúdo numérico, é aconselhável converter esse array de strings para int array. Para isso, você precisa usar a função ‘parseInt’ em cada elemento da matriz e extrair o inteiro.
  O programa a seguir mostra a conversão do array string em um array int. 
 import java.util.*; public class Main { public static void main( String() args ) { //string arrya declaration String () str_Array = {'10', '20','30', '40','50'}; //print the string array System.out.println('Original String Array:'); for(String val:str_Array) System.out.print(val + ' '); System.out.println('
The integer array obtained from string array:'); //declare an int array int () int_Array = new int (str_Array.length); //assign string array values to int array for(int i=0; i Resultado: 
  
 No programa acima, temos um array de strings que contém os números como strings. Neste programa, cada um dos elementos da matriz de string é analisado usando a função ‘parseInt’ e atribuído a uma matriz do tipo int.
 Observe que essa conversão funcionará apenas em uma matriz de string com elementos numéricos. Se qualquer um dos elementos na matriz da string não for numérico, o compilador lançará ‘java.lang.NumberFormatException’.
 perguntas frequentes
  Q # 1) Qual é a diferença entre um Array e uma String em Java? 
  Responda:  A matriz é uma sequência contígua de elementos. A string é uma sequência de caracteres terminada por um caractere nulo. Strings são imutáveis, ou seja, uma vez definidas, não podem ser alteradas. Todas as alterações foram feitas nos resultados da string em uma nova string.
 Arrays são mutáveis. Os arrays podem conter elementos de vários tipos de dados, incluindo strings.
  P # 2) Como você declara um array em Java? 
  Responda: A maneira geral de declarar uma matriz em java é:
  tipo array_name ();  
Ou 
  type () array_name; 
 Portanto, se myarray é uma variável de array com elementos do tipo int, então este array pode ser declarado como:
  int myarray ();  
Ou 
  int () myarray; 
  P # 3) Como faço para criar um Array of Strings? 
  Responda: Se strArray for uma matriz de string, sua declaração pode ser:
  String () strArray;  
Ou 
  String strArray (); 
  P # 4) O que é String () args? 
  Responda: String () args em Java é uma matriz de strings que contém argumentos de linha de comando que podem ser passados para um programa Java.
  P # 5) Os arrays podem conter strings? 
  Responda:  sim. Assim como os arrays podem conter outros tipos de dados, como char, int, float, os arrays também podem conter strings. Nesse caso, a matriz se torna uma matriz de 'matriz de caracteres', pois a string pode ser vista como uma sequência ou matriz de caracteres.
 Conclusão
 Neste tutorial, vimos os detalhes do String Array em Java. Passamos por todos os principais conceitos relacionados a String Array, incluindo declaração, definição e inicialização de string array em Java.
 Também discutimos várias operações como pesquisa, classificação, junção, etc. e conversão de array de string em lista, string, array int, etc. Com isso, completamos nossa discussão sobre arrays de string.
   Em nossos tutoriais subsequentes, discutiremos matrizes multidimensionais em Java.  
  => Aprenda Java do zero aqui  
  Leitura recomendada
    Tutorial de comprimento de array Java com exemplos de código  
  Tutorial Java String com String Buffer e String Builder  
  Tutorial de JAVA para iniciantes: mais de 100 tutoriais práticos em vídeo Java  
  Como classificar uma matriz em Java - Tutorial com exemplos  
  Reverter uma matriz em Java - 3 métodos com exemplos  
  Tutorial de string C # - Métodos de string com exemplos de código  
  String Array C ++: Implementação e Representação com Exemplos  
  Java 'this' Palavra-chave: Tutorial com exemplos de código