Código de Java - Ordenamiento de archivos JList

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

Ordenamiento de archivos JListgráfica de visualizaciones


Java

Publicado el 14 de Febrero del 2019 por Yacoobs (17 códigos)
2.079 visualizaciones desde el 14 de Febrero del 2019
Hola a todos esta vez creo oportuno traer parte un código que ido modificando según las circunstancias pero que me gustaría compartir con la comunidad
El código en si es una clase que hace el trabajo duro de obtener el contenido de archivos de un directorio, o de varios según como lo precises para después mostrar el resultado en un JList de tu proyecto o Inteface gráfica . Al mismo tiempo tiene la posibilidad de hacer un ordenamiento por tamaño de archivo en este caso y también de filtrar los distintos tipos de archivos como gustes....

La case precisa de varios argumentos:
1. Ruta principal del directorio.
2. JList<?> Clase usada para imprimir en la pantalla de la interface el resultado final.
3. ArrayList<?> Se almacenan las extensiones para crear el filtrado.
4. Cinco variables boolean que determinan que rutas tienen que tomar por defecto.

Su método introduceFiles() devuelve un ArrayList<?> donde se almacenan las rutas de los archivos.

Recuerden que esto es la clase encargada de introducir archivos a un JList, falta que tu construyas tu interface gráfica con un JList y un botón para hacer una búsqueda en tu Pc y pasar esa ruta a esa clase, mas los demás argumentos del método.

Espero que les guste y puedan sacar algo interesante de todo este galimatias de lineas de código

Requerimientos

Este código precisa de una librería externa que puedes descargar para su correcta llamada. Apache Commons IO 2.6 precisa de uno de sus métodos para hacer un filtrado por extensión. Puedes descargar dicho archivo de :
https://commons.apache.org/proper/commons-io/download_io.cgi
Se podría llegar a prescindir de esta librería pero hay que crear un método para ello. Y he preferido no hacerlo

Precisa de el JDK 1.7 o mas que yo sepa

0.1
estrellaestrellaestrellaestrellaestrella(2)

Publicado el 14 de Febrero del 2019gráfica de visualizaciones de la versión: 0.1
2.080 visualizaciones desde el 14 de Febrero del 2019
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

Pantallazo
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
package LeerDocument;
 
 
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import javax.swing.JList;
import javax.swing.JOptionPane;
import org.apache.commons.io.FilenameUtils;
 
/**
 * Aprende Java con Yacoobs
 * @author Yacoobs C. M. 
 * https://www.youtube.com/channel/UChFlaF3Ji9vWhizWyhBQdBg?view_as=subscriber
 * Para contactar conmigo: [email protected].com
 * Dia Creación 07-feb-2019
 * Tiempo Creación 14:00:00
 * 
 * Esta clase precisa de tres argumentos, se encarga de obtener todos los archivos de una ruta y agregalos a un JList siempre y cuando sus 
 * extensiones concuerden con el ArrayList<?>. devuelve al finalizar un ArrayList<?> que se usa despues para pasar las rutas de los archivos.
 * La clase tambien implementa la la Clase Comparable junto con su metodo sort()... para hacer un ordenamiento por tamaño de archivo.
 * 
 */
 
public class AgregarArchivos
{
    private boolean Active_Ruta, Active_Ruta1, Active_Ruta2, Active_Ruta3, Active_Ruta4;
 
    public ArrayList<String> introduceFiles(String ruta, JList<String> jList, ArrayList<String> list_ext, boolean Active_Ruta, boolean Active_Ruta1, boolean Active_Ruta2, boolean Active_Ruta3, boolean Active_Ruta4)
    {
        this.Active_Ruta = Active_Ruta;
        this.Active_Ruta1 = Active_Ruta1;
        this.Active_Ruta2 = Active_Ruta2;
        this.Active_Ruta3 = Active_Ruta3;
        this.Active_Ruta4 = Active_Ruta4;
 
        //Creamos un ArrayList donde vamos almacenar los archivos con las extensiones posibles.
        ArrayList<String> arraylistDatos = new ArrayList<>();
 
        //Llamamos al metodo para que agregue todos los archivos de las rutas mas la ruta por defecto.
        ArrayList<String> list_Files = agrega_Rutas(ruta);
 
        //Agregamos todos los archivos que contenga la ruta especifica con el metodo .list();
	String []agrega_Files = new String[list_Files.size()];
 
        int t=0;
        for (String file : list_Files)
        {
            agrega_Files[t] = file;
            t++;
        }
 
        //Recorremos el Array con un bucle forEach para almacenar los posibles archivos con extensiones.
        for (String objeto : agrega_Files)
        {
            //Evaluamos las posibles extensiones que contempla el ArrayList<?>.
            list_ext.forEach((String extt) ->
            {
                //Obtenemos la extension del archivo (Este metodo precisa de una libreria EXTERNA).
                String Extension = FilenameUtils.getExtension(objeto);
 
                //Evaluamos que la extension obtenida sea igual que la pasada por el ArrayList.
                if (Extension.equalsIgnoreCase(extt))
                    //Agregamos el objeto al ArrayList.
                    arraylistDatos.add(objeto);
            });
        }
 
        //Creamos un Arreglo de clase donde almacenaremos todos los datos pertinentes de los archivos el tamaño del arreglo depende del Arreglo arrylistDatos.
        OrdenarTamanoFile []datosfiles = new OrdenarTamanoFile[arraylistDatos.size()];
 
        int indice=0;
        for (String path: arraylistDatos)
        {
            File file = new File(path);
            datosfiles[indice] = new OrdenarTamanoFile(path, file.getName(), FilenameUtils.getExtension(path), getPesofile(path));
            indice++;
        }
 
        //Usamos la Clase Arrays con su metodo sort() para hacer un ordenamiento de datos.
        Arrays.sort(datosfiles);
 
        //Eliminamos todo el contenido del ArrayList<> para pasar el nuevo y ordenado Arreglo.
        arraylistDatos.clear();
 
        //Vamos a dar un tamaño Exacto de datos para el Arreglo de String.
        agrega_Files = new String[datosfiles.length];
        indice=0;
        for (OrdenarTamanoFile obtenerdatos: datosfiles)
        {
            File file = new File(obtenerdatos.getPath());
            //Agregamos a la vez en los dos Array en uno el nombre del archivo en el otro la ruta de acceso al archivo.
            agrega_Files[indice] = file.getName();
            arraylistDatos.add(obtenerdatos.getPath());
 
            indice++;
        }
 
        //Por ultimo para terminar con el metodo de la clase añadimos el contenido del Arreglo de String al JList
        jList.setListData(agrega_Files);
 
        //Datos finalizados mostrados en consola
        /*for (OrdenarTamanoFile d: datosfiles)
        {
            System.out.println(d.getNombrefile() +"\t\t\t"+d.getExtensionfile()+"\t\t"+d.getPath()+"\t"+d.getPesofile());
        }
        System.out.println("-------------------------------");
        */
 
        return arraylistDatos;
    }
 
    //Metodo encargado de obtener el bytes el tamado de los archivos al mismo tiempo redondea la variable arriba.
    public long getPesofile(String rutaFile)
    {
        File file = new File(rutaFile);
        return Math.round(Math.ceil(file.length()));
    }
 
    //Metodo encargado de preparar las diferente rutas para obtener archivos.
    public ArrayList<String> agrega_Rutas(String ruta)
    {
        String r1 = System.getProperty("user.home")+"/Videos";
        String r2 = System.getProperty("user.home")+"/Pictures";
        String r3 = System.getProperty("user.home")+"/Music";
        String r4 = System.getProperty("user.home")+"/Downloads";
 
        ArrayList<String> allFiles = new ArrayList<>();
 
        //Agregamos todos los archivos que contenga la ruta especifica con el metodo .list();
	String []rut_default = new File(ruta).list();
        String []rut_videos = new File(r1).list();
        String []rut_imagenes = new File(r2).list();
        String []rut_musica = new File(r3).list();
        String []rut_descarga = new File(r4).list();
 
        if (Active_Ruta)
            Anadir_File(rut_default, allFiles, ruta);
        if (Active_Ruta1)
            Anadir_File(rut_videos, allFiles, r1);
        if (Active_Ruta2)
            Anadir_File(rut_imagenes, allFiles, r2);
        if(Active_Ruta3)
            Anadir_File(rut_musica, allFiles, r3);
        if (Active_Ruta4)
            Anadir_File(rut_descarga, allFiles, r4);
 
        return allFiles;
    }
 
    //Metodo que devuelve un ArrayList con toda la lista de archivos contenidos en los directorios ruta.
    public ArrayList<String> Anadir_File(String []arreglo, ArrayList<String> arraylist, String rutt)
    {
        try
        {
            for (String arreglo1 : arreglo) {
                arraylist.add(rutt + "/" + arreglo1);
            }
            return arraylist;
        }catch(NullPointerException e)
        {
            JOptionPane.showMessageDialog(null, "El directoria al que hace referencia no exite!!", "Error", 0);
            System.out.println("Error en vinculacion de una ruta " + rutt + "\n" + e);
            System.out.println(getClass());
        }
        return null;
    }
 
    //Clase que implementa la inteface Comparable encargada de ordenar el Array de Clase.
    private class OrdenarTamanoFile implements Comparable
    {
        public String path, nombrefile, extensionfile;
        public long pesofile;
 
        public OrdenarTamanoFile(String path, String nombrefile, String extensionfile, long pesofile)
        {
            this.path = path;
            this.nombrefile = nombrefile;
            this.extensionfile = extensionfile;
            this.pesofile = pesofile;
        }
 
        public String getPath() {
            return path;
        }
 
        public String getNombrefile() {
            return nombrefile;
        }
 
        public String getExtensionfile() {
            return extensionfile;
        }
 
        public long getPesofile() {
            return pesofile;
        }
 
        @Override
        public int compareTo(Object objeto)
        {
            OrdenarTamanoFile elementodato = (OrdenarTamanoFile) objeto;
 
            if (this.pesofile < elementodato.pesofile)
                return -1;
            else
                return 1;
        }
 
    }
}



Comentarios sobre la versión: 0.1 (2)

Imágen de perfil
24 de Febrero del 2019
estrellaestrellaestrellaestrellaestrella
Excelente trabajo estaba buscando precisamente esto para mi programa gracias de todo corazón amigo programador
Responder
Imágen de perfil
24 de Febrero del 2019
estrellaestrellaestrellaestrellaestrella
Un placer ayudar por poco que sea :)
Responder

Comentar la versión: 0.1

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios...
CerrarCerrar
CerrarCerrar
Cerrar

Tienes que ser un usuario registrado para poder insertar imágenes, archivos y/o videos.

Puedes registrarte o validarte desde aquí.

Codigo
Negrita
Subrayado
Tachado
Cursiva
Insertar enlace
Imagen externa
Emoticon
Tabular
Centrar
Titulo
Linea
Disminuir
Aumentar
Vista preliminar
sonreir
dientes
lengua
guiño
enfadado
confundido
llorar
avergonzado
sorprendido
triste
sol
estrella
jarra
camara
taza de cafe
email
beso
bombilla
amor
mal
bien
Es necesario revisar y aceptar las políticas de privacidad

http://lwp-l.com/s5126