Código de Java - Reproductor de imágenes

Imágen de perfil
Val: 491
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Reproductor de imágenesgráfica de visualizaciones


Java

estrellaestrellaestrellaestrellaestrella(1)
Publicado el 11 de Mayo del 2018 por Rafael Angel
1.125 visualizaciones desde el 11 de Mayo del 2018. Una media de 21 por semana
Para que puedas reproducir tus imagenes favoritas y practiques el uso de imagenes.
Lo que no me gusta es que las imagenes deben estar en la misma carpeta de la app o del class que los cargue.
Debes cambiar el nombre de direccion.
Asi mismo, usé la habilidad de copiar los archivos para pasarlos a la carpeta.
No es perfecto, es solo una ejemplificasion para quien quiera mejorarlo y republicarlo.

Requerimientos

NetBeans

1.0
estrellaestrellaestrellaestrellaestrella(1)

Publicado el 11 de Mayo del 2018gráfica de visualizaciones de la versión: 1.0
1.126 visualizaciones desde el 11 de Mayo del 2018. Una media de 21 por semana
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

Permite copiar archivos, permite saberse el nombre y la extencion de las imagenes en la carpeta, permite cargar imagenes y reproducirlas.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
import javax.swing.JPanel;
import java.awt.Graphics;
import java.awt.Image;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.channels.FileChannel;
 
import java.io.File;
import java.util.ArrayList;
 
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import pnl_programasion_neurolinguistica.Contenedor_de_imagen;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
 
 
/**
 *
 * @author Rafael Angel Montero Fernández.
 */
public class Reproductor_de_imagenes {
 
    /**
     * @param args Para la linea de comandos.
     */
    public static void main(String[] args)
    {
        frmReproductor_de_imagenes frm=new frmReproductor_de_imagenes();
        frm.show();
    }
 
}
 
 
/*
Esta clase es para copiar las imagenes de una carpeta externa hacia la carpeta de recursos.
 */
class Copiar_archivos
{
    /**
     * Copia todos los archivos hacia la carpeta destino.
     * Ademas, si se copian los archivos dentro del mismo origen entonces se borra su contenido quedando solo los archivos en blanco con su nombre y su formato.
     * @param carpeta_origen Es la direccion de la carpeta de origen.
     * @param carpeta_destino Es la direccion de la carpeta de destino.
     */
    public void copiar_todos_los_archivos(String nueva_carpeta_origen, String nueva_carpeta_destino)
    {
        try
        {
            File carpeta_origen=new File(nueva_carpeta_origen);
            File carpeta_destino=new File(nueva_carpeta_destino);
            if(carpeta_origen.isDirectory()==true)
            {
                if(!carpeta_destino.exists()==true)
                {
                    carpeta_destino.mkdir();
                } //if
 
                String []lista_de_archivos=carpeta_origen.list();
                for(int i=0; i<lista_de_archivos.length-1; i++)
                {
                    if( (lista_de_archivos[i].endsWith(".jpg")) || (lista_de_archivos[i].endsWith(".png")) || (lista_de_archivos[i].endsWith(".bmp")) || (lista_de_archivos[i].endsWith(".gif")) )
                    {
                        //System.out.println("Copiando " + lista_de_archivos[i]);
                        copiar_un_archivo(new File(carpeta_origen, lista_de_archivos[i]), new File(carpeta_destino, lista_de_archivos[i]));
                    }//if
                } //for
            } //if
            else
            {
                copiar_un_archivo(carpeta_origen, carpeta_destino);
            } //else
        }catch(Exception ex)
        {
            System.out.println("Hay errores\n" + ex);
        } //catch
    } //copiar_todos_los_archivos
 
    /**
     * Copia un archivo a la vez hacia la carpeta destino.
     * Es una matriz.
     * @param mOrigen_destino Es la direccion de la carpeta de origen y la de destino, con el nombre de archivo.
     * 
     */    
    public void copiar_un_archivo(String mOrigen_destino[])
    {
        File carpeta_origen=new File(mOrigen_destino[0]), carpeta_destino=new File(mOrigen_destino[1]);
        copiar_un_archivo(carpeta_origen, carpeta_destino);
    }
 
 
    /**
     * Copia un archivo a la vez hacia la carpeta destino.
     * @param carpeta_origen Es la direccion de la carpeta de origen, con el nombre de archivo.
     * @param carpeta_destino Es la direccion de la carpeta de destino, con el nombre de archivo.
     */
    public void copiar_un_archivo(File carpeta_origen, File carpeta_destino)
    {
 
           /* Thread t=new Thread()
            {
                @Override
                public void run()
                {//*/
        try
        {
            //System.out.println("carpeta_origen " + carpeta_origen + "\ncarpeta_destino " + carpeta_destino);
            FileChannel in=(new FileInputStream(carpeta_origen).getChannel());
            FileChannel out=(new FileOutputStream(carpeta_destino).getChannel());
            in.transferTo(0, carpeta_origen.length(), out);
            in.close();
            out.close();

        }catch(Exception ex)
        {
            System.out.println("Hay errores\n" + ex);
        } //catch
               /* } //run
            };//*/

    } //copiar_un_archivo
} //Copiar_archivos


/*
Clase designada para listar los nombres de imagenes.
 */
 
class Nombres_de_archivos
{
 
    /**
     * Es el simbolo \ llamado slash.
     */
    public final String slash="\\";//Sirve para obtener toda la ruta.
    //Esta propiedad carga la carpeta, la lista de archivos.
    //Se hace desde aqui ya que en tiempo de ejecucion puede que se recargue la propiedad.
    private String ruta="";
 
    /**
     *
     * @param nueva_ruta para pasarle la nueva ruta del archivo. Debe ser la misma carpeta donde se compilo el programa.
     */
    public void setRuta(String nueva_ruta)
    {
        this.ruta=nueva_ruta;
        this.carpeta=new File(this.ruta);
        this.file_lista_de_archivos=carpeta.listFiles();
        setLista_de_archivos();
    }//setRuta
 
    /**
     *
     * @return retorna la ruta del archivo, o sea el nombre de carpeta con la direccion completa.
     */
    public String getRuta()
    {
        return this.ruta;
    }
 
    //Con esta propiedad se pueden obtener uno a uno los nombres de los archivos. Pero con todo y extencion.
    //lista_de_archivos no se pueden agregar directamente los nombres de archivos porque si hay archivos con otros formatos esto causaria espacios nulos en el vector. La solucion será un ArrayList.
    private String lista_de_archivos[];
    //Se usa un ArrayList porque hay archivos que no cumplen con el formato, entonces el conteo sigue, esta es la solucion.
    private ArrayList array_imagenes=new ArrayList();
 
    /**
     * Inicializa la lista de todas las imagenes contenidas en la carpeta donde se compiló el programa.
     */
    public void setLista_de_archivos()
    {
        try
        {
           //Cargando la lista.
            int i=0;
            for(i=0; i<=file_lista_de_archivos.length-1; i++)
            {
                if( (file_lista_de_archivos[i].getName().endsWith(".jpg")) || (file_lista_de_archivos[i].getName().endsWith(".png")) || (file_lista_de_archivos[i].getName().endsWith(".bmp")) || (file_lista_de_archivos[i].getName().endsWith(".gif")) )
                {
                    array_imagenes.add(file_lista_de_archivos[i].getName());
                }//if
                else
                {
                    //this.lista_de_archivos[i]="";//Por el momento. Pero luego se usará un metodo aleatorio para obtener una imagen de alguno de los archivos.
                }
            }//for
            lista_de_archivos=new String[array_imagenes.size()-1];
            for(i=0; i<=array_imagenes.size()-1; i++)
            {
                this.lista_de_archivos[i]=array_imagenes.get(i).toString();
                //System.out.println(this.lista_de_archivos[i]);
            } //for
        }catch(Exception ex){}
    }//set
 
    /**
     *
     * @return retorna un vector con toda la lista de imagenes, incluyendo su extencion.
     */
    public String []getLista_de_archivos()
    {
        //System.out.println(lista_de_archivos[0]);
        return this.lista_de_archivos;
    }//get
 
    private File carpeta=null;//Se carga en setRuta.
    File []file_lista_de_archivos=null;//Se carga en setRuta.
 
    /**
     *
     * @param nueva_ruta Ruta donde se deben encontrar las imagenes, debe ser la misma del proyecto.
     */
    public Nombres_de_archivos(String nueva_ruta )
    {
        setRuta(nueva_ruta);
    }//Constructor
 
    /**
     *
     * @param id_de_la_imagen indice del nombre de la imagen en el vector.
     * @return retorna el nombre de la imagen con la direccion completa de la carpeta.
     */
    public String getImagen_con_direccion_completa(int id_de_la_imagen)
    {
        try
        {
            return this.carpeta + this.slash + this.getLista_de_archivos()[id_de_la_imagen];
        }catch(Exception ex)
        {
            //Este error solo sucede en caso de no haber ninguna imagen cargada.
        }
        return "";//No habia imagenes cargadas.
    } //getImagen_con_direccion_completa
}//Nombres_de_archivos
 
 
/*
Nota importante, las imagenes deben estar en la misma carpeta del proyecto.
En la carpeta donde estan los archivos .java.
No es portable.
Aqui la tactica será una funcion que copie primero todas las imagenes a la carpeta absoluta y luego que las reproduzca.

 */
 
class Contenedor_de_imagen extends JPanel
{
 
 
    /**
     * Este constructor sirve para un cargado rapido.
     */
    public Contenedor_de_imagen()
    {
        this.setSize(500, 400);
    } //Constructor
 
    //Este otro es para insertar la ruta de una vez.
 
    /**
     * Es un constructor con 3 parametros.
     * @param nueva_ruta Una nueva ruta de alguna carpeta, pero esta debe ser la misma donde se compilo el programa.
     * @param nuevo_ancho Nuevo ancho del objeto.
     * @param nuevo_alto Nuevo alto del objeto.
     */
        public Contenedor_de_imagen(String nueva_ruta, int nuevo_ancho, int nuevo_alto)
    {
        this.setSize(nuevo_ancho, nuevo_alto);
        setRuta(nueva_ruta);
        this.archivos.setLista_de_archivos();
    } //Constructor
 
    private String vImagen="";
 
    /**
     * Repinta la imagen en la pantalla.
     */
    public void repintar()
    {
        repaint();
    }//repintar
 
    @Override
    public void paint(Graphics nuevo_grafico)
    {
        graficar(nuevo_grafico,this.vImagen);
    }//paint
 
 
    private Image img=null;//Es mejor la varaible Image porque se carga de una vez.
 
    /**
     *
     * @param nuevo_grafico se pasa un nuevo grafico por medio de ImageIcon
     * @param nombre_de_la_imagen se pasa el nombre de la nueva imagen.
     */
    public void graficar(Graphics nuevo_grafico,String nombre_de_la_imagen)
    {
        try
        {
        //System.out.println(nombre_de_la_imagen);
        img=new ImageIcon(getClass().getResource(nombre_de_la_imagen)).getImage();//ImageIcon(getClass().getResource(nombre_de_la_imagen));
        nuevo_grafico.drawImage(img,0,0,this.getWidth(),this.getHeight(),null);//(imagen,0,0,this);
        repintar();
        }catch(Exception ex)
        {
            //System.out.println("Errores con graficar\n"+ex);
        }
    }//graficar
 
    /**
     * Clase interna para la secuencia de imagenes a la velocidad que uno quiera.
     */
         public class Hilos  extends Thread
     {
        @Override
        public void run()
        {
            try
            {
            while(true)
            {
                for(int i=0;i<=archivos.getLista_de_archivos().length-1;i++)
                {
                    //Se usa esta para no copiar los archivos en la misma carpeta de la app.
                    vImagen=archivos.getLista_de_archivos()[i];//Solo se pueden cargar las imagenes que esten en la misma carpeta.
                    //System.out.println(archivos.getImagen_con_direccion_completa(i));
                    repaint();
                    try{sleep(500);}catch(Exception ex){}
                }//for
            }//while
           }catch(Exception ex)
           {
                System.out.println(ex.getCause() +"\nDebes conseguirte imagenes con formato jpg o cualquier otro formato, copiarlas a la carpeta donde esta este archivo.\nLuego cambiarles el nombre de la siguiente manera:\n0.jpg, 1.jpg, 2.jpg, 3.jpg");
           }//catch
        }//run
     }//class Hilos
 
    /**
     * Inicia la reproduccion de hilos.
     * Inicializa el class de los hilos o threads, y empieza la reproduccion.
     */
         public void iniciar_reproduccion()
     {
         Hilos h=new Hilos();
         h.start();
     } //iniciar_reproduccion
 
    private Nombres_de_archivos archivos=null;
 
    /**
     *
     * @param nueva_ruta obtiene la ruta del archivo. Aunque he visto que los archivos deben estar en la misma carpeta.
     */
    public void setRuta(String nueva_ruta)
    {
        this.archivos=new Nombres_de_archivos(nueva_ruta);
        this.archivos.setLista_de_archivos();//Se inicializa el cargado de imagenes de una vez.
    }//setRuta
 
    /**
     *
     * @return Retorna la ruta del archivo.
     */
    public String getRuta()
    {
        return this.archivos.getRuta();
    }
} //Contenedor_de_imagen
 
 
/*
Este es el form donde se cargaran las imagenes por medio de los threads. Y de otros objetos.
 */
 
class frmReproductor_de_imagenes extends JFrame implements ActionListener
{
    private JMenuBar jmb=new JMenuBar();
    private JMenu jmArchivo=new JMenu("Archivo");
    private JMenuItem jmiSalir=new JMenuItem("Salir");
 
    private final String pnl="C:\\Orgon\\IMGs\\Enero 2014";
    private final String imagenes_dentro_del_jarro="C:\\Biblioteca de Rafael\\Clases Java hechas por mi\\Reproductor de imagenes\\Reproductor_de_imagenes\\src\\pnl_programasion_neurolinguistica";
    private Contenedor_de_imagen imagenes=null;//new Contenedor_de_imagen(imagenes_dentro_del_jarro,300,200);
    private Copiar_archivos copiar=new Copiar_archivos();
    /**
     * frmReproductor_de_imagenes es el constructor de este form.
     */
    public frmReproductor_de_imagenes()
    {
        super("Reproductor de imagenes");
        this.setSize(630, 735);
        this.setLayout(null);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //String m[]={pnl + "\\7dd1174e6e9d85c0231b397f1b369462.jpg", imagenes_dentro_del_jarro + "\\tetona.jpg"};
        //copiar.copiar_un_archivo(m);
        //copiar.copiar_todos_los_archivos(pnl, imagenes_dentro_del_jarro);
        imagenes=new Contenedor_de_imagen(imagenes_dentro_del_jarro,300,200);
 
        imagenes.setBounds(0, 0, 615, 735);
        this.add(imagenes);
 
        this.setJMenuBar(jmb);
        this.jmb.add(this.jmArchivo);
        this.jmArchivo.add(this.jmiSalir);
        this.jmiSalir.addActionListener(this);
 
        imagenes.iniciar_reproduccion();
    } //Constructor
 
    public void click_salir(ActionEvent e)
    {
        if (e.getActionCommand().equalsIgnoreCase(this.jmiSalir.getText())==true)
        {
            System.exit(0);
        } //if
    }
 
    @Override
    public void actionPerformed(ActionEvent e)
    {
        this.click_salir(e);
        //throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }
 
}//frmReproductor_de_imagenes



Comentarios sobre la versión: 1.0 (1)

Imágen de perfil
13 de Mayo del 2018
estrellaestrellaestrellaestrellaestrella
Marquen la siguiente línea como comentario:

import pnl_programasion_neurolinguistica . Contenedor_de_imagen;

Se debe que en mi PC hay un archivo *.Java por cada clase y para publicarlo aquí lo hice así para su portabilidad, además, que depende del aparato y explorador que se use la descarga de archivos se bloque.
Así que yo prefiero pegar el código.
El resto del proyecto está bien y listo para que lo modifiques a tu criterio y gusto.
Responder

Comentar la versión: 1.0

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios
Es necesario revisar y aceptar las políticas de privacidad

http://lwp-l.com/s4595
Revisar política de publicidad