Discussion :

[imanost]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
public static Graph loadSingleFile(Path path)
    {
        Graph graph = new Graph();
        BufferedReader bufferedReader;
        try
        {
            bufferedReader = new BufferedReader(new FileReader(path.toFile()));
            String line = null;
            String[] vertices;
            while ((line = bufferedReader.readLine()) != null)
            {
                vertices = line.split(" ");
                if (vertices.length < 2)
                {
                    continue;
                }
                graph.addEdge(Integer.parseInt(vertices[0]),Integer.parseInt(vertices[1]));
            }
            bufferedReader.close();
            return graph;
    static Graph loadMultipleFiles(Path[] paths, PropertyType propertyType)
    {
        Graph graph =
            propertyType == PropertyType.DOUBLE ? new Graph<Double>(propertyType) : new Graph<Long>(propertyType);
        for (Path path : paths)
        {
            BufferedReader bufferedReader;
            try
            {
                bufferedReader = new BufferedReader(new FileReader(path.toFile()));
                String line = null;
                String[] vertices;
                while ((line = bufferedReader.readLine()) != null)
                {
                    vertices = line.split(" ");
                    if (vertices.length < 3)
                    {
                        continue;
                }
switch (propertyType)
                    {
                    case DOUBLE:
                        graph.addEdge(Integer.parseInt(vertices[0]),Integer.parseInt(vertices[1]),
                            Double.parseDouble(vertices[2]));
                        break;
                    case LONG:
                        graph.addEdge(Integer.parseInt(vertices[0]),Integer.parseInt(vertices[1]),
                            Long.parseLong(vertices[2]));
                        break;
                    default:
                        break;
                    }
                bufferedReader.close();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }
        return graph;
    }

[yildiz-online]

Oui, en commençant par gérer les cas d'exception correctement.

[joel.drigo]

Salut,

Ça me semble difficile de fusionner les deux méthodes dans la mesure où l'une d'elles utilise 2 valeurs pour construire les segments et l'autre 3. Mais on peut imaginer un système de fabrique pour les nœuds.

Quelque chose comme çà :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
private static Graph<Integer> load(Path path) throws IOException {
		return loadGraph(null, path);
	}
 
	private static <T> Graph<T> load(PropertyType ptype, Path...paths) throws IOException {
		return loadGraph(ptype.getFactory(), paths);
	}
 
	private static <T> Graph<T> loadGraph(Function<String,T> parser, PropertyType ptype, Path...paths) throws IOException {
		Graph<T> graph = ptype==null?new Graph<>():new Graph<>(ptype);
		for(Path path : paths) {
			try(BufferedReader reader = Files.newBufferedReader(path)) {
				for(String line = reader.readLine(); line!=null; line = reader.readLine()) {
					String[] vertices = line.split(" ");
	                if (vertices.length >= 2) {
	                	final int x = Integer.parseInt(vertices[0]);
	                	final int y = Integer.parseInt(vertices[1]);
	                	if(  parser!=null ) {
                                     if ( vertices.length>2 ) {
	                		graph.addEdge(x, y, parser.apply(vertices[2]));
                                     }
	                	}
	                	else {
	                		graph.addEdge(x, y);
	                	}
	                }
				}
			}
		}
		return graph;
	}

Avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
public enum PropertyType {
	DOUBLE(Double::parseDouble), LONG(Long::parseLong);
 
	private final Function<String, ?> parser;
	private PropertyType(Function<String, ?> parser) {
		this.parser=parser;
	}
	public <T> Function<String, T> getFactory() {
		return (Function<String, T>) parser;
	}
 
}

Bien sûr ce serait plus simple si le constructeur de Graph prenait le même nombre de paramètres quelque soit le cas... d'ailleurs à quoi ça sert de lui passer un PropertyType en paramètre ?

[noboxstyle]

tu peux peut-etre mettre des id en fonction de tes deux types d'objet graph, et en fonction de l'appel, tu changes le reader.
Mais parfois, mieux vaut faire 2 méthodes, même quasi similaires plutôt que de vouloir refactorer à outrance et que le code ne soit plus claire.
La propreté du code passe aussi par sa clareté.