Escrever valor monetário por extenso

package umcastec;  

import java.math.BigDecimal;

import java.math.BigInteger; 

import java.util.ArrayList; 

import java.util.Iterator;  

public class Escrver_Extenso{ 
     
private ArrayList nro; 


    private BigInteger num;
     
private String Qualificadores[][] = {{"centavo", "centavos"},  

{"", ""}, {"mil", "mil"}, 
{"milhão", "milhões"}, 
{"bilhão", "bilhões"}, 
{"trilhão", "trilhões"},       
{"quatrilhão", "quatrilhões"}, {"quintilhão", "quintilhões"}, 
{"sextilhão", "sextilhões"}, {"septilhão", "septilhões"}}; 
private String Numeros[][] = {
  {"zero", "um", "dois", "três", "quatro", "cinco", "seis", "sete", 
  "oito", "nove", "dez", "onze", "doze", "treze", "quatorze", 
  "quinze", "desesseis", "desessete", "dezoito", "desenove"},         
  {"vinte", "trinta", "quarenta", "cinquenta", "sessenta",     
  "setenta", "oitenta", "noventa"},    
  {"cem", "cento", "duzentos", "trezentos", "quatrocentos",     
  "quinhentos", "seiscentos", "setecentos", "oitocentos",       
  "novecentos"}};     
 /**      * Construtor      */    
 public JExtenso() {
         nro = new ArrayList();     

} 
     /**      * Construtor     
 *     
 * @param dec      
*            valor para colocar por extenso      */ 
    public JExtenso(BigDecimal dec) {        
   this();
   setNumber(dec);     
}   
   /**      
* Constructor for the JExtenso object      
* @param dec      
*            valor para colocar por extenso      */     
public JExtenso(double dec) {     
    this();     
    setNumber(dec);     }      
/**      
* Sets the Number attribute of the JExtenso object      
*      
* @param dec      
*  The new Number value      */     
public void setNumber(BigDecimal dec) {   
 // Converte para inteiro arredondando os centavos       
  num = dec.setScale(2, BigDecimal.ROUND_HALF_UP).multiply(        
    BigDecimal.valueOf(100)).toBigInteger();        
  // Adiciona valores   
      nro.clear();    
     if (num.equals(BigInteger.ZERO)) {       
      // Centavos          
   nro.add(new Integer(0));         
    // Valor    
         nro.add(new Integer(0));       
  } else {         
    // Adiciona centavos     
        addRemainder(100);   
           // Adiciona grupos de 1000    
         while (!num.equals(BigInteger.ZERO)) {          
       addRemainder(1000);            
 }     
    }    
 }     
 public void setNumber(double dec) {        
 setNumber(new BigDecimal(dec));     }     
 /**      * Description of the Method      */    
 public void show() {        
 Iterator valores = nro.iterator();       
   while (valores.hasNext()) {            
 System.out.println(((Integer) valores.next()).intValue());      
   }     
    System.out.println(toString());     }     
 /**      
* Description of the Method      *     
 * @return Description of the Returned Value      */   
  @Override     public String toString() {     
    StringBuffer buf = new StringBuffer();       
   int numero = ((Integer) nro.get(0)).intValue();   
      int ct;     
     for (ct = nro.size() - 1; ct > 0; ct--) {     
        // Se ja existe texto e o atual n�o � zero       
      if (buf.length() > 0 && !ehGrupoZero(ct)) {          
       buf.append(" e ");             }        
     buf.append(numToString(((Integer) nro.get(ct)).intValue(), ct));         }        
 if (buf.length() > 0) {    
         if (ehUnicoGrupo()) {    
             buf.append(" de ");             }
             while (buf.toString().endsWith(" ")) {  
               buf.setLength(buf.length() - 1);             }         
    if (ehPrimeiroGrupoUm()) {                
 buf.insert(0, "");             }          
   if (nro.size() == 2 && ((Integer) nro.get(1)).intValue() == 1) {    
             buf.append(" real");        
     } else {                
 buf.append(" reais");             }         
    if (((Integer) nro.get(0)).intValue() != 0) {              
   buf.append(" e ");             }         }       
  if (((Integer) nro.get(0)).intValue() != 0) {         
    buf.append(numToString(((Integer) nro.get(0)).intValue(), 0));         }     
    return buf.toString();     }      
private boolean ehPrimeiroGrupoUm() {       
  if (((Integer) nro.get(nro.size() - 1)).intValue() == 1) {        
     return true;         }         return false;     }   
   /**      
* Adds a feature to the Remainder attribute of the JExtenso object     
 *      
* @param divisor      
*   The feature to be added to the Remainder attribute      */     
private void addRemainder(int divisor) { 
 // Encontra newNum[0] = num modulo divisor, newNum[1] = num dividido     
// divisor         
BigInteger[] newNum = num.divideAndRemainder(BigInteger.valueOf(divisor));         
 // Adiciona modulo        
 nro.add(new Integer(newNum[1].intValue()));         
 // Altera numero     
    num = newNum[0];     }     
 /**      * Description of the Method      *      
* @param ps      
* Description of Parameter      
* @return Description of the Returned Value      */    
 
private boolean temMaisGrupos(int ps) {    
     for (; ps > 0; ps--) {            
 if (((Integer) nro.get(ps)).intValue() != 0) {             
    return true;             }         }         
 return false;     }   
   /**      * Description of the Method      
*      
* @param ps      
* Description of Parameter      
* @return Description of the Returned Value      */    
 private boolean ehUltimoGrupo(int ps) {      
   return (ps > 0) && ((Integer) nro.get(ps)).intValue() != 0             
    && !temMaisGrupos(ps - 1);     }      
/**      
* Description of the Method      
*      
* @return Description of the Returned Value      */     
private boolean ehUnicoGrupo() {       
  if (nro.size() <= 3) {             
return false;         }        
 if (!ehGrupoZero(1) && !ehGrupoZero(2)) {             
return false;         }        
 boolean hasOne = false;        
 for (int i = 3; i < hasone =" true;">= nro.size()) {          
   return true;        
 }         return ((Integer) nro.get(ps)).intValue() == 0;     }    
  /**      * Description of the Method      
*      
* @param numero      
* Description of Parameter      
* @param escala      
*Description of Parameter      
* @return Description of the Returned Value      */  
   
private String numToString(int numero, int escala) {     
    int unidade = (numero % 10);       
  int dezena = (numero % 100); // * nao pode dividir por 10 pois       
  // verifica de 0..19       
  int centena = (numero / 100);       
  StringBuffer buf = new StringBuffer();          
if (numero != 0) {          
   if (centena != 0) {                 
if (dezena == 0 && centena == 1) {             
        buf.append(Numeros[2][0]);    
             } else {                  
   buf.append(Numeros[2][centena]);                 }            
 }              if ((buf.length() > 0) && (dezena != 0)) {  
               buf.append(" e ");             }      
       if (dezena > 19) {               
  dezena /= 10;                 
buf.append(Numeros[1][dezena - 2]);                 
if (unidade != 0) {                     
buf.append(" e ");                     
buf.append(Numeros[0][unidade]);                 
}             
} else if (centena == 0 || dezena != 0) {                
 buf.append(Numeros[0][dezena]);             
}              
buf.append(" ");             
if (numero == 1) {                
 buf.append(Qualificadores[escala][0]);             
} else {                 
buf.append(Qualificadores[escala][1]);             
}         
}          
return buf.toString();     
} }  


Main.java  
package umcastec;  
import java.math.BigDecimal;    
public class Main {      
public static void main(String[] args) {             

    String extenso;

     Double totProd = 1000.0;     

JExtenso je = new JExtenso(new BigDecimal(totProd));     
extenso = je.toString().toUpperCase();     

 System.out.println(extenso + " - "+ je);       

//sída console   

//UM MIL REAIS   -  um mil reais  

//     

     }      }
 
Código enviado por Ciro S. Santos  

Criando uma ArrayList do tipo Inteiro

ArrayList suporta arrays dinâmicos, que pode crescer conforme necessário.

Em Java, arrays são padrão de um comprimento fixo. Depois de arrays são criados,

eles não podem crescer ou encolher, o que significa que você deve saber antecipadamente

quantos elementos uma matriz irá realizar. Mas, às vezes, você não pode saber com

precisão o tempo de execução até o tamanho de uma matriz que você precisa. Para lidar com esta situação, a estrutura das coleções define ArrayList.

package umcastec;

import java.util.ArrayList;

public class Principal {

public static void main(String[] args) {

// TODO code application logic here

ArrayList array_list_int = new ArrayList();

//adiciona itens na lista manualmente

array_list_int.add(0);

array_list_int.add(1);

array_list_int.add(2);

array_list_int.add(3);

//imprime de acordo com a posição informada manualmente no array list

System.out.println("Posição 0 :"+array_list_int.get(0));

System.out.println("Posição 1 :"+array_list_int.get(1));

//----------

saída no console

//Posição 0 :0

//Posição 1 :1

//----------

//exibe todos valores da lista

for(int i = 0; i "<" array_list_int.size(); i++){

//dessa for irá imprimir todos os registros do array list

System.out.println(array_list_int.get(i));

//----------saída no console

// 0

// 1

// 2

// 3

//----------

}

}

}

Obs: no for() o sinal "<" esta entre aspas!

Porque o sistema do Blogger interpreta como tag de HTML

Operador ternário

Operador ternário ou operador condicional tem objetivo de atribuir um valor a uma variável

de acordo com o resultado de um teste lógico.

Sintaxe:

Teste lógico (?) valor se for verdadeiro (:) valor se for falso

Teste lógico -> é qualquer expresão que pode ser avaliado como verdadeiro ou falso

Exemplo:

package umcastec;

public class Oper_Tern {

public static void main(String args[]) {

/*

* Operador ternário

*/

int x = 2;

int y = 4;

String verdade = "sim";

String falso = "não";

System.out.println(x ">" y ? verdade : falso);

// saída console não

System.out.println(x "<" y ? verdade : falso);

// saída console sim

System.out.println(x == y ? verdade : falso);

// saída console não

System.out.println(x != y ? verdade : falso);

// saída console sim

}

}

Obs: nos dois primeiros System.out... o sinal "<" e ">" então entre aspas!

Porque o sistema do Blogger interpreta como tag de HTML

Mês atual em Java

Um exemplo simples de saber em que mês estamos usando switch() case():

package umcastec;

import java.text.SimpleDateFormat;

import java.util.Date;

public class Ex_mes_atual_case {

@SuppressWarnings("deprecation")

public static void main(String args[]){

Date data = new Date();

SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy");

String dataatual = sdf.format(data);

int h = data.getMonth();

switch(h){

case(0):

System.out.println("Janeiro - " + dataatual);

break;

case(1):

System.out.println("Fevereiro - " + dataatual);

break;

case(2):

System.out.println("Março - " + dataatual);

break;

case(3):

System.out.println("Abril - " + dataatual);

break;

case(4):

System.out.println("Maio - " + dataatual);

break;

case(5):

System.out.println("Junho - " + dataatual);

break;

case(6):

System.out.println("Julho - " + dataatual);

break;

case(7):

System.out.println("Agosto - " + dataatual);

break;

case(8):

System.out.println("Setembro - " + dataatual);

break;

case(9):

System.out.println("Outubro - " + dataatual);

break;

case(10):

System.out.println("Novembro - " + dataatual);

break;

case(11):

System.out.println("Dezembro - " + dataatual);

break;

}

}

}

Um outro exemplo simples de saber em que mês estamos com Array:

package umcastec;

import java.text.SimpleDateFormat;

import java.util.Date;

public class Ex_mes_atual_Array {

@SuppressWarnings("deprecation")

public static void main(String args[]){

Date data = new Date();

SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy");

String dataatual = sdf.format(data);

int h = data.getMonth();

String[] mesatual = {

"Janeiro",

"Fevereiro",

"Março",

"Abril",

"Maio",

"Junho",

"Julho",

"Agosto",

"Setembro",

"Outubro",

"Novembro",

"Dezembro",

};

System.out.println(mesatual[h] + " - " + dataatual);

}

}

O Next, é um framework para desenvolvimento de aplicações JEE. Baseado em Spring e Hibernate, tem como foco facilitar o trabalho do programador e dar produtividade ao desenvolvimento de aplicações web. Conta com diversos recursos que irão turbinar o desenvolvimento de suas aplicações.

mais sobre o Next

Download do Next

Criador do Framework: Rógel Garcia

Contar total de letras, vogais e consoantes de uma String

public class contarString {

public static void main(String args[]){

String palavra = "umcastec";

int qnt_vogais = 0;

//Obs: no sinal de "menor que " eu tive que colocar entre aspas "<" por causa do

//Blogger que indentifica como tag HTML

for(int i = 0; i "<" palavra.length(); i++){

if(

palavra.charAt(i) == 'a'

|| palavra.charAt(i) == 'e'

|| palavra.charAt(i) == 'i'

|| palavra.charAt(i) == 'o'

|| palavra.charAt(i) == 'u'

|| palavra.charAt(i) == 'A'

|| palavra.charAt(i) == 'E'

|| palavra.charAt(i) == 'I'

|| palavra.charAt(i) == 'O'

|| palavra.charAt(i) == 'U'

){

qnt_vogais += 1;

}

}

int qnt_palavra = palavra.length();

int qnt_consoante = qnt_palavra - qnt_vogais;

System.out.println("Essa palavra tem: "+ qnt_palavra + " caracteres sendo " + qnt_vogais + " vogais e "+ qnt_consoante +" consoantes");

}

}

/*Saída no console

Essa palavra tem: 8 caracteres sendo 3 vogais e 5 consoantes

*/

Obs: no sinal de "menor que " no FOR eu tive que colocar entre aspas "<" por causa do

Blogger que indentifica como tag HTML