logica de negocios
TRANSCRIPT
LOGICA DE NEGOCIOS
Este paquete se encargará exclusivamente de las restricciones y validaciones requeridas por el software,
estas restricciones deben ser tratadas de manera cautelosa ya que si no las tomamos en cuentas pueden
causar daños en el software, haciendo que el software no pueda ejecutarse.
En este paquete hemos considerado necesario la creación de nueve clases, estas clases funcionaran de una
manera que el usuario al momento de cometer un error el software se encargará de tratarlo, aquí se
manejaran las excepciones que serán resueltas en un nivel superior, en la respectivas clases de las que son
invocadas. Las excepciones serán manejadas en este software mediante las instrucciones Try y Catch.
Las clases a utilizar en este paquete son: GESTION NOTAS, CALCULADORA, APOSTFIJA, NOTAS,
OPERACIONES, PILAS, PILARESULTADO, REEMPLAZO Y VALIDAR. A continuación haremos una descripción
de las clases antes mencionadas
Clase Gestion Notas
Comenzaremos con la clase GESTION NOTAS, esta clase ha sido creada para manejar las excepciones antes
mencionadas, aquí crearemos ocho métodos los cuales son: Consultar Alumnos, Consultar Cursos, Registrar
Alumno, RegistrarCurso, ModificarAlumno, ModificarCurso, EliminarAlumnoyEliminarCurso. Para la
creación de estos métodos, ha sido necesario importar los paquetes: Entidades (Alumno y Curso) y Acceso a
Datos (TablaAlumno y TablaCurso) además la librería de java, ya que también utilizaremos listas. Todos
estos métodos mencionados anteriormente utilizaran las excepciones try y catch,cada uno de estos
métodos se encargara de retornar los métodoscreados por el paqueteacceso a datos, tanto para alumnos y
cursos los cuales son: Seleccionar, Insertar, Actualizar y eliminar.
Ahora explicaremos la clase Notas. En esta clase se ha debido importar los paquetes java.util.ArrayList,
java.util.List. Además hemos declarado una variable tipo String llamada “frase”, y luego el respectivo
constructor de la clase, esta variable(frase) será utilizada por los métodos de esta clase, los cuales son:
almacen, cadanota, esnumero, posiciónoperador, igualnota, búsqueda y listaauxiliar.
Empezaremos explicando el método almacén, en el cual se ha utilizado la variable “frase”, la misma que será
instanciada con la formula, luego hemos creado dos variables, una tipo String llamada “exa” (inicializada
como vacía) y otra variable “examen” que será un vector tipo String (el cual será del tamaño de la frase
ingresada), además de un contador “k” (inicializado en cero). En el respectivo código estamos inicializando
un bucle con la instrucción “for” para recorrer la frase, luego con la instrucción condicional “if” se compara
los caracteres de la frase recorrida para verificar si estos son letras entre A y Z. Si se cumple esta condición
entonces se evalúa una nueva, también con “if” para verificar si la posición siguiente en la frase es un
número (para esto se implemento el método esnumero), si esto se cumple entonces a la variable “exa” se
le atribuye la subcadena de la frase desde la posición “i” hasta “posicionoperador(i)” (para esto se
implemento el método posicionoperador) y luego al vector “examen” en la posición “k” le pasamos el valor
de la variable “exa” y a la posición “i” la dejamos en “posicionoperador(i)-1”. De con cumplirse esta ultima
condición (si no es número) entonces a la variable “exa” se le atribuye la subcadena de la frase desde la
posición “i” hasta “i+1” y luego al vector “examen” en la posición “k” le pasamos el valor de la variable
“exa”. De no cumplirse la primera condición (si la frase no contiene caracteres entre A y Z) entonces a la
variable “exa” le asignamos vacio (“”) y a la variable “k” la aumentamos en uno. Finalmente este método
nos retornara la variable vector “examen”.
El método esnumeroes para verificar si el carácter ubicado en una determinada posición es un número. Así
este método tipo boolean nos devolverá un valor de verdad. En su código podemos ver que hemos creado la
variable tipo carácter “numero”, luego con la instrucción condicional “if” verificamos que la variable
“numero” este ente los valores 0 y 9. De tal forma si se cumple esta condición retornara el valor de verdad
“true” y de no cumplirse retornara el valor “false”.
El método posicionoperadores para verificar la posición de un operador en la frase. Así este método de tipo
“int” nos retornara un valor tipo entero (“a”). Hemos creado las variables tipo enteras “posicion” y “a”, de
las cuales hemos asignado a la variable “a” el tamaño de la frase. En su código podemos ver que hemos
inicializado un bucle con la instrucción “for”, en el cual al contador “i” le hemos asignado la variable entera
“posicion”, luego recorremos la frase, y mediante una instrucción condicional “if” verificamos que la
subcadena de la frase en la posición (i,i+1) pueda ser igual a “+, -, *, /, (, )” para luego asignarle a la variable
“a” la posición “i”, y hacer un quiebre de bucle con la instrucción “break”. Finalmente el método nos
retornara la variable “a”.
El método cadanotaes para verificar los caracteres de la frase que forman una nota. Así este método que es
una “lista” nos devolverá la lista (“resultado”). Hemos creado una lista tipo array “resultado” y un vector
tipo String “examen”, al cual le hemos asignado el vector del método almacen.En su código podemos ver
que hemos inicializado un bucle con la instrucción “for”, para recorrer la frase y mediante una instrucción
condicional “if” verificamos que el vector “examen” en la posición “i” sea diferente de nulo(que no se
encuentre vació), si se cumple esta condición entonces se agrega “examen” en la posición “i” a la lista tipo
array “resultado”. Finalmente retornaremos la lista “resultado”.
El método búsqueda es para realizar una determinada búsqueda de una nota en la lista, este método se esta
declarando como booleano, aquí hemos dado como parámetros una lista tipo String “lista” y una variable
String “nota”, además se esta creando una variable tipo boolean “a” (inicializada en false). En su código
podemos ver que hemos inicializado una instrucción “for” para recorrer la lista y mediante una instrucción
condicional “if”se esta comparando si una nota ingresada es igual a la que se encuentra en la posición de la
lista, si se cumple esta condición a la variable “a” se le asigna el valor de verdad “true”. Finalmente el
método nos retornara la variable “a”.
El método listaauxiliar, el cual se esta declarando como una lista tipo string, aquí hemos dado como parámetro un entero “posicion”, además se esta declarando una lista tipo String “resultado”, a la cual le asignamos el método cadanota y también una lista tipo array “aux”. En su código podemos ver que hemos inicializado una instrucción “for” para recorrer la lista “resultado” y mediante una instrucción condicional “if” se esta comparando si el contador “i” es igual al de la variable posicion, de no ser igual entonces agregara a la lista “auxi” la lisa resultado en la posicion “i”. Finalmente este método retornara la lista “aux”.
El método igualnotas es para verificar si existen notas iguales dentro de la lista auxiliar, en este método se hace un llamado a busqueda y listaauxiliar. Aquí se ha creado una lista tipo String “resultado”, a la cual le asignamos el método cadanota y también una lista tipo array “aux”. en el codigo podemos ver que hemos inicializado una instrucción “for” para recorrer la lista “resultado”, luego hemos asignado a la variable “aux” el método listaauxiliar con el parámetro indicador de posicion “i”, y mediante una instrucción condicional “if” hemos llamado al método busquedapara verificar si el valor de la lista aux para resultado.get(i) es igual a “true”, de cumplirse esta condición el valor de la variable “notasiguales” le asignamos el valor “true” y hacemos un quiebre de ciclo con la instrucción “break”. Finalmente este método nos retornara la variable “notasiguales”. Siguiendo con las clases ahora explicaremos la clase operaciones. . En esta clase no se ha importado ningún
paquete. Hemos declarado tres variables tipo double “x, y, respuesta” y una variable tipo String llamada
“letras”, además de su respectivo constructor. Hemos considerado la creación de cuatro métodos, los cuales
son: suma, resta, producto, division. En todos estos metodos se realiza una operación respectiva(+, -, *, /) y
retorna una variable respuesta. Como todos tienen la misma logica vamos a explicar solo uno de ellos.
El método suma se encargara de realizar el proceso de suma entre las variables “x” y “y”, para luego
asignarlo a una variable resultado y finalmente retornando esta.
Ahora veremos la clase calculadora, en esta clase hemos importado los paquetes Entidades.Nota,
java.util.ArrayList;,java.util.List y seran usado según la necesidad de los metodos, los cuales son: EsCorrecto,
DeterminarTiposEvaluacion y Calcular.
Empezaremos explicando el metodoEsCorrecto, este metodo es de tipo boolean y tiene como parámetro la
variable tipo String “Expresion” . Básicamente el metodoconsistira en retornarnos que la expresión esta
correcta.
Seguiremos con el metodoDeterminarTiposEvaluacion, el cual es una lista tipo String con su parámetro “Expresion”. Se ha creado una variable lista tipo String “resultado”, luego se ha creado el objeto “obj” de la clase notas y se le ha dado como parámetro la variable “Expresion”, después a la variable resultado se le ha asignado el objeto “obj” que ha llamado al metodocadanota, de la clase notas. Finalmente este metodo nos retornara la lista “resultado”. Finalmente veremos el método Calcular, este método es de tipo Double y se le ha asignado los parámetros “Expresion” y “Notas”. Se ha inicializado una variable “resultado” de tipo double con el valor 0,0 para ser reconocida. Luego se ha creado una lista tipo String “notitas” en la cual se almacenaran todas las notas del modelo de la tabla, tambien se han creado una variable tipo double “a” inicializada en 0. En el código podemos observar que hemos inicializado una instrucción “for” para recorrer la lista Notas, luego con una instrucción condicional “if” verificamos si la nota es menor que cero o mayor que 20, si se cumple esta condición agregamos a la lista “notitas” el valor 0, de no cumplirse entonces agregamos la nota a la lista “notitas”. Teniendo la lista notitas, creamos un objeto “ennumeros” de la clase remplazo con los parámetros “notitas” y ”Expresion” , luego le asignamos a una variable String “num” el objeto ennumeros con el metodomejorado e imprimimos la variable “num”. Siguiendo el codigo se ha creado el objeto “posfija” de la clase aposfija y se le ha asignado a la variable String “pos” este objeto con el metodo resultado para luego imprimir la variable “pos”. Finalmente se ha creado el objeto “res” de la clase pilaresultadocon el parámetro “pos” para luego asignar a la variable “resultado” el objeto “res” con el metodoPilaVacia2 convertido a tipo de dato double, para al final retornar esta variable.
CLASE VALIDAR
En esta clase se comprueba la formula si esta semántica y sintácticamente correcta, para empezar se ha
declarado una variable global “frase” la cual se utilizara para instanciarla por medio del constructor:
public validar(String frase) {
this.frase = frase;
}
Después del constructor se ha creado una clase llamada validación en la cual retornará si la frase esta
correctamente escrita o no, en este caso luego se llamara este método para verificar si la formula esta
correctamente escrita:
publicbooleanvalidacion(){ if(hay()==true){ if(parentesis()==true){ pilaObj =new pila(frase); if(Obj.Pila()==true){ returnconparentesis(); }else{ return false; } } else{ returnsinparentesis(); } }else{ return false; } }
En este método se ha llamado a otras funciones como “hay()”, la cual devuelve si es que la frase tiene operadores y notas, además el método “paréntesis” devuelve si hay una cantidad par de paréntesis, para luego crear un objeto “Obj” de la clase “Pila()” la cual contiene una pila con sus correspondientes métodos que devuelve si la frase esta correctamente escrita con sus paréntesis:
publicbooleanPila(){ booleanretornar=true; for (int i = 0; i <frase.length(); i++) { if(frase.substring(i,i+1).equals("(")){ agregar(1); } if(frase.substring(i,i+1).equals(")")){ if(pop()==true){ }else{ retornar=false; break; } } } return retornar;
} Luego colocamos una sentencia “if ” que divide cuando hay y no hay paréntesis : “conparentesis()” y “sinparentesis()”: En estos dos métodos se usara el proceso de recursividad por cuestiones didácticas explicare el primer método “sinparéntesis()”, en esta podemos mencionar que hemos considerado un algoritmo recursivo que llama a diversos métodos: privatebooleanEsLetra(String expresion, int posicion){ } =>>>En este método inicializa la recursividad puesto que en la expresión debe o bien comenzar con una letra o bien con un numero no puede comenzar de otra forma, este método llama a los siguientes. Luego aumenta la posición en que se encuentra y llama a los métodos recursivos como son que en el caso de que en la posición siguiente puede haber un operador, un numero, y un terminador el cual le hemos asignado un “;” para poder terminar el bucle, los siguientes métodos muestran lo que le continua por ejemplo: Los siguientes métodos recursivos privatebooleanEsOperador(String expresion, int posicion){ } =>>>Este Método devuelve recursivamente verdad o falsedad si al que le continua son: Una letra o un numero con su respectivo método. privatebooleanEsNumero(String expresion, int posicion){ } =>>>Este Método devuelve recursivamente verdad o falsedad si al que le continua son: Un numero, un punto, un operador un terminador con su respectivo método. privatebooleanEsPunto(String expresion,int posicion){ } =>>>Este Método devuelve recursivamente verdad o falsedad si al que le continua son: Es un numero con su respectivo método. privatebooleanEsTerminador(String expresion, int posicion){ } =>>>Este Método devuelve recursivamente verdad o falsedad si al que le continua son: En este caso el “;”. En el método de conparentesis() igual se generan los métodos pero teniendo en cuenta por ejemplo que a un paréntesis cerrado no le puede seguir ni una nota ni un numero, y que necesariamente debe ser un operador
CLASE NOTA
En este clase igual que las demás clases se crea un constructor para después instanciarlo este clase
nota esta compuesta por dos métodos principales el primero almacen() que devuelve todas las notas que se
encuentran en la frase en este caso las notas de la formula en un Array y el otro método convierte este array
en una lista para su mejor uso.
public String[] almacen(){
frase=frase.toUpperCase();
String exa="";
String examen[] = new String[frase.length()];
int k=0;
for (int i = 0; i <frase.length(); i++) {
if(frase.charAt(i) == 'A' || frase.charAt(i) == 'B'||
frase.charAt(i) == 'C' || frase.charAt(i) == 'D'||
frase.charAt(i) == 'E' || frase.charAt(i) == 'F'||
frase.charAt(i) == 'G' || frase.charAt(i) == 'H'||
frase.charAt(i) == 'I' || frase.charAt(i) == 'J'||
frase.charAt(i) == 'K' || frase.charAt(i) == 'L'||
frase.charAt(i) == 'M' || frase.charAt(i) == 'Ñ'||
frase.charAt(i) == 'N' || frase.charAt(i) == 'O'||
frase.charAt(i) == 'P' || frase.charAt(i) == 'Q'||
frase.charAt(i) == 'R' || frase.charAt(i) == 'S'||
frase.charAt(i) == 'T' || frase.charAt(i) == 'U'||
frase.charAt(i) == 'V' || frase.charAt(i) == 'W'||
frase.charAt(i) == 'X' || frase.charAt(i) == 'Y'||
frase.charAt(i) == 'Z'){
if(esnumero(frase.charAt(i+1))){
exa=exa+frase.substring(i, posicionoperador(i));//;i+2);
examen[k]=exa;
//i=i+1;
i=posicionoperador(i)-1;
}
else{
exa=exa+frase.substring(i, i+1);
examen[k]=exa;
}
}
else{
exa="";
k=k+1;
}
}
returnexamen;
}
public List<String>cadanota(){
List<String>resultado = new ArrayList();
String examen[] = almacen();
for (int i = 0; i <frase.length(); i++) {
if(examen[i]!=null){
resultado.add(examen[i]);
}
}
return resultado;
}
La algoritmo utilizado en el primer método es el de crear un array “examen*+” de la longitud de la “frase”,
luego se recorre la frase si encuentra una letra que la almacene en el array desde esta posición hasta la
posición del siguiente operador para lo cual hemos utilizado el método posición operador()
public int posicionoperador(int posicion){ int a=frase.length(); for (int i = posicion; i <frase.length(); i++) { if(frase.substring(i, i+1).equals("+")||frase.substring(i, i+1).equals("-")||frase.substring(i, i+1).equals("*")|| frase.substring(i, i+1).equals("/")||frase.substring(i, i+1).equals("(")||frase.substring(i, i+1).equals(")")){ a=i;
break; } } return a; }
Para dar una mejor efectividad al programa he creido realizar tres funciones mas: igualnotas(), busquedad(List<String>lista, String nota), listaauxiliar(int posicion), maximo():
publicbooleanigualnotas(){ booleannotasiguales=false; List<String>resultado =cadanota(); List<String> aux = new ArrayList(); for (int i = 0; i <resultado.size(); i++) { aux=listaauxiliar(i); if(busquedad(aux,resultado.get(i))==true){ notasiguales=true; break; } } returnnotasiguales; }
En este método creamos una lista del método realizado con anterioridad “cadanota()” luego recorreremos esta lista y por cada nota crearemos una lista auxiliar con el método listaauxiliar() con el fin de con el método busquedad(aux, resultado.get(i)) devuelva si exite una lista igual. Luego finalmente con el método máximo() se ha realizado un testeo con la nota 20 se ha creado una lista y se ha efectuado con la formula:
publicbooleanmaximo(){ doubleveinte; List<String>resultado =cadanota(); List<String> aux =new ArrayList(); for (int i = 0; i <resultado.size(); i++) { aux.add("20"); } remplazoennumeros=new remplazo(aux,frase); String num=ennumeros.mejorado(); aposfijaa posfija=new aposfijaa(); String pos=posfija.resultado(num); pilaresultado res=new pilaresultado(pos); veinte=Double.parseDouble(res.PilaVacia2()); if(veinte==20){ return true; } else{ return false; } }
Como se puede observar se ha creado un objeto con la clase remplazo la cual con la lista de notas de 20 ha sido remplazado en la formula por las notas, Luego se ha instanciado un objeto con la clase aposfijaa y este a su vez en pilaresultado() el cual efectuara la formula hecha números en posfija y posteriormente su resultado. Si el resultado es 20 significa que la formula esta correctamente escrita de no ser así esta incorrecta.
CLASE PILARESULTADO En esta clase se resuelve la formula escrita en posfija para el resultado final de la operación:
public String PilaVacia(){ String operando1; String operando2; String simbolo; double valor=0; String acumulador=""; for (int i = 0; i <frase.length(); i++) { simbolo=frase.substring(i, i+1); if(operando(simbolo)==true){ acumulador=acumulador+simbolo; }else{ if(simbolo.equals(" ")){ if(!acumulador.equals("")){ agregar(acumulador); acumulador=""; } }else{ if(!simbolo.equals(" ")&&vec.length>1){ operando1 = pop(); operando2 = pop(); Operaciones op= new operaciones(Double.parseDouble(operando2),Double.parseDouble(operando1)); f (simbolo.equals("+")) { valor=op.suma(); }
if (simbolo.equals("-")) { valor=op.resta(); }
if (simbolo.equals("*") ){ valor=op.producto(); }
if (simbolo.equals("/")) { valor=op.division(); }
agregar(Double.toString(valor)); } } } } }
En este método recorremos la expresión si encuentra un operando este que lo vaya acumulando. Si no, si encuentra un vacío que extraiga de la pila los operadores y según su operación ejecutar con estos operadores la operación correspondiente. Al Final se retornará el único elemento de la pila que será el resultado de la operación, que vendría hacer el promedio.
CLASE APOSFIJA
Esta clase llamada posfija se encargará de convertir la formula de inflija a postfija, que es mejor trabajarlo
así.
Empezaremos por crear un dato de tipo string llamado encontradas que será una variable de tipo global y
nos devolverá el resultado evaluado o convertido.
Luego creamos el método resultado que se encargará de devolvernos el resultado de tipo string y este
método recibe de parámetro expresion. Hemos importado la pila de la librería java para facilitarnos su uso,
ya que habrá dos pilas una donde guardara los números y la otra los operadores, entonces creamos un
objeto llamado PilaNumeros y PilaOperadores respectivamente de la clase Stack() . La expresion la pasamos
a mayúsculas y la guardamos en “exp”, declaramos un dato de tipo string llamado fragmento se encargará
de guardar el fragmento de texto que se esté utilizando en el momento (ya sea un número, un operador,
etc.), un dato de tipo int llamad “posicion” y “tamaño”, se encargaran de la posicion del carácter que se esta
procesando actualmente y del tamaño del texto que se procesa en este momento respectivamente y un
dato de tipo int llamado “cont” que se encargará de contar, indica el número de caracteres que se sacan del
string en un momento indicado, este no puede ser más de cuatro (la función con más caracteres).
public class aposfija El nombre de nuestra clase
private String encontadas;
public String resultado(String expresion){
Stack PilaNumeros=new Stack();
Stack PilaOperadores= new Stack();
String expr=expresion.toLowerCase();
String fragmento;
intpos=0, tamaño=0;.
intcont=1;
String funciones []={"1 2 3 4 5 6 7 8 9 0 ( ) x + - * /"}
String parentesis="(";
int anterior=0;
Comenzamos a recorrer la expresion, luego validamos si la suma de pos mas cont sea menor o igual al
tamaño de la expresion y utilizamos el indexOf, hace que a cada elemento del array llamado funciones si hay
el número de ocurrencias es por que será diferente de “-1”, si no, quiere decir que no hay ocurrencias; si
esto es correcto entonces tamaño es igual a cont y este se irá incrementando.
for (int i = 0; i <expr.length(); i++) {
tamano=0;
cont=1;
if (tamano==0 &&cont<=1){ //Este while revisa si el pedazo del texto sacado concuerda con algo
conocido
if(pos+cont<=expr.length() &&funciones[cont-1].indexOf(expr.substring(pos,pos+cont))!=-1){
tamano=cont;
}
cont++;
}
Si encontró algo, de tamaño uno, y otra condición donde llama al método EsNumero, que le pasas como
parámetro el recorrido de la expresion desde pos hasta po+tamaño, si lo es, se encargara de sacarlo por
completo. Dentro de la condición inicializamos el fragmento como vacío que es el acumulador, ya que será
ahí donde se guardará el número sacado anteriormente con la instrucción do while, que haga mientras siga
siendo número o punto que vaya concatenando y siga aumentando el pos, mientras pos sea menor que el
tamaño de la expresión o sea igual a un punto o una coma. Luego hace el fragmento lo agrega a la pila de
números, anterior se le asigna uno y el contador disminuye en uno.
Pero si no es número quiere decir que un operador, la cual puede ser una suma, resta, multiplicación o
división; llama al método extraeOperadores que se encargará de que si el operador tiene menor prioridad del
operador que se encuentra en la pila entonces va ir sacando los operadores de mayor prioridad hasta
entrarlo en la pila, hay que tener en cuenta que va tener que llamar al método prioridad para que realice el
cambio sucesivo hasta cuando encuentre uno que sea menor o igual.
Luego este método llamara al método extraerOperador se encargara de se sacar el operador que se va
evaluar, si encuentra un operador saca dos elementos de la pila numeros y los guarda con el operador que fue
evaluado a la PilaNumeros, pero hemos tenido que crear un objeto de la clase string debido a que vamos a
concatenar los operadores con los espacios en blanco (Numeros.push(new String(a+" "+b+" "+operador)); ) y
sino saca un elemento y lo concatena con el operador (Numeros.push(new String(a+" "+operador)).
if(tamaño==1){ //Si encontró algo de tamaño uno
if(EsNumero(expr.substring(pos, pos+tamaño))){ //Si es un número se encarga de sacarlo
completo
fragmento="";
do{
fragmento=fragmento+expr.charAt(pos);
pos++;
}while(pos<expr.length() && Numero(expr.substring(pos,pos+tamano)) || expr.charAt(pos) == '.'
|| expr.charAt(pos) == ',' ));
PilaNumeros.push(new String(fragmento));
anterior=1;
pos--;
}else if (expr.charAt(pos)=='+' || expr.charAt(pos)=='*' || expr.charAt(pos)=='/' ){
ExtraeOperadores(PilaNumeros, PilaOperadores, expr.substring(pos, pos+tamano));
anterior=2;
}elseif (expr.charAt(pos)=='-'){ //Si es una resta
if(anterior==0 || anterior==2 || anterior==3){
PilaNumeros.push(new String("-1"));
ExtraeOperadores(PilaNumeros, PilaOperadores, "*");
}else{//
ExtraeOperadores(PilaNumeros, PilaOperadores, " -");
}
anterior=2;
}else if (expr.charAt(pos)=='('){
if (anterior==1 || anterior == 4){
ExtraeOperadores(PilaNumeros, PilaOperadores, "*");
}
PilaOperadores.push(new String("("));
anterior=3;
}else if (expr.charAt(pos)==')'){
while(!PilaOperadores.empty() &&parentesis.indexOf(((String)PilaOperadores.peek()))==-1){
ExtraeOperador(PilaNumeros, PilaOperadores);
}
if(!((String)PilaOperadores.peek()).equals("(")){
PilaNumeros.push(new String(((String)PilaNumeros.pop()) + " " + ((String)PilaOperadores.pop())));
}else{
PilaOperadores.pop();
}
anterior=4;
}
}
pos+=tamano;
}
//Procesa al final
while(!PilaOperadores.empty()){ //Saca todos los operadores mientras la pila no esté vacía
ExtraeOperador(PilaNumeros, PilaOperadores);
}
encontadas = ((String)PilaNumeros.pop()); //Se obtiene el resultado final
returnencontadas; //Se devuelve el resultado evaluado
}
En este método se crea una tercera pila con el fin evaluar la expresion y dividirla por morfemas luego que la
divide recorre los tokens, cada token representa un numero o un operador, en caso de ser un operador va a
ejecutar la operación en caso q no llena la pila en la pila en la operación realizada y si no la llena en el Token.
public double f(String expresionParseada, double x) {
StackpilaEvaluar = new Stack(); // Pila de doubles para evaluar
double a, b; //Estos valores son los que se van sacando de la pila de doubles
StringTokenizertokens=new StringTokenizer(expresionParseada); //La expresión partida en tokens
String tokenActual; //El token que se procesa actualmente
while(tokens.hasMoreTokens()){ //Haga mientras hayan más tokens
tokenActual=tokens.nextToken();
if(tokenActual.equals("+")){//Si es una suma se sacan dos números y se suman
b=((Double)pilaEvaluar.pop()).doubleValue();
a=((Double)pilaEvaluar.pop()).doubleValue();
pilaEvaluar.push(new Double(a+b));
}elseif(tokenActual.equals("-")){//Si es resta se sacan dos valores y se restan (así con todos los
operadores)
b=((Double)pilaEvaluar.pop()).doubleValue();
a=((Double)pilaEvaluar.pop()).doubleValue();
pilaEvaluar.push(new Double(a-b));
}else if(tokenActual.equals("*")){//Multiplicación
b=((Double)pilaEvaluar.pop()).doubleValue();
a=((Double)pilaEvaluar.pop()).doubleValue();
pilaEvaluar.push(new Double(a*b));
}else if(tokenActual.equals("/")){//División
b=((Double)pilaEvaluar.pop()).doubleValue();
a=((Double)pilaEvaluar.pop()).doubleValue();
pilaEvaluar.push(new Double(a/b));
}else{//si es otra cosa tiene que ser un número, simplemente se mete en la pila
pilaEvaluar.push(Double.valueOf(tokenActual));
}
}
a=((Double)pilaEvaluar.pop()).doubleValue(); //El valor a devolver
return a;
}
Este método se va encargar de devolver la prioridad que será de tipo entero ya sea “0”, “1” ó “-1”ya que la
multiplicación y división tienen prioridad sobre el “+” mas y gggg “-“.
private int prioridad(char s) {
if (s=='+' || s=='-') //Si es una suma o una resta devuelve cero
return 0;
elseif (s=='*' || s=='/') //Si es multiplicación, división o resto de división devuelve
uno
return 1;
return -1; //Si no fue nada de lo anterior devuelve -1
}
Este método se va encargar de devolver si es número o no, si lo es retornará true, sino false y recibirá como
parámetro un s de tipo String.
privatebooleanEsNumero(String s) {
booleancomo = true;
if (s.equals("0") || s.equals("1") || s.equals("2") || s.equals("3") || s.equals("4") ||
s.equals("5") || s.equals("6") || s.equals("7") || s.equals("8") || s.equals("9")) //Si el caracterestá
entre 0 y 9 (sies un número) {
return como;
}else
como=false;
}
return como;
}
private void ExtraeOperadores(StackPilaNumeros, StackPilaOperadores, String operador){
//Todas las funciones que se manejan como paréntesis de apertura
final String parentesis="(";
//mientras (While) la pila no esté vacía, el operador que sigue no sea un paréntesis de
apertura, la longitud del operador sea uno (para que sea un operador), y la prioridad indique que tiene que
seguir sacando elementos
while(!PilaOperadores.empty() &&parentesis.indexOf((String) PilaOperadores.peek()) ==-1 &&
((String)PilaOperadores.peek()).length()==1 &&
prioridad(((String)PilaOperadores.peek()).charAt(0))>=prioridad(operador.charAt(0))){
ExtraeOperador(PilaNumeros, PilaOperadores); //Saca el siguiente operador
}
PilaOperadores.push(operador);//Al final mete el nuevo operador luego de sacar todo lo que tenía que
sacar.
}
private void ExtraeOperador(Stack Numeros, Stack operadores) {
String operador,
String a;
String b;
String operadores="+ - * / "; //Lista de los operadores
operador= (String) operadores.pop(); //Saca el operador que se debe evaluar
if(operadores.indexOf(operador)!=-1){ //Si es un operador saca dos elementos de la pila
y guarda la operación
b=(String)Numeros.pop();
a=(String)Numeros.pop();
Numeros.push(new String (a+" "+b+" "+ operador));
}else{ //==>Sino sólo saca un elemento
a=(String)Numeros.pop();
Numeros.push(new String(a+" "+operador));
}
}//sacaOperador