Dependiendo de la actividad que tenga el server, tardará un poco. Supongo que en tu servidor al enviar sms lo haces desde un # propio, por ejemplo, todas esas API demoran un poco en llegarte el sms por que tienen que revisar el sms, etc. Lo que puedes hacer es hacer un webservice que reciban la petición e inmediatamente envíe el sms (para ésto tienes que usar una API igualmente, para poder asociar tu aplicación con el envío de sms). WebSockets no creo que te sirva mucho porque no habrá una comunicación constante (¿o si?).

Salu2.

Ya sé que estás desesperado pero eso no sirve como dato. ¿El servidor es potente? ¿Cada conexión se hace un un hilo independiente para garantizar que no haya cuello de botella? ¿Utilizas un pool de conexiones?

Salu2.

¿Tu aplicación es Multithreading? Si no es así, ésto puede ser la causa del problema. Si no usas Multithreading al cabo de una cantidad de conexiones se generará un cuello de botella que traerá consigo la caída del server.

Aquí tienes un buen turorial sobre hacer tu aplicación Multithreading: Concurrencia en Java 7

Los Controladores en JavaFX son exclusivos para una sola clase. Es decir, cuando le indicas qué clase quieres que sea el controlador:

fx:controller="paquete.clase"

Estás diciendo que esa clase contralará tu GUI. La clase RXTX contiene un TextField marcado como control FXML pero si te das cuenta está declarado en dicha clase, por lo que el TextField del controller y este TextField son distintos, acá no hay referencia. Por eso te da el NullPointerException, como ese TextField no corresponde a ningún controller, no se ha inicializado y por lo tanto vale null.

Puedes pasárselo por referencia a la clase RXTX por un constructor para que dicha clase haga uso del TextField, o por medio de un setter.

public class RXTX implements SerialPortEventListener{
 
   private TextField carlos;
 
  public RXTX(TextField carlos) { this.carlos = carlos; }

Salu2.

Te salen errores en primera porque olvidé colocar el tipo de retorno al método (ya se lo puse, mira el nuevo código). Además, como eres nuevo intuyo que no sabes aún los conceptos de POO. No te preocupes, todo con calma, paso por paso. Es mejor para tí si haces todo en el main (programación estructurada) ,luego te darás cuenta que ésto no es lo óptimo ya que tendrás el determinado "código spaghetti".

Te sugiero que antes de empezar a realizar ejercicios en un lenguaje, primero estudies el lenguaje. Si no, es como tratar de desarrollar un problema de geometría sin haberla estudiado antes.

public static void main (String[] args) {
	Scanner read = new Scanner(System.in);
	System.out.println("Ingresa un numero:");
	int num = read.nextInt();
	int numero = factorial(num);
 
	String digitos = String.valueOf(numero); // convierte el numero a string
	String temp = digitos; // copia el string para recorrer el for
	List<Character> digitosAscii = new ArrayList<>(); // almacena los caracteres ascii
	// temp.length()/2 porque se toman los numeros en pareja
	for(byte i=0; i<temp.length()/2; i++) {
		int digito; // almacena el digito a guardar en ascii
		if(digitos.length() >= 2) {
			int inicio = digitos.length() -2; // inicio = cantidad de digitos del numero - 2
			int finalx = digitos.length(); // final = cantidad de digitos del numero
			// obtiene la ultima pareja (derecha) de los digitos
			digito = Integer.valueOf(digitos.substring(inicio,finalx));
			// elimina la pareja que se ha tomado de los digitos
			digitos = digitos.substring(0,finalx-2);
		}
		else {
			// si solo queda un digito lo convierte a entero para convertirlo a ascii
			digito = Integer.valueOf(digitos);
		}
		digitosAscii.add((char) digito); // convierte el digito a ascii lo agrega a la lista
	}
	// recorre la lista de codigos ascii y los imprime
	for(char c : digitosAscii)
	System.out.println("Digito:\t"+c);
}

PD: Si tu duda fue disipada, por favor marca el tema como solucionado.

La verdad no te entiendo, pero supongo que quieres que a partir de un numero, se descomponga en parejas de derecha a izquierda, y convierta cada pareja en ascii y su queda un digito unico, lo convierte tambien. Este code te servirá:

public static  void getAsciiPorNumeroEnPares(int numero) {
	String digitos = String.valueOf(numero); // convierte el numero a string
	String temp = digitos; // copia el string para recorrer el for
	List<Character> digitosAscii = new ArrayList<>(); // almacena los caracteres ascii
		// temp.length()/2 porque se toman los numeros en pareja
		for(byte i=0; i<temp.length()/2; i++) {
			int digito; // almacena el digito a guardar en ascii
			if(digitos.length() >= 2) {
				int inicio = digitos.length() -2; // inicio = cantidad de digitos del numero - 2
				int finalx = digitos.length(); // final = cantidad de digitos del numero
				// obtiene la ultima pareja (derecha) de los digitos
				digito = Integer.valueOf(digitos.substring(inicio,finalx));
				// elimina la pareja que se ha tomado de los digitos
				digitos = digitos.substring(0,finalx-2); 
			}
			else {
				// si solo queda un digito lo convierte a entero para convertirlo a ascii
				digito = Integer.valueOf(digitos);
			}
			digitosAscii.add((char) digito); // convierte el digito a ascii lo agrega a la lista
		}
		// recorre la lista de codigos ascii y los imprime
		for(char c : digitosAscii)
			System.out.println("Digito:\t"+c);
}

No entiendo bien tu pregunta, ¿Quieres generar objetos aleatoriamente o quieres a partir de una lista de objetos elegir dos objetos aleatorios?

Sea como sea, no es difícil. Con la clase java.util.Random como te dijo engelx lo puedes conseguir. Te ejo un ejemplo:

package pe.edu.unp.rol;
 
public abstract class Jugador {
 
	private String nombre;
	private Double poder;
	private Integer vida;
 
	public Jugador() {
		this("",0d,0);
	}
 
	public Jugador(String nombre, Double poder, Integer vida) {
		this.nombre = nombre;
		this.poder = poder;
		this.vida = vida;
	}
 
	public String getNombre() {
		return this.nombre;
	}
 
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
 
	public Double getPoder() {
		return this.poder;
	}
 
	public void setPoder(Double poder) {
		this.poder = poder;
	}
 
	public Integer getVida() {
		return vida;
	}
 
	public void setVida(Integer vida) {
		this.vida = vida;
	}
 
 
}

package pe.edu.unp.rol;
 
public class Soldado extends Jugador {
 
	public Soldado() {
		super();
	}
 
	public Soldado(String nombre, Double poder, Integer vida) {
		super(nombre,poder,vida);
	}
 
}

package pe.edu.unp.rol;
 
public class Campesino extends Jugador {
 
	public Campesino() {
		super();
	}
 
	public Campesino(String nombre, Double poder, Integer vida) {
		super(nombre,poder,vida);
	}
 
 
}

package pe.edu.unp.rol;
 
public class Mago extends Jugador {
 
	private Double magia;
 
	public Mago() {
		super();
	}
 
	public Mago(String nombre, Double poder, Integer vida, Double magia) {
		super(nombre,poder,vida);
		this.magia = magia;
	}
 
	public Double getMagia() {
		return magia;
	}
 
	public void setMagia(Double magia) {
		this.magia = magia;
	}
}

package pe.edu.unp.rol;
 
public class Obrero extends Jugador {
 
	public Obrero() {
		super();
	}
 
	public Obrero(String nombre, Double poder, Integer vida) {
		super(nombre,poder,vida);
	}
 
 
}

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
 
public class Test {
 
	private final static String paquete = "pe.edu.unp.rol."; // nombre del paquete que contiene las clases
 
	/**
	 * Este metodo genera en tiempo de ejecución instancias de 4 clases distintas, con nombres aleatorios
	 * y sus propiedades poder, vida y en caso la instancia sea tipo 'Mago', agrega la magia, todos aleatorios.
	 * 
	 * @return List<Jugador>
	 * @throws InstantiationException
	 * @throws IllegalAccessException
	 * @throws IllegalArgumentException
	 * @throws InvocationTargetException
	 * @throws NoSuchMethodException
	 * @throws SecurityException
	 * @throws ClassNotFoundException
	 */
	public List<Jugador> getJugadores() throws InstantiationException, IllegalAccessException, IllegalArgumentException,
	InvocationTargetException, NoSuchMethodException, SecurityException, ClassNotFoundException {
		List<Jugador> listaObjetos = new ArrayList<>(); // lista que almacenara las instancias de las clases
		String[] clases = {"Soldado","Campesino","Mago","Obrero"};
		String[] nombres = {"Halz","Orion","Violetus","Orks","Kalz","Pivot","Nerth","Seth","Vandal"};
 
		int numeroObjetosAzar = new Random().nextInt(50)+1; // se crearan maximo 50 instancias con los 4 tipos de clases
 
		for(byte i=0; i<numeroObjetosAzar; i++) {
			// valores aleatorios que se setearan a las instancias
			String claseAleatoria = clases[ (1 + new Random().nextInt(3)) ];
			String nombreAleatorio = nombres[ (1 + new Random().nextInt(8)) ];
			Double poderAleatorio = Math.floor(1 + Math.random() * 100);
			Double magiaAleatoria = Math.floor(1 + Math.random() * 100);
			Integer vidaAleatoria = 1 + new Random().nextInt(100);
 
			/** de acuerdo a la clase, obtenemos una instancia de acuerdo a la clase que especificamos
			 por medio de 'Class.forName(clase)' seguido de 'getConstructor()' que obtiene el
			 constructor de dicha clase y le pasamos los parametros.
			 Esto se puede hacer perfectamente con el operador new Clase(parametros). La diferencia
			 es que Class.forName() se usa cuando no se sabe que clase instanciar si no hasta cuando
			 las circunstancias en tiempo de ejecucion lo determine. new lo usamos cuando sabemos de
			 antemano que clase instanciar.*/
			switch(claseAleatoria) {
			case "Soldado": listaObjetos.add((Soldado)Class.forName(paquete+claseAleatoria)
					.getConstructor(String.class,Double.class,Integer.class).newInstance(nombreAleatorio,poderAleatorio,vidaAleatoria));
			break;
			case "Campesino": listaObjetos.add((Campesino)Class.forName(paquete+claseAleatoria)
					.getConstructor(String.class,Double.class,Integer.class).newInstance(nombreAleatorio,poderAleatorio,vidaAleatoria));
			break;
			case "Mago": listaObjetos.add((Mago)Class.forName(paquete+claseAleatoria)
					.getConstructor(String.class,Double.class,Integer.class,Double.class).newInstance(nombreAleatorio,poderAleatorio,vidaAleatoria,magiaAleatoria));
			break;
			default : listaObjetos.add((Obrero)Class.forName(paquete+claseAleatoria)
					.getConstructor(String.class,Double.class,Integer.class).newInstance(nombreAleatorio,poderAleatorio,vidaAleatoria));
			}
		}
 
 
		return listaObjetos;
	}
 
	public static void main(String[] args) {
		Test test = new Test();
 
		/**
		 *  Ejemplo de recorrido. Generalizamos con 'Jugador' porque todas sus subclases:
		 * Soldado, Campesino, Mago y Obrero al heredar de Jugador son tambien un Jugador.
		 * Recuerda que la herencia es una relacion es un. El operador 'instaceof' es util
		 * para saber si una objeto es de una clase dada: objeto instaceof clase. Esto
		 * retorna true si es el objeto es una instancia de la clase o false si no lo es.
		 */
		try {
			for(Jugador e : test.getJugadores()) {
				System.out.println("Tipo:\t"+e.getClass().getSimpleName());
				System.out.println("Nombre:\t"+e.getNombre());
				System.out.println("Poder:\t"+e.getPoder());
				System.out.println("Vida:\t"+e.getVida());
				if(e.getClass().getSimpleName().equals("Mago")) {
					Mago mago = (Mago) e;
					System.out.println("Magia:\t"+mago.getMagia());
				}
 
			}
		} catch (InstantiationException | IllegalAccessException
				| IllegalArgumentException | InvocationTargetException
				| NoSuchMethodException | SecurityException
				| ClassNotFoundException e) {
				e.printStackTrace();
				System.err.println(e.getLocalizedMessage());
		}
 
 
	}

Eso pasa porque todo lo haces dentro del loop. Acostúmbrate a usar banderas, ésto no es más que una variable (normalmente booleana) que actúa como un informante. Si ocurre un determinado caso, la bandera va a guardar un valor, por ejemplo true, ésto dentro del loop.

Luego, fuera del loop analizas la bandera, si es true haces algo, si no, haces otra cosa.

public static void main(String[] args) {
		//launch(args);
		int[] array = {0,1,2,3,4,5,6,7,8,9,10};
		int numero = Integer.valueOf(javax.swing.JOptionPane.showInputDialog("Ingrese el numero a buscar"));
		boolean encontrado = false; // bandera que informa si se ha encontrado el numero
		int posicion = 0; // posicion del numero si se encuentra
		for(short i=0; i<array.length; i++) {
			if(numero == array[i]) {
				encontrado = true; // informa que se encontro el numero en
				posicion = i; // esta posicion
			}
		}
		// verifica el valor de 'encontrado' que sera true si se ha encontrado
		// el numero, de lo contrario sera false.
		if(encontrado)
			System.out.println("Numero encontrado en la posicion:\t"+posicion);
		else 
			System.out.println("Numero no encontrado.");
		System.exit(0); // termina el programa
	}

Éste es tu error, estás colocando punto y coma luego del for. Si colocas un punto y coma seguido de un loop (menos do-while) significa que ese loop es un loop vacío y el compilador lo ignora.

for(int indice=0; indice<=arreglo.length; indice++);

Por lo que if, en realidad no está dentro de ningún loop, y la variable 'indice' no existe, ya que solo existe dentro del loop. Solo puedes usar break cuando estás dentro de un loop.

Me equivoqué con el nombre del array nada más. Verifica nuevamente el código que puse.