prova pp

=============================================================================================
				Matrizes
=============================================================================================
• Random gerador = new Random(); // Declaração random , gerador.nextInt(50);


• m[linha][coluna]
• int[][] m = new int[5][5];

• int[][] m = { {1, 2, 3, 4, 5}, {6, 7, 8, 9, 10} };
• int numLinhas = m.length; //número de linhas = 2
• int numColunas = m[linha].length; //número de colunas = 5

• Para imprimir uma matriz:
     for linha{
	for coluna{
	   sout "" + m[l][c];
	}
	sout \n
     }
• Entrada de dados: 2 for L e C (igual a cima) + dados[linha][coluna] = entrada.nextInt();
• Somar matriz toda: 2 for, soma += matriz[lin][col]; , soma inicializado fora do for
• Soma das linhas: 2 for, soma += matriz[lin][col]; , soma inicializado dentro do 1º for
     sout depois do segundo for, dentro do primeiro for

• Soma diagonal de matriz: 1 for da linha, soma += matriz[lin][lin]; , sout fora do for
=============================================================================================
				Igualdade de Strings
=============================================================================================
• str1 == str2; // verifica se apontam para o mesmo endereço de memória
• str1.equals(str2);// verifica se tem o mesmo conteúdo
• nome1.equalsIgnoreCase(nome2); // verifica se tem o mesmo conteúdo ignorando o
     case da palavra.
=============================================================================================
				Comparando Strings
=============================================================================================
• boolean equals(Object anObject) //serve para testar se duas Strings são iguais
• boolean equalsIgnoreCase(String anotherString) //Retorna true se o argumento é
     um objeto String que representa a mesma sequência de caracteres da String
     que chama o método
• int compareTo(String anotherString) //Retorna um inteiro que indica se a String
     que chamadora é maior que (resultado é> 0), igual a (resultado é = 0), ou
     menos do que (resultado é <0) que a String do argumento.
• int compareToIgnoreCase(String str) //igual /\, mas ignora o case
• boolean endsWith(String suffix) // Retorna true se a String termina com ou começa
• boolean startsWith(String prefix) // com a substring especificada como argumento
     para o método. Ex: verd = s2.startsWith(“bc”);  Ex: verd = s2.endsWith(“bc”);
=============================================================================================
				Operando com Strings
=============================================================================================
• s3 = s3.concat("def"); String s3 = "abc"; //MAYBE abc+def = abcdef
• char = s2.charAt(int pos) // retorna um caractere de uma String em uma posição
     específica.
• String = s2.replace(char oldChar, char newChar); //Substitui cada ocorrência de
     um caractere em uma String por outro caractere.
• String = s2.substring(int beginIndex); //retorna uma nova String, copiando um
     trecho indicado de uma String específica Ex: novaString = s2.substring(2);
  String = s2.substring(int beginIndex, int endIndex) //Neste caso, da posição
     (beginIndex) até a posição (endIndex – 1) ou seja, beginIndex é inclusivo e
      endIndex é exclusivo. Ex: novaString = s2.substring(2, 9);
• int = s2.indexOf(char caracter); // retorna a posição da primeira ocorrência de
      um caractere numa String;
  int = s2.indexOf(char caracter, int inicio); // retorna a posição da primeira
      ocorrência de um caractere numa String a partir da posição especificada no
      segundo argumento (inicio);
  int = s2.indexOf(String s1); // Retorna a posição do primeiro caractere da primeira
      ocorrência de uma String em outra String;
• int = s2.lastIndexOf( . . . ); //posicao = s2.lastIndexOf(‘a’);   localiza a última
      ocorrência de um caractere em uma String
• String = s2.toUpperCase(); //tudo maiusculo
• String = s2.toLowerCase(); //tudo minusculo
• s2.trim(); // remove todos os caracteres em branco do inicio ao fim da string original
=============================================================================================
				StringBuffer (Construtores)
=============================================================================================

• StringBuffer() // Reserva um tamanho de 16 caracteres
• StringBuffer(int size)
 //é ajustado automaticamente com o valor do parâmetro.
• StringBuffer(String str)//Coloca o tamanho inicial do StringBuffer com o tamanho da String
      e acrescenta mais 16 caracteresde capacidade.
• int capacity() // retorna toda a capacidade alocada do StringBuffer

• int length() // retorna o tamanho atual do StringBuffer
• charAt(posicao) // igual string
• setCharAt(pos, ch) // (sobrepoe) este método seta o caractere ‘ch’ na posição especificada
• Insert() // (insere) método utilizado para a inserção de caracteres
• reverse() // retorna a string contida ao contrário

• deleteCharAt(posicao) // Remove um caractere indicado pelo índice posicao
• delete(pos_inicial, pos_final): Remove os caracteres desde pos_inicial até pos_final – 1
• append() // é utilizado para adicionar caracteres no final da String
      StringBuffer append(String str) : adiciona a String str no final
      StringBuffer append(int num) : converte o inteiro em uma String e adiciona no final
      StringBuffer append(Object obj) : o objeto é convertido para String através do método
	toString() e adiciona no final
=============================================================================================
				StringTokenizer
=============================================================================================
• Construtor com 1 argumento: StringTokenizer componentes = new StringTokenizer (frase);
• Construtor com dois argumentos: StringTokenizer componentes = new StringTokenizer (frase, “|”);
• countTokens() // Retorna a quantidade de tokens

• hasMoreTokens() // Retorna um valor booleano informando se ainda há tokens a serem processados
• nextToken() // Retorna uma String com o próximo token
• EXEMPLO:
      StringTokenizer str = new StringTokenizer (frase);
      while (str.hasMoreTokens())
	System.out.println(str.nextToken());
=============================================================================================
				Fluxos de Bytes e Caracteres
=============================================================================================

• Byte : InputStream e OutputStream
• Caractere : Reader e Writer
• Ler arquivo usando Fluxo de Byte:
public static void main(String[] args) throws IOException {
	InputStream is = new FileInputStream("arquivo.txt");
	int b = is.read();
	System.out.println("O valor lido do arquivo é: " + b);
}
• Gravando Arquivos Usando Fluxo de Bytes:
public static void main(String[] args) throws IOException {
	String entrada = "1237890";
	FileOutputStream fout = new FileOutputStream("arquivo.txt");
	for(int c = 0; c < entrada.length(); c++)
	fout.write(entrada.charAt(c));
	System.out.println("Dados Gravados: " +entrada);
	fout.close();
}
•Use a FileReader/FileWriter to read/write characters from/to a file
public static void main(String[] args) throws IOException {
	BufferedReader br = new BufferedReader(new FileReader("ArqEntr.txt"));
	FileWriter fw = new FileWriter("ArqSaida.txt");
	String line;
	while ((line = br.readLine()) != null) {
		fw.write(line + "\r\n");
	}
	fw.close();
	br.close();
}




ARQUIVOS BUFFER, FALTA FAZER