domingo, 2 de mayo de 2010

Reproducir musica en java N°2

Este reproductor basico es para poder reproducir archivos mp3 wav ogg en una interfaz java con skin´s ademas tiene capacidad de guardar listas de reproducccion adelantar la cancion a determinada posicion con un slider darle al archivo anterior como al posterior , repeticion aleatoria,continua y sin repeticion.

No eh tenido tiempo de poner el codigo pues lo tengo q documentar pero si les agrada la aplicacion lo pondre gustoso.
Dejo las visualizaciones ahh la funcion ocultar aun no esta disponible se trata de hacer que se vuelva un trayicon.
Equalizador en desarrollo..........

Link = http://www.4shared.com/file/UiltlT6o/Reproductor_de_sonido_Expandib.html


Uso de swing y objetos

/*
* Realizar el programa mediante arreglo de objetos ingresar las notas (parcial final practicas) de n alumnos se pide obtener su promedio general y
* el promedio de la clase
*
*/
package promedio;

import javax.swing.JOptionPane ;

public class Main {

public static void main(String[] args) {
String temp;
double a,b,n,c;
double k=0;
secundaria promedio=new secundaria();
secundaria[] wec=new secundaria[100];
do
{
temp=JOptionPane.showInputDialog("Ingrese Nº de alumnos");
n=Double.parseDouble(temp);}
while (n>=100);{
for (int i=0;i {
temp=JOptionPane.showInputDialog("Examen parcial");
a=Double.parseDouble(temp);
temp=JOptionPane.showInputDialog("Examen final");
b=Double.parseDouble(temp);
temp=JOptionPane.showInputDialog("Promedios de practicas");
c=Double.parseDouble(temp);
wec[i]=promedio;

JOptionPane.showMessageDialog( null,"promedio del alumno: "+wec[i].promedio(a,b,c));
k=k+wec[i].promedio(a,b,c);

}
}

JOptionPane.showMessageDialog( null,"promedio de la clase: "+k/n);
}

}

package promedio;
public class secundaria {
double promedio(double x, double y, double z)
{
return (x+y+z)/3.0;
}
}

Es un pequeño ejemplo de este uso en el comprimido estan mas ejemplos

Link = http://www.mediafire.com/?o4z2wot2yjz

Uso de objetos

Ahora usemos objetos es encillo instanciando otra clase.
Hgamos algo sencillo vean:

package objetos;
public class main2 {
public static void main(String[] args) {
long i,n,num;
n=(int) (Math.random() * 100);

for(i=1;i<=n;i++)
{
num =(int) (Math.random() * 20);
Secundaria2 obj=new Secundaria2(num);//Instanciamos la clase secundaria
obj.factorial();
obj.sumatoria();
}

}

}

package objetos;
public class Secundaria2 {
long y;
Secundaria2(long z){
y=z;
}
void factorial()
{

long fact=1;
for(int j=1;j<=y;j++)
{
fact=fact*j;
}
System.out.println("El factorial de "+y+" es :"+fact);
}
void sumatoria()
{
long sumcif=0,res,x;
x=y;
while(y!=0)
{
res=y%10;
sumcif=sumcif+res;
y=y/10;
}
System.out.println("la suma de cifras de "+x+" es: "+sumcif);
System.out.println("");
}
}

Usamos asi los metodos de otra clase otra alternativa a heredar metodos

Ahora esos no son las unikas variaciones en el archivo estan las demas y funcionales
Link = http://www.mediafire.com/?mocjm2untti

Capicua


Capicua es un numero que al voltearlo es el mismo ejemplo 121; 12521, etc.
Hagamos un programa que nos encuentre estos numeros.
/*
/*
 * Realizar el programa que asigne aleatoriamente el numero entero entre
 * 3 y 5 cifras , se pide calcular e imprimir cuantos nùmeros asignados
 *son capicuas
 */
public class capicua{

    public static void main(String[] args) {
        int n, num, i, cif, x, inv, cont;
        n = (int) (Math.random() * 100); // veces a repetir
        for (i = 0; i < n; i++) {
            num = (int) (Math.random() * 99900 + 100);
            x = num;
            inv = 0;
            cont = 0;
            do {
                cif = num % 10;// obtener ultima cifra
                inv = inv * 10 + cif; //invirtiendo el numero
                num = num / 10; //Quitandole la ultima cifra
            } while (num != 0);

            if (inv == x) {
                cont++;
                System.out.println(x + " es capicua");
            }
            else {
                System.out.println(x + " no es capicua");
            }
        }
    }
}
Link = http://www.mediafire.com/?utywdineju1

Numero de cifras

Bueno este es un ejmplo sencillo algunos me diran.
¿Por que no pasar el numero a String y pasarle un metodo .length() ? y asi sacamos la cantidad de cifras.

Pero asi no aprendemos la forma que les comente de instancia asi.

int numero = 12345;
String nume = String.valueOf(numero);
int longitud = nume.length(); //Esto seria la cantidad de cifras del numero

o lo juntamos todo

int numero = 12345;
int lonitud = String.valueOf(numero).length();

Hagamos el metodo largo pero educativo :

/*
* Realizar el programa que asigne aleatoriamente n numeros enteros se pide calcular e imprimir
* la cantidad de cifras que tiene cada numero asignado.
*/

package proyecto;
public class numerodecifras {
public static void main(String[] args) {

int n,num,cif,i,x;
n=(int)(Math.random()*100);

for(i=0; i<=0; i++)
{
num=(int)(Math.random()*10000);
x=num;
cif=0;
while (num!=0)
{
num= num/10;
cif++;
}
System.out.println("El numero "+x+" tiene "+cif+" cifras");

}
}

}

Link = http://www.mediafire.com/?xmdzqy3zm2k

Mcd,Mcm java

Ahora veamos la forma en que hallamos el mcm y mcd dando un ejemplo sencillo podran modificarlo y aplicarlo.
En este caso vemos que asigno numeros uds. le pueden poner un Math.ramdom() para que sean variable o cualquier cosa que imaginen.

/*
* Dado 2 numeros enteros calcular su maximo comun divisor
* y su minimo comun divisor.
*/

package problemasunfv;

/**
*
* @author JONATHAN
*/
public class mcmymcd {

public static void main(String[] args) {
int a,b,t,t1,x;
a=10;
b=20;
t=1; //constante inicializada para evitar la multiplicidad x cero
x=2; //constante inicial

while (x<=a && x<=b)
{
while (a%x==0 && b%x==0)
{
a=a/x;
b=b/x;
t=t*x;
}
x++;
}
t1=t;
t=t*a*b;
System.out.println("El mcm es :" +t);
System.out.println("El mcd es :" +t1);
}

}

Ahora veamos como hacer imprimir numeros que comiensan y termionan con la misma cifra.
El codigo esta aqui:

/*
* Realizar el programa que asigen aleatoriamente n numeros enteros se pide
* calcular e imprimir cuantos numeros empiesan y terminan en la misma cifra.
*/

package problemasunfv;

public class numeros {
public static void main(String[] args) {
int n,i,d,d1=0,contador = 0;

n=(int)(Math.random()*20);
if (n==0)
n=1;
i=1;
while (i<=n)
{
d=(int)(Math.random()*1000);
System.out.println(d);
int r=1,k=0;
k=d;
d1=k%10;
while (d!=0)
{
r=d%10;
d=d/10;
}
//System.out.println(r+" y "+d1);
if (r==d1)
{
//System.out.println("Si cumple la condicion");
contador++;
}
else
{
//System.out.println("No cumple la condicion");
}
i++;
}
System.out.println("Son en total "+contador+" los que cumplen con la condicion");
}
}

Ahora hay formas graficas de aplicarlos pero eso esta en el archivo que adjunto lo descargan y veran que es sencillo.

Link = http://www.mediafire.com/?jy4dxznikn3

Funciones trigonometricas en una tabla

Hagamos una tabla de funciones trigonometricas es muy sencillo asi q manos a la obra.

/**
*
* @author JONATHAN
*/
public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
double sen,cos,tan,cotg,sec,csc,d;
int i=0;

System.out.println("***********************************************************************************************************************************************************************************");
System.out.println("*\t\t\t\t\t\t\t\tRazones trigonometricas\t\t\t\t\t\t\t\t\t\t\t *");
System.out.println("***********************************************************************************************************************************************************************************");
System.out.println("Angulo \tSeno\t\t\tCoseno\t\t\ttangente\t\t\tcotangente\t \tsecante\t\t cosecante");
System.out.println("***********************************************************************************************************************************************************************************");
System.out.println(0+" \t"+Math.sin(0)+" \t\t\t"+Math.cos(0)+" \t\t\t"+Math.tan(0)+" \t\t\t"+(1/Math.tan(0))+" \t\t"+(1/Math.cos(0))+"\t\t\t"+(1/Math.sin(0)));
while (i<30) {
i=i+15;

d=i*3.1415926535897932384626433832795/180;
sen=(double)(Math.sin(d));
cos=(double)(Math.cos(d));
tan=(double)(Math.tan(d));
cotg=1/tan;
sec=1/cos;
csc=1/sen;

System.out.println(i+"\t"+sen+"\t"+cos+"\t"+tan+"\t"+cotg+"\t\t"+sec+"\t\t"+csc);
}
for(i=37;i<=53;i=i+8){

d=i*3.1415926535897932384626433832795/180;
sen=(double)(Math.sin(d));
cos=(double)(Math.cos(d));
tan=(double)(Math.tan(d));
cotg=1/tan;
sec=1/cos;
csc=1/sen;

System.out.println(i+"\t"+sen+"\t"+cos+"\t"+tan+"\t"+cotg+"\t\t"+sec+"\t\t"+csc);
}

for(i=60;i<90;i=i+15){
d=i*3.1415926535897932384626433832795/180;
sen=(double)(Math.sin(d));
cos=(double)(Math.cos(d));
tan=(double)(Math.tan(d));
cotg=1/tan;
sec=1/cos;
csc=1/sen;

System.out.println(i+"\t"+sen+"\t"+cos+"\t"+tan+"\t"+cotg+"\t\t"+sec+"\t\t"+csc);
}

System.out.println(90+" \t"+(Math.sin(0)+1)+"\t\t\t "+(Math.cos(0)-1)+"\t\t\tinfinito"+ "\t\t\t"+0.0+"\t\t"+(1/Math.cos(0))+"\t\t\t"+(1/Math.sin(0)));
System.out.println(180+" \t"+Math.sin(0)+" \t\t\t"+-Math.cos(0)+" \t\t\t"+Math.tan(0)+" \t\t\t"+(1/Math.tan(0))+" \t\t"+(-1/Math.cos(0))+"\t\t\t"+(1/Math.sin(0)));
for(i=210;i<270;i=i+30){
d=i*3.1415926535897932384626433832795/180;
sen=(double)(Math.sin(d));
cos=(double)(Math.cos(d));
tan=(double)(Math.tan(d));
cotg=1/tan;
sec=1/cos;
csc=1/sen;

System.out.println(i+"\t"+sen+"\t"+cos+"\t"+tan+"\t"+cotg+"\t\t"+sec+"\t\t"+csc);
System.out.println(270+" \t"+-(Math.sin(0)+1)+" \t\t"+(Math.cos(0)-1)+"\t\t\tinfinito"+ "\t\t\t"+0.0+"\t\t\t"+-(1/Math.cos(0))+"\t\t\t"+(1/Math.sin(0)));
System.out.println(360+" \t"+Math.sin(0)+" \t\t\t"+Math.cos(0)+" \t\t\t"+Math.tan(0)+" \t\t\t"+(1/Math.tan(0))+" \t\t"+(1/Math.cos(0))+"\t\t\t"+(1/Math.sin(0)));
}
}
}


Link = http://www.mediafire.com/?drro1xmgm3y

http://www.mediafire.com/?xyynegigmij

Primos en un arreglo

Ahora buscaremos numeos primos en un arreglo es sencillo ya rapido solo refrescaremos que primo es aquel divisible sobre si y el 1.
/*
 * Realizar el programa que asigne a un arreglo lineal n numeros enteros
 * se pide calcular e imprimir cuantos numeros primos existen en el arreglo.
 */
package arreglos;

/**
 *
 * @author Jonathan
 */
public class arreglos1{

    public static void main(String[] args) {
        int n, i, cnp = 0, res;
        n = (int) (Math.random() * 100);
        int num[] = new int[n + 1];
        for (i = 0; i < n; i++) {
            num[i] = (int) (Math.random() * 100);
            res = 0;
            for (int j = 1; j <= num[i]; j++) {
                if (num[i] % j == 0) {
                    res++;
                }
            }
            if (res == 2) {
                cnp++;
                System.out.println("numero primo =" + num[i]);
            }

        }
        System.out.println("La cantidad de numeros primos es :" + cnp);
    }
}
Ya vimos un unidimensional tenemos la idea apliquemos al bidimensional.
/* 
* Realizar el programa que asigne aleatoriamente a un arreglo bidimensional 
* de mxn elementos datos de tipo entero, se pide calcular e imprimir cuantos 
* nùmeros primos existen en cada fila y en cada columna del arreglo. 
*/ 
package arreglos;

public class arreglos2{

    public static void main(String[] args) {
        int m, n, i, j, cnp, res;
        m = (int) (Math.random() * 10 + 2);
        n = (int) (Math.random() * 10 + 2);
        int beta[][] = new int[m + 1][n + 1];
        cnp = 0;
        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                beta[i][j] = (int) (Math.random() * 100);
                res = 0;
                for (int k = 1; k <= beta[i][j]; k++) {
                    if (beta[i][j] % k == 0) {
                        res++;
                    }
                }
                if (res == 2) {
                    cnp++;
                    System.out.println("numero primo =" + beta[i][j]);
                }

            }
        }//Fin de la generacion de filas
        System.out.println("La cantidad de numeros primos en la fila " + i + " son:" + cnp);
        for (j = 0; j < n; j++) {
            for (i = 0; i < m; i++) {
                beta[i][j] = (int) (Math.random() * 100);
                res = 0;
                for (int k = 1; k <= beta[i][j]; k++) {
                    if (beta[i][j] % k == 0) {
                        res++;
                    }
                }
                if (res == 2) {
                    cnp++;
                    System.out.println("numero primo =" + beta[i][j]);
                }

            }
        } //Fin de la generacion de columnas

        System.out.println("La cantidad de numeros primos en la columna " + j + " son:" + cnp);
    }
}
http://www.mediafire.com/?mgtybdwnjmb

Maximos y minimo en un arreglo

Como dice el nombre del paquete este fue una pregunta de examen del profe huapaya es encillo usamos la burbuja para buscar.

package examen;
public class Main {
public static void main(String[] args) {
int m,n,i,j,j1=0,max = 0,min = 0;
m=(int)(Math.random()*10);
n=24;
int emp[][] =new int [m+2][n+2];

for(i=0;i{
for(j=0;j {
emp[i][j]=(int)(Math.random()*2001+1000);
System.out.println(emp[i][j]+" "+i+" "+j);
j1=j;

while(emp[i][j1]>emp[i][j1+1] && j1!=25)
{

max=emp[i][j1];

j1=j1+1;
}

}
System.out.println("El maximo sera "+max);
System.out.println("El minimo sera "+min);
}
}
}

link = http://www.mediafire.com/?zmurf3jiliy

Java programa 4 Ordenar un arreglo

Bueno llegamos al capitulo en el cual tengamos que ordenar un arreglo a la hora de mostrar o ordenarlo fisicamente pero como lo hacemos ya que hay muchos elementos para eso esta la forma mas simple el metodo de burbuja.
Aclaro una cosa es el metodo mas simple de ordenamiento pero no es el mas eficaz con esto digo que hay veces que te pueda fallar ya que sirve mas para entender como es el ordenamiento.
Para ordenar un arreglo de forma mas eficaz esta el quick short que por asi decirlo es demasiado mas complicado. Es por ello que primero veamos esta forma para entender luego el otro.

Usamos Frame para mostrar pero si ven el metodo ordenamBurbuja( arreglo ) que es que lo hace lo podran adaptar a consola.


import java.awt.Container;
import javax.swing.JFrame;
import javax.swing.JTextArea;

/**
 *
 * @author JONATHAN PALOMINO VILCA
 */
public class Burbuja1 extends JFrame{

    public Burbuja1() {
        setSize(400, 300);
        setLocation(300, 300);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        JTextArea areaSalida = new JTextArea();
        Container contenedor = getContentPane();
        contenedor.add(areaSalida);

        int arreglo[] = {2, 6, 4, 8, 10, 12, 89, 68, 45, 37};

        String salida = "Elementos de datos en su orden original\n";

// anexar los valores originales al String salida
        for (int contador = 0; contador < arreglo.length; contador++) {
            salida += " " + arreglo[ contador];
        }

        ordenamBurbuja(arreglo); // ordenar arreglo

        salida += "\n\nElementos de datos en orden ascendente\n";

// anexar los valores ordenados del arreglo al String salida
        for (int contador = 0; contador < arreglo.length; contador++) {
            salida += " " + arreglo[ contador];
        }

        areaSalida.setText(salida);

    }
// ordenar elementos del arreglo con el método burbuja
    public void ordenamBurbuja(int arreglo2[]) {
// ciclo para controlar número de pasadas
        for (int pasada = 1; pasada < arreglo2.length; pasada++) {

// ciclo para controlar número de comparaciones
            for (int elemento = 0;
                    elemento < arreglo2.length - 1;
                    elemento++) {

// comparar elementos uno a uno e intercambiarlos si
// el primer elemento es mayor que el segundo
                if (arreglo2[ elemento] > arreglo2[ elemento + 1]) {
                    intercambiar(arreglo2, elemento, elemento + 1);
                }

            } // fin del ciclo para controlar las comparaciones

        } // fin del ciclo para controlar las pasadas

    } // fin del método ordenamBurbuja

// intercambiar dos elementos de un arreglo
    public void intercambiar(int arreglo3[], int primero, int segundo) {
        int almacen; // área temporal de almacenamiento para intercambiar

        almacen = arreglo3[ primero];
        arreglo3[ primero] = arreglo3[ segundo];
        arreglo3[ segundo] = almacen;
    }

    public static void main(String[] args) {
        Burbuja1 obj = new Burbuja1();
        obj.show();
    }
} // fin de la clase OrdenamBurbuja

Link del proyecto = http://www.mediafire.com/?yhzdmzuyymz

Java programa 3 -- Arreglos Bidimensionales

Bueno este ejemplo es para un arreglo bidimensional esta es la sumilla.
Como veran es un ejemplo sencillo donde veran como asignar numeros a un arreglo bidimensional teniendo esta idea podran hacerlo para multiples dimensiones-

/*
* Realizar un programa que asigne aleatoriamente a un arreglo de m x n (entero)
* se pide calcular e imprimir la cantidad de números
* que empiezan y terminan con las misma cifra en las dos diagonales
* principales del arreglo cuando m = n ..
*/
package arreglodiagonal;

public class arreglodiagonal {

public static void main(String[] args) {
int m,i,j,n=0,t=0,k=0,q=0,x = 0,c=0;
m=3;
int delta[][] = new int[m+1][m+1];
for (i=0;i0)
{
x=n%10; //resto
y=n/10; //cociente;
n=y;
}
System.out.println("es "+x+ " y "+t);
}
//Fin de condicional de diagonal
k=x*10+t;


}

}


System.out.println("es la cantidad de numeros que comiensan y terminan " +
"con la misma cifra en la 1° diagonal son "+c);
}
}

Link del proyecto = http://www.mediafire.com/?t4jmydh2lz0