Descarga de Ejercicios Facilitos en Java

Aqui os dejo todos los Ejercicios echos por mi de Programacion en Java para Inicializados  .

Ejercicio Mayor de 5 :

https://mega.nz/#!klgA0R6B!xdQelgpVJpRMRW7idWOyEHufxOTMIQu36VHKjM9IC04

Ejercicio Mayor Menor Igual:

https://mega.nz/#!11Q0kaDZ!L3YrTTE-XpmOIg2N7uHj40KajqSKZdxRtK8dL2Q4B7w

Ejercicio Multiplos:

https://mega.nz/#!p84g3CRZ!MoI2yjY6FLcaTZAuDnWydqOHIACzC9CbQrTiktmbOiI


 

Ejercicio Calculadora:

https://mega.nz/#!shJjUDbI!_rad0Y6lyM2SLvvPVC2VZNfQTnB-IAzW_R0zHPiX0yA

Ejercicio Capicua:

https://mega.nz/#!FkABSTSK!wZKcrgmZRl71UXLd7xEwcZSLbl_UdPnRiz1S6Jp8Jh8

Busqueda Binaria:

https://mega.nz/#!Rlhn3YpI!-yHEtmMIgKj9_WphMl5rzJCH_h0_fUOLUgZp0PlP5a8

Busqueda Lineal:

https://mega.nz/#!I4wETI6S!ywuMgyxNjGtnnMeMj7WeQDj1_y9aUXxbzrq5pJ_hY2A

Robot con Clases:

https://mega.nz/#!htgiyLyK!1UMW_N19ay6FEXfrDFtfA5PeUdoxr-XrP_A2VAqU4hM

Anstrong:

https://mega.nz/#!gkIwhSKC!_AU_KnIcmXFKuXAjmFxRMDuZcBuSUL5lmo9stjxCbGs


 

Bucle:

https://mega.nz/#!hp53QKJD!bf6TI3_tyAFY7muaJHy7IyX5xRRdYg9zNdS2D0bC3KI

Area:

https://mega.nz/#!Rtp3FYZL!cO1c_tjnoqDvvsoWHKN1keR7pI-iTcAe0FoM0oY7sT4

Cambio a Euros:

https://mega.nz/#!1gZDRAAZ!OtifSAwsrPgB3gIgJJTaRN6wL7Dx0Tnm27yfQfefSks

Cilindro:

https://mega.nz/#!IpQjjBha!tOdjfq2TPJ2ZTQUsg2fCeI7bPjUfBgWWvNchb3K-BKM

Dime tu nombre:

https://mega.nz/#!Blo10Jwb!V5jZWBDkwZoOzbthARE91UvDmFrR71IIuqFnBws3IHI

Ecuacion:

https://mega.nz/#!p8ByzL5J!TJ_f9LHUe66kvYiBoFWCSnyFay3GH8BWzPeAxCFgFwg

Euros a Pesetas:

https://mega.nz/#!9xZmkQIA!lyceGVUFuC_v3STqluVyMkmpdFSDCE9TuZ6zsnVuUYM

Hola Mundo:

https://mega.nz/#!EhZWVJgQ!mXR7l0EDkbnudDhyp3u8TLJp7D6gcamNZ7G20Jcpcgg

If Else:

https://mega.nz/#!1xoHDJAY!fnmfVCUmi66o7LjZzp6FVXeDF9YjqgLO0j2bO_K9xtE

Indice IMC:

https://mega.nz/#!B0oEnBDJ!d-1oTYGv4N5fqDH-DL_ZSXsPVlAUtK6bNL4EarP1DmU

Multiplos:

https://mega.nz/#!p84g3CRZ!MoI2yjY6FLcaTZAuDnWydqOHIACzC9CbQrTiktmbOiI

Numeros al Azar:

https://mega.nz/#!IgYyyTDa!2-hBE9whfPzjdhwya6IOT4vRp8L3RQ9kHJ5_gLj0_S0

Switch Calculadora:

https://mega.nz/#!skpQCaBZ!1CixgkmdPnDxwgDrX1gGgGiravDytaxzpW3oXxYnsNQ

 

Tutorial de Linux

Tutorial de Linux

1 Comandos de Linux
1.1 Comandos básicos
Los comandos son esencialmente los mismos que cualquier sistema UNIX. En la tablas 1
y 2 se tiene la lista de comandos mas frecuentes. En la tabla 3 se tiene una lista de
equivalencias entre comandos Unix/Linux y comandos DOS.
Comando/Sintaxis Descripción Ejemplos
cat fich1 […fichN] Concatena y muestra un archivos cat /etc/passwd
archivos cat dict1 dict2 dict
cd [dir] Cambia de directorio cd /tmp
chmod permisos fich Cambia los permisos de un archivo chmod +x miscript
chown usuario:grupo fich Cambia el dueño un archivo chown nobody miscript
cp fich1…fichN dir Copia archivos cp foo foo.backup
diff [-e]arch1 arch2 Encuentra diferencia entre archivos diff foo.c newfoo.c
du [-sabr] fich Reporta el tamaño del directorio du -s /home/
file arch Muestra el tipo de un archivo file arc_desconocido
find dir test acción Encuentra archivos.
find . -name ‘‘.bak’’ –
print
grep [-cilnv] expr
archivos
Busca patrones en archivos grep mike /etc/passwd
head -count fich Muestra el inicio de un archivo head prog1.c
mkdir dir Crea un directorio. mkdir temp
mv fich1 …fichN dir
Mueve un archivo(s) a un
directorio
mv a.out prog1
mv fich1 fich2 Renombra un archivo. mv .c prog_dir
less / more fich(s)
Visualiza página a página un
archivo.
more muy_largo.c
less acepta comandos vi. less muy_largo.c
ln [-s] fich acceso
Crea un acceso directo a un
archivo
ln -s /users/mike/.profile
.

Java Database Connectivity

1

 

 

Java Database Connectivity, más conocida por sus siglas JDBC,1 es una API que permite la ejecución de operaciones sobre base de datos desde el lenguaje de programacion en Java , independientemente del sistema operativo donde se ejecute o de la base de datos a la cual se accede, utilizando el dialecto SQL del modelo de base de datos que se utilice.

El API JDBC se presenta como una colección de interfaces Java y métodos de gestión de manejadores de conexión hacia cada modelo específico de base de datos. Un manejador de conexiones hacia un modelo de base de datos en particular es un conjunto de clases que implementan las interfaces Java , y que utilizan los métodos de registro para declarar los tipos de localizadores a base de datos (URL) que pueden manejar. Para utilizar una base de datos particular, el usuario ejecuta su programa junto con la biblioteca de conexión apropiada al modelo de su base de datos, y accede a ella estableciendo una conexión; para ello provee el localizador a la base de datos y los parámetros de conexión específicos. A partir de allí puede realizar cualquier tipo de tarea con la base de datos a la que tenga permiso: consulta, actualización, creación, modificación y borrado de tablas, ejecución de procedimientos almacenados en la base de datos, etc.

Aqui un ejemplo de codigo de como conectar con la Base de Datos :

1

 

1

//  Estableciendo  connection to a mSQL database using JDBC. 
import java.sql.*; 

class JdbcTest1 { 

  public static void main (String[] args) { 
    try
    {
      // Step 1: Load the JDBC driver. 
      Class.forName("com.imaginary.sql.msql.MsqlDriver"); 
      // Step 2: Establish the connection to the database. 
      String url = "jdbc:msql://www.myserver.com:1114/contact_mgr"; 
      Connection conn = DriverManager.getConnection(url,"user1","password");  
    }
    catch (Exception e)
    {
      System.err.println("Got an exception! "); 
      System.err.println(e.getMessage()); 
    } 
  } 
} 


Bibliografia :

http://es.wikipedia.org/wiki/Java_Database_Connectivity

 

Hash Table

1

 

 

Una hashtable es una estructura de datos que utiliza una función hash para identificar datos mediante una llave o clave (ej. Nombre de una persona).

La función hash transforma una llave a un valor índice de un arreglo de elementos. En este caso a una índice de nuestra hashtable .

1

 

Miraque el identificador será el que hace referencia a los datos en este caso solo será un nombre, para este caso haremos un pequeño ejemplo en java donde solo manejaremos una clase la cual tendrá las siguientes propiedades: un objeto de tipo hash con sus respectivos métodos, los elementos de la tabla y finalmente el main dentro de la misma clase

Lo primero será definir una variable contenedor para instanciar la clase hashtable  Java:

Hashtable<String,String> contenedor=new Hashtable<String,String>();

 

Nos vamos a ayudar del método .put(); para insertar elementos dentro de la hashtable :

  1. contenedor.put(“101”, “Harry”);
  2. contenedor.put(“102”, “Potter”);
  3. contenedor.put(“103”, “IRONMAN”);
  4. contenedor.put(“104”, “IRONMAN”);
  5. contenedor.put(“105”, “HALLO”);

 

El primer elemento será la clave y el segundo será el valor a almacenar.

Si queremos obtener un valor de la hashtable  tendremos que pasarle al método .get(); la clave que queremos recuperar:

  1. System.out.println(contenedor.get(“105”));
  2. System.out.println(contenedor.get(“101”));

Mediante un Enumeration vamos a recorrer el contenido de nuestra Hashtable Java:

  1. Enumeration<String> enumeration = contenedor.elements();
  2. while (enumeration.hasMoreElements()) {
  3. System.out.println(“”+”hashtable valores: ” + enumeration.nextElement());
  4. }

Si queremos saber cuales son las claves de la hashtable  usamos el método .keys();

  1. Enumeration<String> llaves = contenedor.keys();
  2. while (llaves.hasMoreElements()) {
  3. System.out.println(“”+”hashtable llaves: ” + llaves.nextElement());
  4. }

También se puede obtener la enumeración de todas las claves mediante el uso del método .keys();

  1. System.out.println(“Claves: ” +contenedor.keys());

 

Bibliografia:

http://lineadecodigo.com/java/usar-una-hashtable-java/

 

Java Exceptions


exception-hierarchy-in-java

 

 

Los programadores de cualquier lenguaje se esfuerzan por escribir programas libres de errores, sin embargo, es muy difícil que los programas reales se vean libres de ellos.

En Java las situaciones que pueden provocar un fallo en el programa se denominan excepciones.

Java lanza una excepción en respuesta a una situación poco usual. El programador también puede lanzar sus propias excepciones.

Las excepciones en Java son objetos de clases derivadas de la clase base Exception.

Existe toda una jerarquía de clases derivada de la clase base Exception. Estas clases derivadas se ubican en dos grupos principales:

Las excepciones en tiempo de ejecución ocurren cuando el programador no ha tenido cuidado al escribir su código.

Por ejemplo, cuando se sobrepasa la dimensión de un array se lanza una excepción ArrayIndexOutOfBounds.

Cuando se hace uso de una referencia a un objeto que no ha sido creado se lanza la excepción NullPointerException.

Estas excepciones le indican al programador que tipos de fallos tiene el programa y que debe arreglarlo antes de proseguir.

El segundo grupo de excepciones, es el más interesante, ya que indican que ha sucedido algo inesperado o fuera de control.

Manejando varias excepciones

public class ExcepcionApp {
    public static void main(String[] args) {
        String str1="12";
	String str2="0";
        String respuesta;
	int numerador, denominador, cociente;
        try{
            numerador=Integer.parseInt(str1);
            denominador=Integer.parseInt(str2);
            cociente=numerador/denominador;
            respuesta=String.valueOf(cociente);
        }catch(NumberFormatException ex){
            respuesta="Se han introducido caracteres no numéricos";
        }catch(ArithmeticException ex){
            respuesta="División entre cero";
        }
        System.out.println(respuesta);
    }
}

Como vemos las sentencias susceptibles de lanzar una excepción se sitúan en un bloque trycatch. Si el denominador es cero,

se produce una excepción de la clase ArithmeticException en la expresión que halla el cociente, que es inmediatamente capturada en el bloque catch

que maneja dicha excepción, ejecutándose las sentencias que hay en dicho bloque. En este caso se guarda en el string respuesta el texto “División entre cero”.

AD_Practica10_xml

xml

 

El objetivo de esta práctica es añadir una entrada a la cartera de los archivos relacionados con el tratamiento

en formato XML en JAVA.

• Explicar qué es un archivo XML

La tecnología XML busca dar solución al problema de expresar información estructurada de la manera

más abstracta y reutilizable posible. Que la información sea estructurada quiere decir que se compone

de partes bien definidas, y que esas partes se componen a su vez de otras partes. Entonces se tiene un

árbol de pedazos de información. Ejemplos son un tema musical, que se compone de compases, que

están formados a su vez con notas. Estas partes se llaman elementos, y se las señala mediante etiquetas.

Una etiqueta consiste en una marca hecha en el documento, que señala una porción de este como un

elemento. Un pedazo de información con un sentido claro y definido.
Teniendo en cuenta esta definición podremos definir un XML para una lista de temas musicales de

esta manera: Tanto MUSICA como tema son ambas etiquetas!

1

 

Continuar leyendo “AD_Practica10_xml”

Lectura y Escritura de Ficheros en Java

 

Podemos abrir un fichero de texto para leer usando la clase FileReader. Esta clase tiene métodos que nos permiten leer

caracteres. Sin embargo, suele ser habitual querer las líneas completas, bien porque nos interesa la línea completa, bien

para poder analizarla luego y extraer campos de ella. FileReader no contiene métodos que nos permitan leer líneas

completas, pero sí BufferedReader. Afortunadamente, podemos construir un BufferedReader a partir del FileReader

de la siguiente forma:

Principalmente voy a explicar los metodos que vamos a utilizar en este Proyecto.

Para poder Escribir en el Archivo utilizaremos :

  • File: para comprobar si existe el fichero especificado.
  • FileWriter: para especificar el archivo en el que se va a escribir.
  • PrintWriter: te permite escribir cosas, por ejemplo en archivos, te genera el archivo nuevo, y en caso de que
  • exista te lo sustituye.

 

Para Leer archivos :

  •   File: para comprobar si existe el fichero especificado.
  • FileReader : Nos va a servir para Leer el fichero.
  • BufferedReader: combierte la cadena de texto en un flujo de datos.

Continuar leyendo “Lectura y Escritura de Ficheros en Java”

Lectura y Escritura de Ficheros en Java

 

Hola a todos, hoy os explicare como podemos manejar las clases FileReader y FileWritter para ficheros de texto en Java.

Las clases FileReader y FileWriter permiten leer y escribir, respectivamente, en un fichero.

Lo primero que debemos hacer es importar estas clases y las que controlan las excepciones.

Después debemos crear un objeto de alguna de estas clases. Se pueden construir con un objeto File, FileDescriptor o un String. Nosotros usaremos este último.

Al crear un objeto de estas clases, deben estar dentro de un try-catch.

Recuerda que debemos controlar las excepciones.

Cuando creamos un objeto, abrimos un stream entre nuestro programa y el exterior, cuando debemos de usarlo debemos cerrar el stream con el método close().

Veamos un ejemplo, de creación de los objetos, también cerramos los streams:

1
2
FileWriter fw=new FileWriter("D:\\fichero1.txt");
FileReader fr=new FileReader("D:\\fichero1.txt");

Como vemos, escribimos la ruta del fichero. Si usas FileWriter y escribes una ruta de fichero que no existe lo crea, para FileReader si que debe existir el fichero, sino lanzara una excepción. Usamos doble barra (\\) por que es un carácter de escape, para poner \.

Ahora vamos a ver como escribir y leer texto en el fichero.

Continuar leyendo “Lectura y Escritura de Ficheros en Java”

ArrayList en Java && String tokenizer.

En esta Sección os voy hablar de dos métodos en Java .

ArrayList en Java

 

 

La clase ArrayList en Java, es una clase que permite almacenar datos en memoria de forma similar a los Arrays, con la ventaja de que el

numero de elementos que almacena, lo hace de forma dinámica, es decir, que no es necesario declarar su tamaño como pasa con los Arrays.

Es decir, un ArrayList puede contener objetos de tipos distintos.

En este ejemplo, el primer objeto que se añade es el String “Lenguaje”. El resto no son objetos. Son datos de tipos básicos pero el compilador los convierte automáticamente en objetos de su clase envolvente (clase contenedora o wrapper) antes de añadirlos al array.

Un array al que se le pueden asignar elementos de distinto puede tener alguna complicación a la hora de trabajar con él. Por eso, una alternativa a esta declaración es indicar el tipo de objetos que contiene. En este caso, el array solo podrá contener objetos de ese tipo.

 

 

Continuar leyendo “ArrayList en Java && String tokenizer.”