Chicken Game Java Swing 2D

Jogo em Java 2D desenvolvido por Sarwan Karim bem simples, mas bem legal.

Você tem que obter 12 ovos em 2 minutos. Clique no frango (galinha) para botar um ovo!

Site do projeto original: https://www.geeksacademy.com.pk/chicken-game-java-swing/

Link download: Chicken Game Java.jar (31 KB)

Aqui a classe Java para analise e estudo tanto da linguagem em si como da lógica do jogo. Modifiquei pouca coisa, mas precisava devido a codificação ser bem antiga.

/**
* Last modified by J. Marcos B.
* Date: 2020/25/08
* Site: https://www.geeksacademy.com.pk/chicken-game-java-swing/
* Author: Sarwan Karim
* E-mail: sarwankarim25@gmail.com
*/

import java.applet.Applet;
import java.applet.AudioClip;
import java.awt.Color;
import java.awt.Frame;
import java.awt.Label;
import java.awt.LayoutManager;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
//import java.io.File;
import java.net.URL;
import java.util.Timer;
import java.util.TimerTask;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JOptionPane;

public class HenGame_ImIc_Sound implements MouseListener {

// private static final int RequiredScore = 12;
private static int score = 0;
private static int time = 120;
Frame f = new Frame("Chicken Game Java by Sarwan Karim");
JLabel hen = new JLabel("H");
JLabel egg = new JLabel("E");
static Label timeLabel = new Label("Time: " + time);
static Label scoreLabel = new Label("Score: " + score);
ImageIcon henI = new ImageIcon(HenGame_ImIc_Sound.class.getResource("Hen.gif"));
ImageIcon eggI = new ImageIcon(HenGame_ImIc_Sound.class.getResource("Egg.gif"));
static Timer timer = null;

public void run() {
int i = 0;
HenGame_ImIc_Sound.timeLabel.setText("Time: " + i--);
System.out.println(i);
if (i <= 0) {

// Timer timer = null;
timer.cancel();
JOptionPane.showMessageDialog(null, "You Lose! :(");
System.exit(0);
}
if (i == 12) {
JOptionPane.showMessageDialog(null, "Congratulations!\n You Win! :(");
System.exit(0);
}
}

HenGame_ImIc_Sound() {
f.setLayout((LayoutManager) null);
f.setBounds(0, 0, 1024, 700);
f.setBackground(Color.black);
hen.setBounds(50, 50, 140, 132);
timeLabel.setBounds(920, 40, 70, 30);
timeLabel.setBackground(Color.gray);
scoreLabel.setBounds(920, 70, 70, 30);
scoreLabel.setBackground(Color.gray);
hen.setIcon(henI);
egg.setIcon(eggI);
f.add(hen);
f.add(egg);
f.add(timeLabel);
f.add(scoreLabel);
hen.addMouseListener(this);
egg.setVisible(false);
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent param1WindowEvent) {
System.exit(0);
}
});
// The method show() from the type Window is deprecated
// f.show();
f.setVisible(true);
}

public void mouseEntered(MouseEvent paramMouseEvent) {
double d1 = Math.random() * 900.0D;
int i = (int) d1;
double d2 = Math.random() * 590.0D;
int j = (int) d2;
hen.setBounds(i, j, 140, 132);
if (hen == paramMouseEvent.getSource()) {
int k = i + 30;
int m = j + 93;
egg = new JLabel("E");
ImageIcon imageIcon = new ImageIcon(
HenGame_ImIc_Sound.class.getResource("Egg.gif"));
egg.setIcon(imageIcon);
f.add(egg);
egg.setBounds(k, m, 20, 22);
egg.setVisible(false);
}
}

public void mouseReleased(MouseEvent paramMouseEvent) {
try {
// File file = new File("chicken.wav");
// The method toURL() from the type File is deprecated
// URL uRL = file.toURL();
URL uRL = this.getClass().getClassLoader().getResource("chicken.wav");
AudioClip audioClip = Applet.newAudioClip(uRL);
audioClip.play();
} catch (Exception exception) {
exception.printStackTrace();
}
score++;
scoreLabel.setText("Score: " + score);
if (hen == paramMouseEvent.getSource()) {
double d1 = Math.random() * 720.0D;
int i = (int) d1;
double d2 = Math.random() * 340.0D;
int j = (int) d2;
hen.setBounds(i, j, 140, 132);
}
}

public void mousePressed(MouseEvent paramMouseEvent) {
egg.setVisible(true);
}

public void mouseClicked(MouseEvent paramMouseEvent) {
}

public void mouseExited(MouseEvent paramMouseEvent) {
}

public static void main(String[] paramArrayOfString) {
JOptionPane.showMessageDialog(null, "You have to get 12 eggs in 2 minutes.\n Note: Click Chicken to Lay an egg.");
new HenGame_ImIc_Sound();
final Timer timer = new Timer();
// long i = 0;
timer.scheduleAtFixedRate(new TimerTask() {
int i = HenGame_ImIc_Sound.time;

public void run() {
HenGame_ImIc_Sound.timeLabel.setText("Time: " + i--);
System.out.println(i);
if (i <= 0) {
timer.cancel();
JOptionPane.showMessageDialog(null, "You Lose! :(");
System.exit(0);
}
if (HenGame_ImIc_Sound.score == 12) {
JOptionPane.showMessageDialog(null,
"Congratulations!\n You Win! :(");
System.exit(0);
}
}
}, 0L, 1000L);
}
}

chicken.wav

Microsoft Translator Java API

Microsoft Translator Java APITradutor de textos para 41 línguas usando a API Java da Microsoft (Bing). Infelizmente a API limita a quantidade de letras no texto para traduzir, cerca de 10,000 caracteres apenas por vez.

API usada: microsoft-translator-java-api-0.6.2-jar-with-dependencies

/*
* Copyright 2011-2015 Jonathan Griggs.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* @author Jonathan Griggs <jonathan.griggs at gmail.com>
*/

import java.awt.Cursor;
import java.awt.EventQueue;
import java.awt.Rectangle;
import java.awt.Toolkit;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.DefaultStyledDocument;
import javax.swing.text.DocumentFilter;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.ScrollPaneConstants;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import javax.swing.JLabel;
import javax.swing.SwingConstants;
import java.awt.Font;

import com.memetix.mst.language.Language;
import com.memetix.mst.translate.Translate;

public class MicrosoftTranslatorGUI extends JFrame {

private static final long serialVersionUID = 1L;
private JPanel contentPane;
private JLabel lblCharactersLimit;
private JScrollPane jScrollPane = null;
private JTextArea textArea;
private JComboBox<Object> comboBox;
private DefaultStyledDocument doc;

// 41 Languages
String[] languages = { "ARABIC", "BULGARIAN", "CATALAN",
"CHINESE_SIMPLIFIED", "CHINESE_TRADITIONAL", "CZECH", "DANISH",
"DUTCH", "ENGLISH", "ESTONIAN", "FINNISH", "FRENCH", "GERMAN",
"GREEK", "HAITIAN_CREOLE", "HEBREW", "HINDI", "HMONG_DAW",
"HUNGARIAN", "INDONESIAN", "ITALIAN", "JAPANESE", "KOREAN",
"LATVIAN", "LITHUANIAN", "MALAY", "NORWEGIAN", "PERSIAN", "POLISH",
"PORTUGUESE", "ROMANIAN", "RUSSIAN", "SLOVAK", "SLOVENIAN",
"SPANISH", "SWEDISH", "THAI", "TURKISH", "UKRAINIAN", "URDU",
"VIETNAMESE", };

public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
MicrosoftTranslatorGUI frame = new MicrosoftTranslatorGUI();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

private JScrollPane getJScrollPane() {
if (jScrollPane == null) {
// jTextArea dentro do JScrollPane
jScrollPane = new JScrollPane(getjtextArea());
// tamanho do jScrollPane
jScrollPane.setBounds(new Rectangle(10, 104, 764, 411));
// só mostra a barra vertical se necessário
jScrollPane
.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
// só mostra a barra de rolagem horizontal se necessaria
jScrollPane
.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
// textArea.getText();
// textArea.setLineWrap(true);
}
// retorna o jScrollPane
return jScrollPane;
}

private JTextArea getjtextArea() {
if (textArea == null) {
textArea = new JTextArea();
// textArea.setBounds(new Rectangle(10, 104, 764, 411));
// textArea.addMouseListener(this);
// textArea.setCaretPosition(jTextAreaParaTraduzir.getDocument().getLength());
// Não corta a palavra ao quebra a linha
textArea.setWrapStyleWord(true);
// Quebra de linha automatica
// textArea.setLineWrap(true);
// Cor de fundo azul claro do TextArea
// jTextAreaParaTraduzir.setBackground(new Color(217,232,238));

}
return textArea;
}

private void Translate() {

// Set the Microsoft Translator API Key - Get yours at
// http://www.bing.com/developers/createapp.aspx
Translate.setKey("Authentication key here...");

String translatedText = null;
try {
translatedText = Translate.execute(textArea.getText(),
Language.AUTO_DETECT,
Language.valueOf(comboBox.getSelectedItem().toString()));
} catch (Exception e) {
e.printStackTrace();
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"Error In Language Translation...", "Error",
JOptionPane.ERROR_MESSAGE);
}
System.out.println(translatedText);
textArea.setText(translatedText);

}

// 10,000 characters limit
public MicrosoftTranslatorGUI() {
setTitle("Bing Translate API Service");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 800, 600);
// Tamanho fixo do programa, sem alteção
this.setResizable(false);
// Deixa o programa no meio da tela, centralizado
this.setLocationRelativeTo(null);

contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
contentPane.setLayout(null);

lblCharactersLimit = new JLabel("Characters Limit: 10000");
lblCharactersLimit.setBounds(10, 81, 337, 14);
contentPane.add(lblCharactersLimit);

// textArea = new JTextArea();
// textArea.setBounds(10, 104, 764, 411);
// contentPane.add(textArea);
// Declarando o JScroolPane
contentPane.add(getJScrollPane(), null);

//************************************************
doc = new DefaultStyledDocument();

//aqui é atribuido um filtro ao DefaultStyledDocument, é esta classe que vai
//limitar o número máximo de caracteres, basta alterar o 10000
//para o valor maximo desejado
doc.setDocumentFilter(new DocumentSizeFilter(10000));
//neste trecho, foi sobrescrito um DocumentListener,
//que monitora alterações dentro do campo de texto
//sempre que uma alteração for realizada, será invocado
//o método updateCount(), que vai atualizar o numero
//de caracteres restantes
doc.addDocumentListener(new DocumentListener() {

public void changedUpdate(DocumentEvent e) {
updateCount();
}

public void insertUpdate(DocumentEvent e) {
updateCount();
}

public void removeUpdate(DocumentEvent e) {
updateCount();
}
});
//finalmente o DefaultStyledDocument foi
//atribuido ao seu campo de texto
textArea.setDocument(doc);
//insere o valor inicial restante
updateCount();
//************************************************

JButton btnTranslate = new JButton("Translate");
btnTranslate.setCursor(new Cursor(Cursor.HAND_CURSOR));
btnTranslate.setToolTipText("Translate");
btnTranslate.setBounds(345, 527, 89, 23);
btnTranslate.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {

//Chamada do método
Translate();
}
});

contentPane.add(btnTranslate);

comboBox = new JComboBox<Object>(languages);
comboBox.setToolTipText("Languages");
comboBox.setCursor(new Cursor(Cursor.HAND_CURSOR));
comboBox.setBounds(646, 68, 128, 20);
// comboBox.setText("--Select--");
contentPane.add(comboBox);

JLabel lblNewLabel = new JLabel("Microsoft Translator Java API");
lblNewLabel.setFont(new Font("Tahoma", Font.BOLD, 28));
lblNewLabel.setHorizontalAlignment(SwingConstants.CENTER);
lblNewLabel.setBounds(10, 11, 764, 34);
contentPane.add(lblNewLabel);


}

private void updateCount() {
lblCharactersLimit.setText("Characters Limit: " + (10000 - doc.getLength()));
//System.out.println("Characters limit: " + (10000 - doc.getLength()));
}

//esta classe que faz a limitação de caracteres
class DocumentSizeFilter extends DocumentFilter {

int maxCharacters;
boolean DEBUG = false;

public DocumentSizeFilter(int maxChars) {
maxCharacters = maxChars;
}

public void insertString(DocumentFilter.FilterBypass fb, int offs,
String str, AttributeSet a)
throws BadLocationException {
if (DEBUG) {
System.out.println("in DocumentSizeFilter's insertString method");
}

//Isto rejeita novas inserções de caracteres se
//a string for muito grande. Outra opção seria
//truncar a string inserida, de forma que seja
//adicionado somente o necessário para atingir
//o limite máximo permitido
if((fb.getDocument().getLength() + str.length()) <= maxCharacters) {
super.insertString(fb, offs, str, a);
} else {
Toolkit.getDefaultToolkit().beep();
}
}

public void replace(DocumentFilter.FilterBypass fb, int offs,
int length,
String str, AttributeSet a)
throws BadLocationException {
if (DEBUG) {
System.out.println("in DocumentSizeFilter's replace method");
}
//Isto rejeita novas inserções de caracteres se
//a string for muito grande. Outra opção seria
//truncar a string inserida, de forma que seja
//adicionado somente o necessário para atingir
//o limite máximo permitido
if((fb.getDocument().getLength() + str.length() - length) <= maxCharacters) {
super.replace(fb, offs, length, str, a);
} else {
Toolkit.getDefaultToolkit().beep();
}
}

}
}// fim da classe

Segue a aplicação com interface gráfica para uso.

Link download: Microsoft Translator Java 24-08-2020.jar (42,3 KB)

Participe, contribua, melhore, aprimore… Bom proveito.

Processamento De Texto: Com As APIs Java Coimbra pt-BR & Silabas pt-BR

Processamento De Texto Com As APIs Coimbra pt-BR & Silabas pt-BRProcessamento De Texto Com As APIs Coimbra pt-BR & Silabas pt-BR

Tanto a API Coimbra como a Silabas PT 1.0 estão descontinuadas (Deprecated API). Porém aqui eu abri o fonte e fiz algumas modificações. Acho que o projeto foi muito bom e que essas bibliotecas ainda possam serem úteis. Você pode melhorar, modificar para outras línguas como por exemplo o espanhol… Pode utilizar em trabalhos escolares, trabalhos de cursos, Monografias, TCC… Jogos, aplicativos e etc… a criatividade não tem limites e o código é aberto. Contribua e nos notifique.
Essas bibliotecas NÃO tem a função de correção ortográfica. Olha ai uma boa ideia para adicionar a elas…
As APIs fechadas (que estou deixando aqui também para download) tem alguns problemas.
Exemplo: Ao separar a sílaba de algumas palavras ela separa errada, mas são poucas as palavras em relação a quantidade de palavras da língua portuguesa.
A palavras (Poluição) é uma delas…
A Coimbra.jar ela está ignorando letras de palavras com acentos como: é, ã, õ, ô, ç, í, … Eu ao mexer no fonte conseguir resolver isso. Mas a fechada do projeto tem ainda tem esse erro.

Não é uma tarefa fácil realizar separação de sílabas, correção de palavras e etc… Todos nos que somo programadores de alguma linguagem sabe bem disso, então esse projeto ele deu inicio e deixa-lo cair no esquecimento e triste e tenho certeza que isso aqui ainda pode ajudar muitos que estão ingressando tanto em Java como em outras linguagens que já sabe e desenvolver não faz nenhuma diferença, mas quem esta começando e precisa de ajuda, precisa a desenvolver a lógica e entender a linguagem sim.

Bom, ou abrir o código fonte das bibliotecas citadas eu fiz uma interface  gráfica (GUI) para melhor uso dos usuários. E mexi no fonte de algumas classes.

A Classe gráfica:

</pre>
import java.awt.Color;
import java.awt.Cursor;
import java.awt.EventQueue;
import java.awt.Rectangle;
import java.awt.Toolkit;

import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.ScrollPaneConstants;
import javax.swing.border.EmptyBorder;
import javax.swing.JButton;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import javax.swing.JTextArea;

//import br.coppe.coimbra.processing.text.Str;
import javax.swing.JLabel;
import javax.swing.SwingConstants;
import java.awt.Font;
import java.util.Arrays;

//API: Coimbra.jar e silabasPT_1.0
public class CoimbraPTBRgui extends JFrame {

private static final long serialVersionUID = 1L;
private static final long[] s = null;
private JPanel contentPane;
private JScrollPane jscRead = null;
private JTextArea textArea;
private JLabel lblSentenceNumber;
private JLabel lblLettersnumber;
private JLabel lblWordsnumber;
private JLabel lblWordspersentence;
private JLabel lblSyllablesperword;
private JLabel lblWordsWith;
private JLabel lblPercentageWordsWith;

public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
CoimbraPTBRgui frame = new CoimbraPTBRgui();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

private void ProcessarTexto() {

String text = textArea.getText();

if (textArea.getText().equals("")) {
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null, "Campo vazio! ",
"Processamento De Texto", JOptionPane.ERROR_MESSAGE);
} else {
// LETTERSNUMBER
System.out.println("Quantidade de letras na palavra ou texto: ");
System.out.println("==========================================");
System.out.println(Str.lettersNumber(text) + " Letras.");
System.out.println("");
lblLettersnumber.setText(Str.lettersNumber(text) + " Letras.");

// CLEAN EXTRAS PACES
System.out.println("Texto sem Espaços Extra: ");
System.out.println("==========================================");
System.out.println("");
System.out.println(Str.cleanExtraSpaces(text + "\n"));
System.out.println("");

// CLEAN PUNCTUATION
System.out.println("Texto sem Espaços Extra e sem Pontuação: ");
System.out.println("==========================================");
System.out.println("");
System.out.println(Str.cleanPunctuation(text));
System.out.println("");

// WORDS NUMBER
System.out.println("Quantidade de palavras no texto: ");
System.out.println("==========================================");
System.out.println(Str.wordsNumber(text) + " palavras.");
System.out.println("");
lblWordsnumber.setText(Str.wordsNumber(text) + " palavras.");

// SENTENCES
System.out.println("Sentenças: ");
System.out.println("==========================================");
System.out.println("");
String[] sents = Str.sentences(text);
for (String s : sents)
System.out.println(s);
System.out.println("");
lblWordspersentence.setText(Arrays.toString(s));

// SENTENCES NUMBER
System.out.println(Str.sentencesNumber(text) + " sentenças.");
lblSentenceNumber
.setText(Str.sentencesNumber(text) + " sentenças.");

// AVERAGE WORDS PER SENTENCE
System.out.println(Str.averageWordsPerSentence(text)
+ " palavras por sentença.");
System.out.println("");
// mostra duas casas percentuais
lblWordspersentence.setText(Math.floor(Str
.averageWordsPerSentence(text) * 100) / 100 + " %");

// SYLLABLES NUMBER
System.out.println("EXEMPLO: " + Str.syllablesNumber("palavra"));
System.out.println("");
lblSyllablesperword.setText("EXEMPLO: "
+ Str.syllablesNumber("palavra"));

// AVERAGE SYLLABLES PER WORD
System.out.println(Str.averageSyllablesPerWord(text)
+ " sílabas por palavra.");
// mostra duas casas percentuais
lblSyllablesperword.setText(Math.floor(Str
.averageSyllablesPerWord(text) * 100) / 100 + " %");

// WORDS WITH 3 SYLLABLES
System.out.println(Str.wordsWith3Syllables(text)
+ " palavras com mais de 2 sílabas.");
lblWordsWith.setText(Str.wordsWith3Syllables(text)
+ " palavras com mais de 2 sílabas.");

// PERCENTAGE WORDS WITH 3 SYLLABES
System.out.println(Str.percentageWordsWith3Syllables(text)
+ " PONTOS PERCENTUAIS.");
// mostra duas casas percentuais
lblPercentageWordsWith.setText(Math.floor(Str
.percentageWordsWith3Syllables(text) * 100) / 100 + " % ");
}
}

private JScrollPane getjscRead() {
if (jscRead == null) {
jscRead = new JScrollPane(textArea);
jscRead.setBorder(null);
jscRead.setBounds(new Rectangle(10, 100, 764, 450));
// só mostra a barra vertical se necessário
jscRead.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
// só mostra a barra horizontal se necessário
jscRead.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
jscRead.setViewportView(gettextArea());
// Cor cinza da aplicação Java
// jscRead.setBackground(new Color(238, 238, 238));

}
return jscRead;
}

private JTextArea gettextArea() {
if (textArea == null) {
textArea = new JTextArea();
textArea.setEditable(true);
// quebra a linha ao chegar no limite
// da textarea
textArea.setLineWrap(true);
// define a quebra de linha sem quebrar
// a palavra no final da linha, caso
// nao caiba inteira
textArea.setWrapStyleWord(true);
// Cor de fundo azul claro
// textArea.setBackground(new Color(217, 232, 238));
// textArea.setBounds(new Rectangle(10, 100, 764, 450));
// textArea.setText("");
// Ponhe o cursor na primeira linha da TextArea
// textArea.setCaretPosition(1);
}
return textArea;
}

public CoimbraPTBRgui() {
setTitle("Processamento De Texto: API Java Coimbra pt-BR Por J. Marcos B.");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 1046, 600);
// Tamanho fixo do programa, sem alteção
this.setResizable(false);
//this.setResizable(true);
// Deixa o programa no meio da tela, centralizado
this.setLocationRelativeTo(null);

contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
contentPane.setLayout(null);

JButton btnCoimbraPTBR = new JButton("Processar Texto");
btnCoimbraPTBR.setToolTipText("Processar Texto");
btnCoimbraPTBR.setCursor(new Cursor(Cursor.HAND_CURSOR));
btnCoimbraPTBR.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {

ProcessarTexto();
}
});
btnCoimbraPTBR.setBounds(784, 527, 159, 23);
contentPane.add(btnCoimbraPTBR);

// textArea = new JTextArea();
// textArea.setBounds(10, 100, 764, 450);
// para quebra a linha
// textArea.setLineWrap(true);
// textArea.setWrapStyleWord(true);
// contentPane.add(textArea);
contentPane.add(getjscRead(), null);

JLabel lblTtulo = new JLabel("Processamento De Texto");
lblTtulo.setFont(new Font("Tahoma", Font.BOLD, 28));
lblTtulo.setHorizontalAlignment(SwingConstants.CENTER);
lblTtulo.setBounds(10, 11, 1009, 51);
contentPane.add(lblTtulo);

JLabel lblNumerodeletras = new JLabel(
"Quantidade de letras na palavra ou texto:");
lblNumerodeletras.setBounds(784, 100, 235, 14);
contentPane.add(lblNumerodeletras);

JLabel lblQuantidadedepalavras = new JLabel(
"Quantidade de palavras no texto:");
lblQuantidadedepalavras.setBounds(784, 150, 235, 14);
contentPane.add(lblQuantidadedepalavras);

JLabel lblSentencas = new JLabel("Senten\u00E7as:");
lblSentencas.setBounds(784, 196, 235, 14);
contentPane.add(lblSentencas);

// SENTENCES NUMBER
lblSentenceNumber = new JLabel("");
lblSentenceNumber.setBounds(784, 216, 235, 14);
lblSentenceNumber.setForeground(Color.RED);
contentPane.add(lblSentenceNumber);

JLabel lblPalavrasporsentencas = new JLabel(
"Palavras Por Senten\u00E7as:");
lblPalavrasporsentencas.setBounds(784, 242, 235, 14);
contentPane.add(lblPalavrasporsentencas);

JLabel lblSilabasporPalavras = new JLabel("Silabas Por Palavras:");
lblSilabasporPalavras.setBounds(784, 292, 235, 14);
contentPane.add(lblSilabasporPalavras);

// LETTERSNUMBER
lblLettersnumber = new JLabel("");
lblLettersnumber.setBounds(784, 125, 235, 14);
lblLettersnumber.setForeground(Color.RED);
contentPane.add(lblLettersnumber);

// WORDSNUMBER
lblWordsnumber = new JLabel("");
lblWordsnumber.setBounds(784, 171, 235, 14);
lblWordsnumber.setForeground(Color.RED);
contentPane.add(lblWordsnumber);

// WORDSPERSENTENCE
lblWordspersentence = new JLabel("");
lblWordspersentence.setBounds(784, 267, 235, 14);
lblWordspersentence.setForeground(Color.RED);
contentPane.add(lblWordspersentence);

// SYLLABLESPERWORD
lblSyllablesperword = new JLabel("");
lblSyllablesperword.setBounds(784, 313, 235, 14);
lblSyllablesperword.setForeground(Color.RED);
contentPane.add(lblSyllablesperword);

JLabel lblPalavrasComMais = new JLabel(
"Palavras com mais de 2 s\u00EDlabas:");
lblPalavrasComMais.setBounds(784, 338, 235, 14);
contentPane.add(lblPalavrasComMais);

// WORDS WITH 3 SYLLABLES
lblWordsWith = new JLabel("");
lblWordsWith.setBounds(784, 363, 235, 14);
lblWordsWith.setForeground(Color.RED);
contentPane.add(lblWordsWith);

JLabel lblPontospercentuais = new JLabel(
"% De Palavras Com Mais De 3 Sílabas:");
lblPontospercentuais.setBounds(784, 388, 235, 14);
contentPane.add(lblPontospercentuais);

// PERCENTAGE WORDS WITH 3 SYLLABES
lblPercentageWordsWith = new JLabel("");
lblPercentageWordsWith.setBounds(784, 409, 235, 14);
lblPercentageWordsWith.setForeground(Color.RED);
contentPane.add(lblPercentageWordsWith);
}
}

Uma classe que alterei foi a Str.

</pre>
//package br.coppe.coimbra.processing.text;

import silabas.SilabasPT;

/**
* Str é uma classe auxiliar para o processamento de Strings.
*
* Para ver o processo de separação das sílabas, veja:
* {@link <a href="http://linguateca.dei.uc.pt/index.php?sep=recursos">liguateca</a>}
*
*
* @author phillipe
*
*/

public abstract class Str {

// text uma string de palavra ou texto.
// a quantidade de letras de uma palavra ou texto.
public static int lettersNumber(String text) {
// return text.replaceAll("\\W|\\d|\\s|\\p{InGreek}", "").length();
return text.replaceAll("\\d|\\s|\\p{InGreek}", "").length();
}

// text uma string de palavra ou texto.
// a string sem espaços extras.
public static String cleanExtraSpaces(String text) {
return text.replaceAll("\\s{2,}", " ").trim();
}

// text uma string de palavra ou texto.
// a string sem espaços extras e sem pontuação.
public static String cleanPunctuation(String text) {
text = cleanExtraSpaces(text);
return text.replaceAll("\\p{Punct}", "");
}

// text uma string.
// a quantidade de palavras do texto.
public static int wordsNumber(String text) {
return words(text).length;
}

// text uma string de texto.
// as palavras do texto
public static String[] words(String text) {
text = cleanPunctuation(text);
return text.split(" ");
}

// text uma string de texto.
// um conjunto de sentenças do texto.
public static String[] sentences(String text) {
text = cleanExtraSpaces(text);
text = text.replaceAll("[\\p{Punct}&&[^!?.]]", "");
String[] sentence = text.split("[!?.,]");
int sentencesLen = sentence.length;
for (int i = 0; i < sentencesLen; i++)
sentence[i] = cleanPunctuation(sentence[i]);
return sentence;
}

// text uma string.
// a quantidade de sentenças do texto.
public static int sentencesNumber(String text) {
return sentences(text).length;
}

// text uma string.
// a média de palavras por sentença do texto.
public static float averageWordsPerSentence(String text) {
float average = wordsNumber(text) / (float) sentencesNumber(text);
return average;
}

// word uma string palavra
// a quantidade de sílabas desta palavra
public static int syllablesNumber(String word) {
return SilabasPT.separa(word).size();
}

// text uma string texto.
// a média de sílabas por palavra
public static float averageSyllablesPerWord(String text) {
long syllablesTotal = 0;
String[] words = words(text);
for (String w : words)
syllablesTotal += syllablesNumber(w);

return syllablesTotal / (float) wordsNumber(text);
}

// text uma string texto
// palavras com 3 ou mais sílabas
public static int wordsWith3Syllables(String text) {
int words3 = 0;
String[] words = words(text);

for (String w : words)
if (syllablesNumber(w) > 2)
words3++;
return words3;
}

// text uma string texto.
// porcentagem de palavras com 3 ou mais sílabas
public static float percentageWordsWith3Syllables(String text) {
return wordsWith3Syllables(text) / (float) wordsNumber(text);
}
}
<pre>

Outra classe do projeto a classe Constantes.

</pre>
package comuns;

public interface Constantes {
public static final char[] CONSOANTES = new char[] { 'b', 'c', 'd', 'f',
'g', 'h', 'j', 'k', 'l', 'm', 'n', 'p', 'q', 'r', 's', 't', 'v',
'x', 'y', 'z', 'ç' };

public static final char[] VOGAIS = new char[] { 'a', 'e', 'i', 'o', 'u' };

public static final char[] CONJ_1 = new char[] { 'b', 'c', 'd', 'f', 'g',
'p', 't', 'v' };

public static final char[] CONJ_2 = new char[] { 'c', 'l', 'n' };

public static final char[] LATERAIS = new char[] { 'l', 'r', 'z' };

public static final char[] H = new char[] { 'h' };

public static final char[] CONJ_5 = new char[] { 'c', 'g', 'm', 'p' };

public static final char[] CONJ_6 = new char[] { 'n' };

public static final char[] ACENTOS_GA = new char[] { 'à', 'á', 'é', 'í',
'ó', 'ú' };

public static final char[] CIRCUNFLEXO = new char[] { 'â', 'ê', 'î', 'ô' };

public static final char[] SEMI_VOGAIS = new char[] { 'i', 'u' };

public static final char[] TIL = new char[] { 'ã', 'õ' };

public static final char[] NASAIS = new char[] { 'm', 'n' };

public static final char[] CONJ_8 = new char[] { 'q', 'g' };

public static final char[] HIFEN = new char[] { '-' };

public static final String[] MONOSSILABOS_ATONOS = new String[] { "o", "a",
"os", "as", "um", "uns", "me", "te", "se", "lhe", "nos", "lhes",
"que", "com", "de", "por", "sem", "sob", "e", "mas", "nem", "ou" };

public static final String PROLONGAMENTO = "~";

public static final int G_SEMINIMA = 1;

public static final int G_COLCHEIA = 2;

public static final int G_SEMICOLCHEIA = 4;

public static final int N0 = 0;

public static final int N1 = 1;

public static final int N2 = 2;

public static final int N3 = 3;

public static final int N4 = 4;

public static final int N5 = 5;

public static final int NIVEL_FRACO = 6;

public static final int[] DOIS_DOIS = new int[] { 0, 4, 3, 4, 2, 4, 3, 4,
1, 4, 3, 4, 2, 4, 3, 4 };

public static final int[] QUATRO_QUATRO = new int[] { 0, 4, 3, 4, 2, 4, 3,
4, 1, 4, 3, 4, 2, 4, 3, 4 };

public static final int[] TRES_QUATRO = new int[] { 0, 3, 2, 3, 1, 3, 2, 3,
1, 3, 2, 3 };

public static final int[] DOIS_QUATRO = new int[] { 0, 3, 2, 3, 1, 3, 2, 3 };

public static final int[] TRES_OITO = new int[] { 0, 2, 1, 2, 1, 2 };

public static final int[] SEIS_OITO = new int[] { 0, 3, 2, 3, 2, 3, 1, 3,
2, 3, 2, 3 };

public static final int NENHUM = -1;

public static final int AMBOS = 0;

public static final int TEMPO = 1;

public static final int NIVEIS = 2;

public static final String FICHEIROS_DIR = "ficheiros/";

public static final int TEMPO_FORTE = 0;

public static final int PAUSA = 1;

public static final int TEMPO_FORTE_PAUSA = 2;

public static final int FIM = 3;

public static final int TEMPO_FORTE_FIM = 4;

public static final int TEMPO_FORTE_OUTRO_PAUSA = 5;

public static final int ULTIMO_FORTE_PARTE = 6;

public static final int NOTA_CURTA = 8;
}
<pre> 

Mais uma classe a ReadDoubleFrame.

</pre>
package comuns;

import java.awt.Button;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

class ReadDoubleFrame implements ActionListener {

private boolean valid;
private double value;
private String msg;
private Frame window;
private TextField valueArea;

public ReadDoubleFrame(String msg) {
msg = new String(msg);
valid = false;
window = new Frame();
window.setTitle(msg);
window.setLayout(new FlowLayout());
valueArea = new TextField("", 15);
Button done = new Button("Ok");
done.addActionListener(this);
window.add(valueArea);
window.add(done);
window.setSize(320, 100);
window.setBackground(Color.gray);
window.setLocation(100, 100);
window.setResizable(false);
window.setVisible(true);
}

public synchronized void actionPerformed(ActionEvent e) {
try {
value = Double.valueOf(valueArea.getText().trim()).doubleValue();
valid = true;
window.dispose();
notify();
} catch (Exception exc) {
window.setTitle("!!! Not a double !!! --- " + msg);
}
}

public synchronized double getValue() {
try {
if (!valid)
wait();
} catch (Exception exception) {
}
return value;
}
}
<pre> 

Outra do mesmo pacote ReadIntFrame.

</pre>
package comuns;

import java.awt.Button;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

class ReadIntFrame implements ActionListener {
private boolean valid;

private int value;

private String msg;

private Frame window;

private TextField valueArea;

public ReadIntFrame(String msg) {
msg = new String(msg);
valid = false;
window = new Frame();
window.setTitle(msg);
window.setLayout(new FlowLayout());
valueArea = new TextField("", 15);
Button done = new Button(" Ok ");
done.addActionListener(this);
window.add(valueArea);
window.add(done);
window.setSize(320, 100);
window.setBackground(Color.gray);
window.setLocation(100, 100);
window.setResizable(false);
window.setVisible(true);
}

public synchronized void actionPerformed(ActionEvent e) {
try {
value = Integer.valueOf(valueArea.getText().trim()).intValue();
valid = true;
window.dispose();
notify();
} catch (Exception exc) {
window.setTitle("!!! Not an integer !!! --- " + msg);
}
}

public synchronized int getValue() {
try {
if (!valid)
wait();
} catch (Exception exception) {
}
return value;
}
}
<pre> 

Mais uma classe agora a User.

</pre>
package comuns;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class User {
private static final int BUF_SIZE = 1024;

public static int readInt() {
while (true) {
try {
return Integer.valueOf(readString().trim()).intValue();
} catch (Exception e) {
System.out.println("!!! Not an integer !!!");
}
}
}

public static double readDouble() {
while (true) {
try {
return Double.valueOf(readString().trim()).doubleValue();
} catch (Exception e) {
System.out.println("!!! Not a double !!!");
}
}
}

public static long readLong() {
while (true) {
try {
return Long.valueOf(readString().trim()).longValue();
} catch (Exception e) {
System.out.println("!!! Not a long !!!");
}
}
}

public static float readFloat() {
while (true) {
try {
return Float.valueOf(readString().trim()).floatValue();
} catch (Exception e) {
System.out.println("!!! Not a float !!!");
}
}
}

public static String readString() {
String s = "";
try {
BufferedReader in = new BufferedReader(new InputStreamReader(
System.in), 1);
s = in.readLine();
} catch (IOException e) {
System.out.println("Error reading from the input stream.");
}
return s;
}

public static int graphicsReadInt(String msg) {
ReadIntFrame intFrame = new ReadIntFrame(msg);
return intFrame.getValue();
}

public static double graphicsReadDouble(String msg) {
ReadDoubleFrame doubleFrame = new ReadDoubleFrame(msg);
return doubleFrame.getValue();
}

public static int getBufSize() {
return BUF_SIZE;
}
}
<pre> 

E outra da API silabas PT do pacote silabas.

</pre>
package silabas;

import comuns.Constantes;
import comuns.User;
import java.util.ArrayList;

public class SilabasPT implements Constantes {
public static final char[] ACENTOS = new char[ACENTOS_GA.length + CIRCUNFLEXO.length + TIL.length];

public static final char[] VOGAIS_ACENTOS = new char[VOGAIS.length + ACENTOS.length];

public static final char[] SEMI_VOGAIS_ACENTOS = new char[SEMI_VOGAIS.length + ACENTOS.length];

static {
iniciaArraysCompostos();
}

public static ArrayList<String> separa(String palavra) {
palavra = palavra.toLowerCase();
if (palavra.equals("ao") || palavra.equals("aos")) {
ArrayList<String> separada = new ArrayList<String>();
separada.add(palavra);
return separada;
}
ArrayList<Integer> posicoes = constroiPosicoes1(palavra);
posicoes = constroiPosicoes2(palavra, posicoes);
return preencheSilabas(posicoes, palavra);
}

public static String getSilabasString(String palavra) {
return getSilabasString(separa(palavra));
}

public static String getSilabasString(ArrayList<String> silabas) {
String ret = "";
for (int i = 0; i < silabas.size(); i++) {
ret = String.valueOf(ret) + (String)silabas.get(i);
if (i < silabas.size() - 1)
ret = String.valueOf(ret) + "-";
}
return ret;
}

private static void iniciaArraysCompostos() {
System.arraycopy(ACENTOS_GA, 0, ACENTOS, 0, ACENTOS_GA.length);
System.arraycopy(CIRCUNFLEXO, 0, ACENTOS, ACENTOS_GA.length, CIRCUNFLEXO.length);
System.arraycopy(TIL, 0, ACENTOS, ACENTOS_GA.length + CIRCUNFLEXO.length, TIL.length);
System.arraycopy(VOGAIS, 0, VOGAIS_ACENTOS, 0, VOGAIS.length);
System.arraycopy(ACENTOS, 0, VOGAIS_ACENTOS, VOGAIS.length, ACENTOS.length);
System.arraycopy(SEMI_VOGAIS, 0, SEMI_VOGAIS_ACENTOS, 0, SEMI_VOGAIS.length);
System.arraycopy(ACENTOS, 0, SEMI_VOGAIS_ACENTOS, SEMI_VOGAIS.length, ACENTOS.length);
}

private static ArrayList<Integer> constroiPosicoes1(String palavra) {
ArrayList<Integer> posicoes = new ArrayList<Integer>();
for (int i = 1; i < palavra.length(); i++) {
if (pertence(palavra.charAt(i), VOGAIS_ACENTOS) && !pertence(palavra.charAt(i - 1), VOGAIS_ACENTOS) && i > 1)
if ((pertence(palavra.charAt(i - 1), H) && pertence(palavra.charAt(i - 2), CONJ_2)) || (
pertence(palavra.charAt(i - 1), LATERAIS) && pertence(palavra.charAt(i - 2), CONJ_1))) {
posicoes.add(Integer.valueOf(i - 2));
} else {
posicoes.add(Integer.valueOf(i - 1));
}
}
if (posicoes.size() > 0 && ((Integer)posicoes.get(0)).intValue() == 1 && !pertence(palavra.charAt(0), VOGAIS_ACENTOS))
posicoes.set(0, Integer.valueOf(0));
if (posicoes.size() == 0 || ((Integer)posicoes.get(0)).intValue() != 0)
posicoes.add(0, Integer.valueOf(0));
return posicoes;
}

private static ArrayList<Integer> constroiPosicoes2(String palavra, ArrayList<Integer> posicoes) {
for (int i = 1; i < palavra.length(); i++) {
if (pertence(palavra.charAt(i), VOGAIS_ACENTOS) && pertence(palavra.charAt(i - 1), VOGAIS_ACENTOS)) {
if ((i > 1 && palavra.charAt(i - 1) == 'u' && pertence(palavra.charAt(i - 2), CONJ_8)) ||
pertence(palavra.charAt(i - 1), TIL))
continue;
if (pertence(palavra.charAt(i), SEMI_VOGAIS))
if (!ultimaSilaba(palavra, i, posicoes) || !pertence2(LATERAIS, palavra, i + 1))
if (!pertence2(NASAIS, palavra, i + 1) || pertence2(VOGAIS_ACENTOS, palavra, i + 2))
continue;
for (int j = 0; j < posicoes.size(); j++) {
if (((Integer)posicoes.get(j)).intValue() > i) {
posicoes.add(j, Integer.valueOf(i));
break;
}
if (j == posicoes.size() - 1) {
posicoes.add(Integer.valueOf(i));
break;
}
}
}
continue;
}
return posicoes;
}

public static boolean pertence(char l, char[] conjunto) {
for (int i = 0; i < conjunto.length; i++) {
if (l == conjunto[i])
return true;
}
return false;
}

private static boolean pertence2(char[] conjunto, String palavra, int index) {
if (index >= palavra.length() || index < 0)
return false;
return pertence(palavra.charAt(index), conjunto);
}

private static boolean ultimaSilaba(String palavra, int index, ArrayList<Integer> posicoes) {
return (index >= ((Integer)posicoes.get(posicoes.size() - 1)).intValue());
}

private static ArrayList<String> preencheSilabas(ArrayList<Integer> posicoes, String palavra) {
ArrayList<String> ret = new ArrayList<String>();
if (posicoes.size() > 0) {
int i = 0;
while (i < posicoes.size() - 1) {
ret.add(palavra.substring(((Integer)posicoes.get(i)).intValue(), ((Integer)posicoes.get(i + 1)).intValue()));
i++;
}
ret.add(palavra.substring(((Integer)posicoes.get(i)).intValue(), palavra.length()));
}
return ret;
}

public static int getTonicaInt(String palavra) {
ArrayList<String> silabas = separa(palavra);
return getTonicaInt(palavra, silabas);
}

public static int getTonicaInt(String palavra, ArrayList<String> silabas) {
if (estaEm(MONOSSILABOS_ATONOS, palavra) || palavra.length() == 0)
return -1;
for (int i = silabas.size() - 1; i >= 0; i--) {
String silaba = silabas.get(i);
for (int k = 0; k < silaba.length(); k++) {
if ((pertence(silaba.charAt(k), ACENTOS_GA) || pertence(silaba.charAt(k), CIRCUNFLEXO)) &&
i > silabas.size() - 4)
return i;
if (pertence(silaba.charAt(k), TIL) &&
i > silabas.size() - 3)
return i;
}
}
char ultimo = palavra.charAt(palavra.length() - 1);
if (silabas.size() == 1 || pertence(ultimo, LATERAIS))
return silabas.size() - 1;
String ultima = silabas.get(silabas.size() - 1);
for (int j = 0; j < ultima.length(); j++) {
if (pertence(ultima.charAt(j), SEMI_VOGAIS) && (
ultima.charAt(j) != 'u' || !pertence2(CONJ_8, ultima, j - 1)))
return silabas.size() - 1;
}
return silabas.size() - 2;
}

public static String getTonicaString(String palavra) {
ArrayList<String> silabas = separa(palavra);
return getTonicaString(palavra, silabas);
}

public static String getTonicaString(String palavra, ArrayList<String> silabas) {
int i = getTonicaInt(palavra, silabas);
return (i >= 0) ? silabas.get(i) : "-";
}

public static boolean estaEm(String[] lista, String palavra) {
for (int i = 0; i < lista.length; i++) {
if (palavra.equals(lista[i]))
return true;
}
return false;
}

public static void main(String[] args) {
while (true) {
System.out.print("Palavra? ");
String txt = User.readString();
ArrayList<String> silabas = separa(txt);
System.out.println("Ei-la: " + silabas);
System.out.println("Tonica: " + getTonicaString(txt, silabas));
System.out.println("Ordem tonica: " + getTonicaInt(txt, silabas));
}
}
}
<pre> 

No total foram sete classe uma eu criei que foi a gráfica as outras foram do projeto.

package comuns: Constantes.java, ReadDoubleFrame.java, ReadIntFrame.java e User.java

package silabas: SilabasPT.java

Mas se você quiser você pode ignorar esses pacotes e deixar-las todas juntas em um pacote default como estão as CoimbraPTBRgui.java e Str.java.

Por essas pequenas mudanças e por por corregir alguns erros eu dei o título as bibliotecas de Coimbra pt-BR e Silabas pt-BR, pt sendo de portugês de Portugal e BR de português do Brasil.

Donload do APP: Processamento De Textos.jar (16 KB)

O Projeto Original

A Coimbra processa textos e palavras. Vejam aqui o seu funcionamento.

</pre>
//LETTERSNUMBER
System.out.println("Quantidade de letras na palavra ou texto");
System.out.println(Str.lettersNumber(text) + " existem 3 letras d a mais ");

//CLEAN EXTRAS PACES
System.out.println("Texto sem Extra Espaços");
System.out.println(Str.cleanExtraSpaces(text + "\n"));

//CLEAN PUNCTUATION
System.out.println("Texto sem Extra Espaços e sem Pontuação");
System.out.println(Str.cleanPunctuation(text));

//WORDS NUMBER
System.out.println("Quantidade de palavras no texto");
System.out.println(Str.wordsNumber(text) + " palavras");

//SENTENCES
System.out.println("Sentenças");
String[] sents = Str.sentences(text);
for (String s: sents)
System.out.println(s);

//SENTENCES NUMBER
System.out.println(Str.sentencesNumber(text) + " sentenças");

//AVERAGE WORDS PER SENTENCE
System.out.println(Str.averageWordsPerSentence(text) + " palavras/sentença");

//SYLLABLES NUMBER
System.out.println("EXEMPLO:"+ Str.syllablesNumber("palavra"));

//AVERAGE SYLLABLES PER WORD
System.out.println(Str.averageSyllablesPerWord(text) + " sílabas/palavra");

//WORDS WITH 3 SYLLABLES
System.out.println(Str.wordsWith3Syllables(text) + " palavras com mais de 2 sílabas");

//PERCENTAGE WORDS WITH 3 SYLLABES
System.out.println(Str.percentageWordsWith3Syllables(text) + " PONTOS PERCENTUAIS");
<pre>

SilabasPT é uma API Java que fornece métodos estáticos para realizar a divisão silábica e a identificação das sílabas tônicas de palavras escritas em português. É baseada em um conjunto de regras.
A SilabasPT foi desenvolvido para gerar texto (português) baseado em ritmo, no âmbito do mestrado. Tese de Geração de texto com base em ritmo pela o pessoal da Universidade de Coimbra em Portugal. Projeto esse criado em 26 de Outubro de 2011.

Como usar:

Separação silábica da palavra:


//get syllabic division
ArrayList<String> separada = SilabasPT.separa("palavra");

Sílaba tônica da palavra:

//get stress position
int pos = SilabasPT.getTonicaInt("palavra");
//or
int pos = SilabasPT.getTonicaInt("palavra", ArrayList<String> separada);

Posição da tônica da palavra:


//get stressed syllable
String stress = = SilabasPT.getTonicaString("palavra");
//or
String stress = = SilabasPT.getTonicaString("palavra", ArrayList<String> separada);

Ela ainda pode fornecer se uma palavra é Oxítona, Paroxítona ou Proparoxítona.

</pre>
if (SilabasPT.getTonicaInt(suaClasse.jtfPalavra.getText(), separada) == separada.size() - 1)
suaClasse.jlbProsodia.setText("A palavra é Oxítona.");

else if (SilabasPT.getTonicaInt(suaClasse.jtfPalavra.getText(), separada) == separada.size() - 2)
suaClasse.jlbProsodia.setText("A palavra é Paroxítona.");

else if (SilabasPT.getTonicaInt(suaClasse.jtfPalavra.getText(), separada) == separada.size() - 3) {
suaClasse.jlbProsodia.setText("A palavra é Proparoxítona.");
<pre>

Deprecated API

Link do projeto original: https://code.google.com/archive/p/coimbra/downloads

silabasPT_1.0.jar (39.65 KB)
Coimbra.jar (2.69MB)

Agradeço ao Hugo Gonçalo Oliveira um dos desenvolvedores do projeto pela atenção e por responder o meu email na época.

jHQ: Blade Runner – O Caçador De Androides 1982

jHQ: Blade Runner - O Caçador De Androides 1982Leitor virtual do quadrinho Blade Runner – O Caçador De Androides de 1982. Tem que ter Java instalado para poder rodar.

Em 1992 a Guerra Mundial Terminus devastou a Terra levando a extinção a grande maioria das espécies de animais e plantas do planeta gerando uma poeira radioativa tornando quase toda superfície estéril.
Aqueles com dinheiro e que ainda gozam de boa saúde se mudaram para colônias fora da Terra ficando aqui apenas quem não passa nos exames médicos (os chamados inaptos que são catalogados) e aqueles que não tem condições financeiras.
Várias corporações empresariais de tecnologia avançada começaram a desenvolver a linha de androides chamada Nexus para trabalhos escravos nessas colônias uma vez que esses humanoides são possuidores de força e resistência sobre humana.
Idênticos aos seres humanos esses seres artificiais concebidos com inteligência artificial logo começaram a desenvolver sentimentos como ódio, amor, raiva, medo… Os tornando assim ainda mais indistinguíveis do homem.
Prevendo futuros problemas os fabricantes instalaram uma chave biológica limitando o tempo de vida útil dos androides em apenas 4 anos. Após várias rebeliões e motins os Nexus foram proibidos de “viverem” na terra, mas um pequeno grupo residente de uma colônia de Marte podem abalar as estruturas do Universo.

Baixar (Download): jHQ – Blade Runner – O Caçador De Androides 1982.jar

Tamanho: 44.5 MB