elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Sigue las noticias más importantes de seguridad informática en el Twitter! de elhacker.NET


  Mostrar Mensajes
Páginas: [1]
1  Programación / Java / Re: Java en Linux en: 11 Septiembre 2009, 11:17 am
Buenas

Nosotros en la uni, almenos en la asignatura de Elementos de Programación, lo hicimos todo en Vim y programemos con Python y Java. Personalmente es bueno no empezar directamente a programar con Ide's cuando uno es novato, ya que no se pueden aprender muchas cosas que el mismo Ide hace automáticamente, como compilar el código, ejecutarlo, crear jar's, crear documentación, etc.

Así que para Linux, búscate un buen editor primero (recomiendo Vim) e instala el JDK y JRE. Más adelante, cuando los programas se vayan haciendo mas extensos y complicados, te darás cuenta que hace falta algo "más profesional". Entonces usa un Ide (Netbeans o Eclipse).

Espero haber sido de ayuda!

Saludos!
2  Programación / Java / Re: Cargar y guardar datos en un archivo .txt localizado dentro de un fichero .jar en: 3 Septiembre 2009, 16:23 pm
No he encontrado solución. Veo que es mas fácil y mejor que el fichero se guarde fuera del archivo jar y en la misma carpeta donde se encuentra este. Mas adelante ya me encargaré de hacer alguna clase que encripte los datos para que no puedan ser descifrados simplemente abriendo el .txt

Saludos!
3  Programación / Java / Cargar y guardar datos en un archivo .txt localizado dentro de un fichero .jar en: 3 Septiembre 2009, 13:28 pm
Saludos a todos!

Estoy desarrollando una especie de agenda que almacena todos los eventos dentro de un fichero txt. Lo estoy programando sobre NetBeans y todo funciona perfectamente hasta que creo el fichero .jar. Es aqui donde empieza el problema, ya que las rutas son diferentes. Sobre NetBeans es : "src/archivos/lista.txt" pero una vez creado el jar no puedo acceder a esa ruta, ya que es diferente. La carpeta src no existe y ademas no he conseguido entrar a la carpeta archivos dentro del jar.

Buscando por internet he encontrado soluciones para acceder al fichero y leerlo. Esto ahora mismo funciona perfectamente dentro de NetBeans y con el .jar:

Código
  1. String ruta = "lista.mem";
  2. URL fileURL = Main.class.getResource(ruta);
  3. BufferedReader br = new BufferedReader(new InputStreamReader(fileURL.openStream()));
  4. String linea = br.readLine();
  5.  

Ahora quisiera saber como poder guardar la informacion dentro del mismo archivo. De momento tengo una parte,pero no se como meter o escribir en este:

Código
  1. String ruta = "lista.mem";
  2. URL fileURL = Main.class.getResource(ruta);
  3. BufferedWriter br = new BufferedWriter(new OutputStreamWriter(fileURL.openStream()));
  4. // ^ en esta linea tengo el problema...
  5.  

Espero que me podais dar alguna solución, si no, me decantaré por pasar la ruta del archivo por los argumentos del programa.

Gracias por adelantado ;)

4  Programación / Java / Re: Problema con buffer en: 19 Agosto 2009, 00:55 am
Pregunta: la variable directorioEmoticones, de que tipo es? Porque no la veo declarada por ningún lado. En todo caso, prueba a poner o crear fuera de la comprobación 'try' la declaración del tipo:

Código
  1. public void getContenido(){
  2.        String directorioEmoticones = null;
  3.        try {
  4.            br = new BufferedReader(new FileReader("//home//debci//Escritorio//debci.cfg"));
  5.            try {
  6.                directorioEmoticones = br.readLine();
  7.            } catch (IOException ex) {
  8.                Logger.getLogger(LecturaArchivosView.class.getName()).log(Level.SEVERE, null, ex);
  9.            }
  10.        } catch (FileNotFoundException ex) {
  11.            Logger.getLogger(LecturaArchivosView.class.getName()).log(Level.SEVERE, null, ex);
  12.        }
  13.  
  14.    System.out.println("El directorio marcado es: " + directorioEmoticones);
  15. }

No he probado a compilar, pero puede ser la solución al problema :)

Quizás te pueda servir esta clase de un programa mio que accede a un fichero para leer datos:

Código
  1. /*
  2.  *  Copyright (C) 2009 Juan Carlos Ortega <juancarloslinux@gmail.com>
  3.  */
  4. package biorritmos;
  5.  
  6. import java.io.*;
  7.  
  8. /**
  9.  * Clase Documentacion
  10.  *
  11.  * Esta clase se encarga de informar al usuario informacion acerca del programa.
  12.  *
  13.  * @author juancarlos <JmpNull>
  14.  */
  15. public class Documentacion {
  16.  
  17.    // Atributos
  18.    private static final String ruta = "src/biorritmos/doc.txt";
  19.  
  20.    // Constructor
  21.    public Documentacion() {
  22.  
  23.        File archivo = null;
  24.        FileReader fr = null;
  25.        BufferedReader br = null;
  26.  
  27.        try {
  28.            // Apertura del fichero y creacion de BufferedReader para poder
  29.            // hacer una lectura comoda (disponer del metodo readLine()).
  30.            archivo = new File(ruta);
  31.            fr = new FileReader(archivo);
  32.            br = new BufferedReader(fr);
  33.  
  34.            // Lectura del fichero
  35.            String linea;
  36.            while ((linea = br.readLine()) != null) {
  37.                // Lectura de una sola linea
  38.                System.out.println(linea);
  39.            }
  40.        } catch (Exception e) {
  41.            e.printStackTrace();
  42.        } finally {
  43.            // En el finally cerramos el fichero, para asegurarnos
  44.            // que se cierra tanto si todo va bien como si salta
  45.            // una excepcion.
  46.            try {
  47.                if (null != fr) {
  48.                    fr.close();
  49.                }
  50.            } catch (Exception e2) {
  51.                e2.printStackTrace();
  52.            }
  53.        }
  54.    }    
  55. }
  56.  
5  Programación / Java / Clase para interactuar con el usuario mediante interfaz gráfica simple en: 17 Agosto 2009, 22:38 pm
Buenas!

Como últimamente me aburro bastante (hasta empezar otra vez la uni en 2o curso de Ingeniería Informática ;D), hoy he programado una clase estática que sirve para mostrar y recibir datos mediante simples mensajes por pantalla. Es muy simple, pero bastante útil a la hora de hacer programas simples o pedir datos en un cierto momento. Respetando el modelo MVC, es estática simplemente porque la interfaz de interacción con el usuario (en la mayoría de casos) tiene que ser independiente del programa para poder implementar el software en consola, web, etc. Espero que sirva de ayuda y os sea de interés!

Próximamente subiré algunos programas que he hecho durante estos casi 3 meses de vacaciones (lo que hace el aburrimiento  :xD).

Saludos a todos! :)

Nombre de la clase: SimpleGui.java

Código
  1. /*
  2.  * Copyright 2009 Juan Carlos <juancarloslinux@gmail.com>
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify
  5.  * it under the terms of the GNU General Public License as published by
  6.  * the Free Software Foundation; either version 2 of the License, or
  7.  * (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  17.  * MA 02110-1301, USA.
  18.  */
  19.  
  20. import javax.swing.JOptionPane;
  21. import javax.swing.JTextArea;
  22.  
  23. /**
  24.  * Clase estatica para pedir datos mediante interfaz grafica simple.
  25.  *
  26.  * @author JmpNull
  27.  */
  28. public class SimpleGui {
  29.  
  30.    /**
  31.      * Este metodo se encarga de leer un objeto Integer.
  32.      *
  33.      * @param mensaje El mensaje que va a mostrar
  34.      * @return El valor de retorno
  35.      */
  36.    public static Integer getInteger(String mensaje) {
  37.        Integer i = null;
  38.        boolean valido = false;
  39.        while (!valido) {
  40.            try {
  41.                i = Integer.parseInt(JOptionPane.showInputDialog(mensaje));
  42.                valido = true;
  43.            } catch (NumberFormatException e) {
  44.                printError("La entrada no es valida");
  45.                i = null;
  46.            }
  47.        }
  48.        return i;
  49.    }
  50.  
  51.    /**
  52.      * Este metodo se encarga de leer un objeto Double.
  53.      *
  54.      * @param mensaje El mensaje que va a mostrar
  55.      * @return El valor de retorno
  56.      */
  57.    public static Double getDouble(String mensaje) {
  58.        Double i = null;
  59.        boolean valido = false;
  60.        while (!valido) {
  61.            try {
  62.                i = Double.parseDouble(JOptionPane.showInputDialog(mensaje));
  63.                valido = true;
  64.            } catch (NumberFormatException e) {
  65.                printError("La entrada no es valida");
  66.                i = null;
  67.            }
  68.        }
  69.        return i;
  70.    }
  71.  
  72.    /**
  73.      * Este metodo se encarga de leer un objeto Float.
  74.      *
  75.      * @param mensaje El mensaje que va a mostrar
  76.      * @return El valor de retorno
  77.      */
  78.    public static Float getFloat(String mensaje) {
  79.        Float i = null;
  80.        boolean valido = false;
  81.        while (!valido) {
  82.            try {
  83.                i = Float.parseFloat(JOptionPane.showInputDialog(mensaje));
  84.                valido = true;
  85.            } catch (NumberFormatException e) {
  86.                printError("La entrada no es valida");
  87.                i = null;
  88.            }
  89.        }
  90.        return i;
  91.    }
  92.  
  93.    /**
  94.      * Este metodo se encarga de leer un objeto Character.
  95.      *
  96.      * @param mensaje El mensaje que va a mostrar
  97.      * @return El valor de retorno
  98.      */
  99.    public static Character getCharacter(String mensaje) {
  100.        Character salida = null;
  101.        boolean valido = false;
  102.        while (!valido) {
  103.            String valor = JOptionPane.showInputDialog(mensaje);
  104.  
  105.            if (valor.length() == 0) {
  106.                salida = ' ';
  107.                valido = true;
  108.            } else if (valor.length() == 1) {
  109.                salida = valor.charAt(0);
  110.                valido = true;
  111.            } else {
  112.                printError("La entrada no es valida");
  113.            }
  114.        }
  115.        return salida;
  116.    }
  117.  
  118.    /**
  119.      * Este metodo se encarga de mostrar al usuario un mensaje de pregunta.
  120.      *
  121.      * @param entrada El mensaje de pregunta
  122.      * @return El resultado
  123.      */
  124.    public static Integer getQuestion(String entrada) {
  125.        return JOptionPane.showConfirmDialog(null, entrada);
  126.        // 0 para yes
  127.        // 1 para no
  128.        // ? para cancel o x
  129.    }
  130.  
  131.    /**
  132.      * Este metodo se encarga de leer un objeto String.
  133.      *
  134.      * @param mensaje El mensaje que va a mostrar
  135.      * @return El valor de retorno
  136.      */
  137.    public static String getString(String mensaje) {
  138.        return JOptionPane.showInputDialog(mensaje);
  139.    }
  140.  
  141.    /**
  142.      * Este metodo muestra por pantalla un mensaje de tipo texto plano.
  143.      *
  144.      * @param entrada El mensaje a mostrar
  145.      */
  146.    public static void printPlain(String entrada) {
  147.        JOptionPane.showMessageDialog(null, entrada, "Salida",
  148.                JOptionPane.PLAIN_MESSAGE);
  149.    }
  150.  
  151.    /**
  152.      * Este metodo muestra por pantalla un mensaje de tipo error.
  153.      *
  154.      * @param entrada El mensaje a mostrar
  155.      */
  156.    public static void printError(String entrada) {
  157.        JOptionPane.showMessageDialog(null, entrada, "Error",
  158.                JOptionPane.ERROR_MESSAGE);
  159.    }
  160.  
  161.    /**
  162.      * Este metodo muestra por pantalla un mensaje de tipo pregunta.
  163.      *
  164.      * @param entrada El mensaje a mostrar
  165.      */
  166.    public static void printQuestion(String entrada) {
  167.        JOptionPane.showMessageDialog(null, entrada, "Salida",
  168.                JOptionPane.QUESTION_MESSAGE);
  169.    }
  170.  
  171.    /**
  172.      * Este metodo muestra por pantalla un mensaje de tipo informativo.
  173.      *
  174.      * @param entrada El mensaje a mostrar
  175.      */
  176.    public static void printInformation(String entrada) {
  177.        JOptionPane.showMessageDialog(null, entrada, "Salida",
  178.                JOptionPane.INFORMATION_MESSAGE);
  179.    }
  180.  
  181.    /**
  182.      * Este metodo muestra por pantalla un mensaje de tipo aviso.
  183.      *
  184.      * @param entrada El mensaje a mostrar
  185.      */
  186.    public static void printWarning(String entrada) {
  187.        JOptionPane.showMessageDialog(null, entrada, "Salida",
  188.                JOptionPane.WARNING_MESSAGE);
  189.    }
  190.  
  191.    /**
  192.      * Este metodo muestra por pantalla un mensaje dentro de un objeto
  193.      * JTextArea.
  194.      *
  195.      * @param entrada El objeto JTextArea
  196.      */
  197.    public static void println(JTextArea entrada) {
  198.        JOptionPane.showMessageDialog(null, entrada);
  199.    }    
  200.  
  201.    /**
  202.      * Este metodo muestra por pantalla un mensaje de tipo estandar.
  203.      *
  204.      * @param entrada El mensaje a mostrar
  205.      */
  206.    public static void println(String entrada) {
  207.        JOptionPane.showMessageDialog(null, entrada);
  208.    }    
  209.  
  210.    // IDEM
  211.    public static void println(Integer entrada) {
  212.        JOptionPane.showMessageDialog(null, String.valueOf(entrada));
  213.    }
  214.  
  215.    public static void println(Double entrada) {
  216.        JOptionPane.showMessageDialog(null, String.valueOf(entrada));
  217.    }
  218.  
  219.    public static void println(Float entrada) {
  220.        JOptionPane.showMessageDialog(null, String.valueOf(entrada));
  221.    }
  222.  
  223.    public static void println(Character entrada) {
  224.        JOptionPane.showMessageDialog(null, String.valueOf(entrada));
  225.    }
  226. }
  227.  
  228.  

6  Programación / Programación C/C++ / Re: Video Tutorial Programacion C++ en: 5 Agosto 2009, 00:13 am
Muy buen aporte! Son simplemente geniales!

Saludos!
Páginas: [1]
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines