Computêro

public static String cBinario(int n){
		ArrayList resto = new ArrayList();
 
		while (n != 0){
			resto.add((n%2)+"");
			n = (int)(n/2);
		}
 
		String res = "";
		for (int i=resto.size()-1;i>=0;i--){
			res += resto.get(i);
		}
		return res;
	}

public static String cBinarioRec(int n){
		String ret="";
		if (n > 0){
			ret += cBinarioRec(n/2)+n%2;
		}
		return ret;
	}

public static void main (String args[]){
		int num = 69;
 
		System.out.println(cBinario(num));
		System.out.println(cBinarioRec(num));
	}

//Hello.java
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
 
public class Hello extends MIDlet implements CommandListener {
	private Command exitCommand; //comando acionado por teclas do dispositivo
	private Display display; //manipulador da tela do dispositivo
	private TextBox tbMain; //uma tela que permite mostrar e editar informações
 
	public Hello() {
		display = Display.getDisplay(this);
		exitCommand = new Command("Exit", Command.SCREEN, 2);
		tbMain = new TextBox("Meu primeiro app","Olá, mundo!", 150, 0);
		tbMain.addCommand(exitCommand);
		tbMain.setCommandListener(this);
	}
 
	public void startApp() {
		display.setCurrent(tbMain);
	}
 
	public void pauseApp() {
		// método abstrato da classe MIDlet que
		// deve ser implementado
	}
 
	public void destroyApp(boolean unconditional) {
		//método abstrato da classe MIDlet que deve
		//ser implementado
	}
 
	public void commandAction(Command c, Displayable s) {
		if (c == exitCommand) {
			destroyApp(false);
			notifyDestroyed();
		}
	}
} //fim da classe

String s = new String ();
s = "String";
 
String s = new String ("String");
 
String s = "String";

String s = "Comput";
s.concat("ero");
System.out.println("x = " + s); //resultado s = Comput

String s = "Comput";
s = s.concat("ero");
System.out.println("x = " + x); //resultado x = Computero

String var1 = "Computero";
String var2 = "Computero";

StringBuilder sb = new StringBuilder();
sb.append("Comput");
sb.append("ero");
system.out.println("x = " + sb);//x = Computero

//usando o metodo reverse da classe StringBuffer
 
public class Reverse {
 
public static void main(String args[]){
StringBuilder sb = new StringBuilder();
sb.append("Computero");//concatenando String
sb.append(2009);//concatenando int
sb.append('H');//concatenando char
System.out.println(sb);//imprimindo sb - Computero2009H
System.out.println(sb.reverse());//imprimindo de forma reversa sb - H9002oretupmoC
}
}

//exemplo usando alguns metodos da classe StringBuilder
 
public class Reverse {
public static void main(String[] args) {
StringBuilder sb= new StringBuilder("Computero");
 
/*metodo que remove pelo indice a partir do indice 6 (conta com ele) até o indice 9(não conta com ele)*/
sb.delete(6, 9);
/*imprimi Comput*/
System.out.println(sb);
/*concatena - a String portanto sb esta valendo Comput-*/
sb.append("-");
/*insere na posição 7 a palavra Jaqueline*/
sb.insert(7,"Jaqueline");
//imprimi Comput-Jaqueline
System.out.println(sb);
/*concatena -Bento a String portanto sb esta valendo Comput-Jaqueline-Bento*/
sb.append("-Bento");
/*imprimi Comput-Jaqueline-Bento*/
System.out.println(sb.toString());
}}/*a vantagem de usar StringBuilder ou StringBuffer é que nao tenho objetos perdidos na minha memória*/

/*
 * ============================================================
 * Lucas Felix de Sousa - 736627
 * Avaliação Parcial de Técnicas de Programação II - A
 * Universidade Cruzeiro do Sul
 * http://blog.computero.com.br
 * =============================================================
 * 
 * Classe com implementação de Thread, comunicação client-server
 * Utilização de Criptografia, Socket e Thread
 * 
 * =============================================================
 * */
 
import java.io.*;
import java.net.*;
import java.util.*;
 
public class ServerCrypt extends Thread{
	private static Vector clientes;
	private Socket conexao;
 
	public ServerCrypt(Socket s){
    	conexao = s;
    }
 
	/*Método para criptografar um texto qualquer,
	 * passando como parâmetro a mensagem em string 
	 * e a chave em inteiro
	 */  
	public static String Crypt(String msg,int n){
		String newMsg="";
 
		/*for para deixar os caracteres ao contrario
		 * exemplo:
		 * aeiou - uoiea
		 */
		for (int i=msg.length()-1;i>=0;i--)
		{
			/*somar a quantidade de digitos (n) ao char*/
			newMsg += "" + (char)(msg.charAt(i)+n);
		}
		//retornando a mensagem criptografada
		return(newMsg);
	}	
 
	/*Método para desciptografar a criptografia anterior
	 * passando como parâmetro a mensagem a ser descriptografada em String
	 * e a chave em inteiro
	 */
	public static String Descrypt(String msg,int n){
		String newMsg="";
		/*for para deixar os caracteres de volta ao normal
		 * exemplo:
		 * uoiea - aeiou
		 */
		for (int i=msg.length()-1;i>=0;i--)
		{
			/*subtrair a quantidade de digitos (n) ao char*/
			newMsg += "" + (char)(msg.charAt(i)-n);
		}
		return newMsg;
	}
 
	public static void main(String args[]){
    	clientes = new Vector();
    	try{
    		ServerSocket s = new ServerSocket(6666);
    		while(true){
    			System.out.print("Esperando alguem se conectar...");
    			Socket conexao = s.accept();
   				System.out.println(" Conectou!");
   				Thread t = new ServerCrypt(conexao);
    			t.start();
    		}
    	}
    	catch(IOException e){    	
    	}
    }
 
	public void run(){
    	try{
    		//para receber os dados dos clientes
    		BufferedReader entrada = new BufferedReader(new InputStreamReader(conexao.getInputStream()));
 
    		//para enviar os dados para os clientes
   			PrintStream saida = new PrintStream(conexao.getOutputStream());
 
   			//texto padrão ao cliente se conectar
   			String texto = "
Cliente" + conexao.getInetAddress() + " - " + conexao.getInetAddress().getHostName() + " tenta se comunicar
";
       		System.out.println(texto + "
Pronto para o envio dos dados...
");
       		try{
       			while(true)
       			{
       				String strCliente[] = entrada.readLine().toString().split(";"); 
 
       				/*verifica se os dados enviados pelo cliente estão em 3 parâmetros
       				 * opção - crypt ou descrypt (IgnoreCase)
       				 * num - Um digito inteiro entre 0 e 9
       				 * mensagem - uma string com QUALQUER texto, inclusive espaços
       				 */
       				if (strCliente.length != 3)
       				{
       					saida.println("Formato inválido. [OPCAO;NUM;MENSAGEM]");
       				}
       				else
       				{
       					try{
       						int num;
       						num = Integer.parseInt(strCliente[1]);
 
       						/*O número digitado é mudado de acordo com a tabela a seguir:
       						 * num: 0 ou 1 --> A = B (soma 1)
       						 * num: 2 ou 3 --> A = C (soma 2)
       						 * num: 4 ou 5 --> A = D (soma 3)
       						 * num: 6 ou 7 --> A = E (soma 4)
       						 * num: 8 ou 9 --> A = F (soma 5)
       						 */
 
       						if ((num == 0) || (num==1)){
       							num = 1;
       						}
       						else if ((num == 2) || (num==3)){
       							num = 2;
       						}
       						else if ((num == 4) || (num==5)){
       							num = 3;
       						}
       						else if ((num == 6) || (num==7)){
       							num = 4;
       						}
       						else if ((num == 8) || (num==9)){
       							num = 2;
       						}
       						else{
       							saida.println("Formato do número inválido");
       						}
       						/*Verifico qual a opção desejada pelo cliente e devolvo a resposta*/
       						if (strCliente[0].equalsIgnoreCase("CRYPT")){
           						saida.println(
           									Crypt(
           										strCliente[2],
           										num
           										)
           									);
           					}
           					else if(strCliente[0].equalsIgnoreCase("DESCRYPT")){
           						saida.println(
       									Descrypt(
       										strCliente[2],
       										num
       										)
       									);
           					}
           					else{
           						saida.println("Comando inválido, somente [Crypt] e [Descrypt]");
           					}
       					}
       					catch(Exception e)
       					{
       						saida.println("Erro ao converter a chave");
       					}       					
       				}
       			}
       		}
       		catch(Exception ex){
       		}
    	}
    	catch(IOException e){
    		System.out.println("IOException: " + e);
    	}
    }
}

/*
 * ============================================================
 * Lucas Felix de Sousa - 736627
 * Avaliação Parcial de Técnicas de Programação II - A
 * Universidade Cruzeiro do Sul
 * http://blog.computero.com.br
 * =============================================================
 * 
 * Classe com implementação de Thread, comunicação client-server
 * Utilização de Criptografia, Socket e Thread
 * 
 * =============================================================
 * */
 
import java.io.*;
import java.net.*;
 
public class ClientCrypt extends Thread{
	private Socket conexao;
  	//private static boolean done = false;
 
  	public ClientCrypt(Socket s) {
  		conexao = s;
 	}
 
  	public static void main(String args[]){
  		try{
  			/*indico a qual computador ele vai se conectar e a qual porta
  			 * lembrando que é recomendável utilizar portas maiores que 1000
  			 * pois as anteriores são reservadas ao Sistema Operacional
  			 */  			
  			Socket conexao = new Socket("localhost", 6666);
 
  			Thread t = new ClientCrypt(conexao);
   			//iniciando a Thread e chamando o método run()
  			t.start();
  		}
  		catch(IOException e){
  			System.out.println("IOException: " + e);
  		}
  	}
 
  	public void run(){
  		try{
  			//receber os dados do servidor
  			BufferedReader entrada = new BufferedReader(new InputStreamReader(conexao.getInputStream()));
  			//receber os dados do teclado
  			BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in));
  			//enviar dados para o servidor
  			PrintStream saida = new PrintStream(conexao.getOutputStream());
 
  			while (true)
  			{
  				/*Exemplo de utilização:
  				 * Criptografar:
  				 * crypt;7;http://computero.com.br
  				 * Descriptografar:
  				 * descrypt;7;vf2qsg2svixytqsg2kspf33>txxl
  				 */
 
  				System.out.println("Envie a mensagem para o servidor no seguinte formato: [OPCAO;NUM;MENSAGEM], ou FIM para sair");
	  			String str = teclado.readLine();
 
	  			//se for fim saio do loop
	  			if (str.equalsIgnoreCase("FIM"))
	  			{
	  				break;
	  			}
	  			else
	  			{
	  				//senão envio pro servidor e obtenho a resposta
	  				saida.println(str);	
					System.out.println("Resposta: " + entrada.readLine() + "
");	  			
	  			}
  			}  			
  		}
  		catch(IOException e){
 
  		}
  	}
}

 /*
Autor: Lucas Felix de Sousa - Computero
05/04/2009 - 00:15
http://blog.computero.com.br
*/
public class primo{
//função que imprime os valores primos até determinado número (n)
public static void printPrimo(int n){
//indica se o valor é primo ou não
boolean primo;
//simples contador
int iNum;
//string para concatenar os numeros primos
String strPrimos = "";
//laço de 1 até n para ver quais os primos
for (int i=1;i<=n;i++)
{
//o numero 1 sempre é primo
if (i==1){
primo = true;
}
else{
//inicio com 2, pq todo numero dividido por 1 tem resto 0
iNum = 2;
//digo que todo numero é primo até que se prove o contrário
primo = true;
//faço um loop de iNum (iniciando em 2) até menor que i
while(iNum < i){
//se o valor do resto da divisão de i por iNum for 0, o i não é primo
if (i%iNum == 0)
{
primo = false;
}
//se primo for false, saio do loop, é importante sair do loop por questão de desempenho
if (primo == false){
break;
}
//senão incremento e tento com o próximo numero
else{
iNum ++;
}
}
}
//se o valor depois de todos os testes permanecer como true, eh pq o i é primo
if (primo == true)
{
strPrimos += i + ",";
}
}
//imprimo a string
System.out.println(strPrimos);
}
public static void main(String args[]){
//chamada da função
printPrimo(100);
}
}