problème de recherche dans JTable

**abdennour bouaicha** · 15/09/2019, 00h35

salut tout le monde,

pour faire une recherche dans JTable on fait ce code suivant

:

Code :

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

1
2
3
 
RowFilter<TableModel, Integer> tm = RowFilter.regexFilter( "(?i)" + text, 0 );
rowSorter.setRowFilter(tm);

et ça fonctionne bien, si on tape par exemple dans la zone de texte :ol , ça va nous extraire : soleil, olive ,tournesol,...
mon problème :je voudrais par exemple:si je tape : ol* ça m'affiche seulement olive ...et tous les mots qui ont ol comme préfixe, si je tape *ol ça m'affiche seulement les mots qui ont ol comme suffixe , si je tape *ol* ça m'affiche seulement les mots qui ont ol au milieu.
est ce qui c'est possible??

et merci.

**joel.drigo** · 15/09/2019, 04h15

Salut,

Sans rien faire, non, ça n'existe pas. En revanche, RowFilter a une méthode, celle que tu utilises, pour construire un filtre par une expression régulière, donc qui utilise la syntaxe des expressions régulières.
Exemple ici.

Tu peux bien entendu implémenter toi-même ce genre de filtre, comme ce que fait RowFilter.regexFilter().

soit en te basant par exemple sur FileNameUtils.wildcardMatch() de Apache Commons. Ça en fait plus que ce que tu voudrais, mais ça fait au moins ce que tu voudrais (c'est fait pour gérer les filtres sur nom de fichier, comme dans un shell). Il faudra étendre RowFilter pour ça.

En cherchant à convertir ce qui est tapé en expression régulière, et en l'utilisant avec RowFilter.regexFilter(). Ce qui se fait de manière assez simple, de manière générale, par exemple par :

Code :

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

1
2
3
	String regexfilter = Arrays.stream(filter.split("\\*",-1))
			.map(s-> s.isEmpty()?s:Pattern.quote(s))
			.collect(Collectors.joining(".*?"));

Ou en testant si ton filtre commence ou termine par une astérisque et en utilisant startsWith et/ou endsWith selon, en étendant RowFIlter, par exemple:

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
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
public class WildcardRowFilter<M,I> extends RowFilter<M,I> {
 
	private final boolean endsWith;
	private final boolean startsWith;
	private final String filter;
	private final int[] columns;
	private final boolean casesensitive; 
 
	public WildcardRowFilter(String filter, boolean casesensitive, int...columns) {
		this.casesensitive=casesensitive;
		if ( filter.startsWith("*") ) {
			endsWith=true;
			filter = filter.substring(1);
		}
		else {
			endsWith=false;			
		}
		if ( filter.endsWith("*") ) {
			startsWith=true;
			filter = filter.substring(0,filter.length()-1);
		}
		else {
			startsWith=false;			
		}
		if ( !casesensitive ) {
			filter = filter.toLowerCase();
		}
		this.filter=filter;
		this.columns=checkIndices(columns);
	}
 
	@Override
    public boolean include(Entry<? extends M, ? extends I> value){
        int count = value.getValueCount();
        if (columns.length > 0) {
            for (int i = columns.length - 1; i >= 0; i--) {
                int index = columns[i];
                if (index < count) {
                    if (include(value, index)) {
                        return true;
                    }
                }
            }
        } else {
            while (--count >= 0) {
                if (include(value, count)) {
                    return true;
                }
            }
        }
        return false;
    } 
	private boolean include(Entry<? extends M, ? extends I> value, int count) {
		String column = value.getStringValue(count);
		if ( column==null ) {
			return false;
		}
 
		if ( !casesensitive ) {
			column = column.toLowerCase();
		}
 
		if ( startsWith ) {
			if ( endsWith ) {
				return column.contains(filter);
			}
			else {
				return column.startsWith(filter);
			}
		}
		else if ( endsWith ) {
			return column.endsWith(filter);
		}
		else {
			return column.equals(filter);
		}
	}
 
	private static int[] checkIndices(int[] columns) {
        for (int i = columns.length - 1; i >= 0; i--) {
            if (columns[i] < 0) {
                throw new IllegalArgumentException("Index must be >= 0");
            }
        }
        return columns;
    }
}