Please have a look at this query

Question

hi there,
i'm implementing a wildcard search utility in my app (restricting usage by allowing to use '*' & '?' only, so no hectic job here), i've achieved the correct matching of a given text & a text with wildcards but to some extent by manual check which very hectic to me, now i want to try with new code which is (incomplete) as follows, please correct & suggest me,
class WildcardSearchUtility {
    static boolean isNodeStringMatchingWildcardText(String wcText, String nodeText) {
         char    c1[] = wcText.toCharArray();
         char    c2[] = nodeText.toCharArray();
         int     n1 = c1.length;
         int     n2 = c2.length;
         int   i1 = 0;
         int   i2 = 0;
         for ( ;     i1 < n1   &&   i2 < n2;     i1++, i2++) {
            if(c1[i1] == '*') {
                      // don't know what to do
               if(i1 != (n1-1)) {
                  i1++;
            } else if (c1[i1] == '?') {
                      // don't know what to do
               if(i1 != (n1-1)) {
                  i1++;
            } else if(c1[i1] != c2[i2])
               return false;
         return false;
   }when i implement the code it should correctly match the given text and a wildcard search text, for example:
     String    wildcardText = "*L?st*";
     String    nodeTexts[] = {
          "List",   "ActionListener",   "JComponent",   "SomeText",
          "Last",   "AbstractList",     "JButton",      "Component"
          "Like",   "ABCDLastPQRS"
     System.out.println("Search text is " + wildcardText + "\n");
     for(int i=0; i < nodeTexts.length; i++) {
          boolean matching = WildcardSearchUtility.isNodeStringMatchingWildcardText(
                                wildcardText, nodeTexts);
System.out.println(
"\tmatching with \""+ nodeTexts[i] + "\"\t" +
(matching ? "[Matched]" : "[Not Matched]\n");
System.out.println("Done");
the output must be like the one below
Search text is "*L?st*"
         matching with "List"         [Matched]
         matching with "ActionListener"         [Not Matched]
         matching with "JComponent"         [Not Matched]
         matching with "SomeText"         [Not Matched]
         matching with "Last"         [Matched]
         matching with "AbstractList"         [Matched]
         matching with "JButton"         [Not Matched]
         matching with "Component"         [Not Matched]
         matching with "Like"         [Not Matched]
         matching with "ABCDLastPQRS"         [Matched]
Donei'd appreciate any suggestions, sample codes, corrections by you experts
thanx in advance,
Afroze.

Answer 1

the jdk1.4 comes with regular expression treatment ...
here it is a sample code:
to test:
* A class which provide a way of filtering a folder relative a set of filename masks
* @version 1.0
* @author Felipe Ga�cho
public class teste
   static public void main(String[] args)
      MyFileFilter t = new MyFileFilter(new String[]{"*.jpg","i*o*u","*88*"});
      System.out.println(t.accept("teste.jpg"));
      System.out.println(t.accept(".jpg.jpg.jpge"));
}The filter class:
import java.util.*;
import java.io.*;
* A class which provide a way of filtering a folder relative a set of masks
* @version 1.0
* @author Felipe Ga�cho
* @date september - 2001
class MyFileFilter implements FileFilter
     /** The array of valid masks */
   private Object[][] masks = null;
   /** The wildcard. The default wildcard is the character '*' */
   private String wildcard = "*";
   /** The description of this filter. For example: "JPG and GIF Images" */
   String filterDescription = "";
     * The constructor
     * @param setOfMasks A set of masks which will be used as filter
   MyFileFilter(String[] setOfMasks, String description)
          filterDescription = description;
      masks = new Object[setOfMasks.length][];
      for(int i=0; i<setOfMasks.length; i++)
         masks[i] = parseMask(setOfMasks);
     * The constructor
     * @param setOfMasks A set of masks which will be used as filter
MyFileFilter(String[] setOfMasks)
          this(setOfMasks, "");
     * Sets the character used as wildcard
     * @param wildcard The new wildcard character
public void setWildcard(String newWildcard)
          wildcard = newWildcard;
     * Returns the current wildcard character
     * @return The current wildcard character
public String getWildcard()
          return this.wildcard;
     * Creates an array with all tags of a mask
     * @param mask The mask which will be used to filter a folder
private Object[] parseMask(String mask)
          StringTokenizer maskParser = new StringTokenizer(mask, wildcard, false);
          ArrayList maskTags = new ArrayList();
          // Fill the array of tags representation of the mask
          while(maskParser.hasMoreTokens())
               maskTags.add((String)maskParser.nextToken());
          // Check if the first character of the mask is a wildcard (open mask on left)
          if(mask.startsWith(wildcard))
               maskTags.add(0,wildcard);
          // Check if the last character of the mask is a wildcard (open mask on right)
          if(mask.endsWith(wildcard))
               maskTags.add(wildcard);
          return maskTags.toArray();
     * The validation process: the filename is parsed from the left to the right
     * seeking the mask tags. If a tag in the mask can�t be reached
     * in the filename it return false, otherwise it returns true.
     * @param filename The filename to be test
     * @param mask An array containing the mask tags
private boolean valid(String filename, Object[] mask)
          // Test if the first tag of the mask is present at the start of the filename
if( ! mask[0].equals(wildcard) && ! filename.startsWith((String)mask[0]))
return false;
          // Test if the last tag of the mask is present at the end of the filename
if( ! mask[mask.length-1].equals(wildcard) && ! filename.endsWith((String)mask[mask.length-1]))
return false;
for(int i=0; i<mask.length; i++)
               // If the tag is a wildcard, then ignore this tag and continues the verification
               if(mask[i].equals(wildcard))
                    continue;
               // The index of a non-wildcard tag in the filename
               int indexOfTheTag = filename.indexOf((String)mask[i]);
               if(indexOfTheTag == -1)
                    return false;
               // The tag were found. Continues the verification from the tag index plus its length
               filename = filename.substring(indexOfTheTag + ((String)mask[i]).length());
          return true;
     * Check if a filename is like one of the masks
     * @param filename The filename to be checked
public boolean accept(String filename)
for(int i=0; i<masks.length; i++)
if(valid(filename, masks[i]))
return true;
return false;
* The FileFilter method overwrite
* @param filename The File which the name should be verifyied
public boolean accept(File filepath)
return accept((filepath.getName()).substring(filepath.getName().lastIndexOf(File.separator)));
* The FileFilter method overwrite
* @return The description of this file filter
public String getDescription()
return filterDescription;