utilizzando pattern matching per ordinare da un file, Java

così ho ottenuto il mio programma al punto in cui separa correttamente le linee del file di testo correttamente e può anche corrispondere al modello per la prima riga di testo, ma ho anche bisogno di essere in grado di rilevare e separare le linee di indirizzo del file di testo e ordinarle in base alla loro direzione o strada / broadway, ma non posso anche ottenere il modello iniziale da rilevare per l’impostazione dell’indirizzo. sto usando regex sbagliato ed è che perché la parte dell’indirizzo non sarà rilevata correttamente?

codice codice codice codice

package csi311;

// Import some standard Java libraries.
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.ArrayList;
/**
 * Hello world example.  Shows passing in command line arguments, in this case a filename. 
 * If the filename is given, read in the file and echo it to stdout.
 */
public class HelloCsi311 {

    /**
     * Class construtor.
     */
    public HelloCsi311() {
    }


    /**
     * @param filename the name of a file to read in 
     * @throws Exception on anything bad happening 
     */
    public void run(String filename) throws Exception {
        if (filename != null) {
            readFile(filename); 
        }
    }


    /**
     * @param filename the name of a file to read in 
     * @throws Exception on anything bad happening 
     */
    private void readFile(String filename) throws Exception {
        System.out.println("Dumping file " + filename); 
        // Open the file and connect it to a buffered reader.
        BufferedReader br = new BufferedReader(new FileReader(filename));  
        ArrayList<String> foundaddr = new ArrayList<String>();
        String line = null;  
        String pattern = "^\\d\\d\\d-[A-Za-z][A-Za-z][A-Za-z]-\\d\\d\\d\\d";
        String address[] = new String[4];
        address[0] = "\\d{1,3}\\s\\[A-Za-z]{1,20}";
        address[1] = "\\d{1,3}\\s\\[A-Za-z]{1,20}\\s\\d{1,3}\\[A-Za-z]{1,20}\\s\\[A-Za-z]{1,20}";
        address[2] = "\\d{1,3}\\s\\d{1,3}\\[A-Za-z]{1,20}\\s\\[A-Za-z]{1,20}";
        address[3] = "\\d\\d\\s\\[A-Za-z]{1,20}";
        Pattern r = Pattern.compile(pattern);
        // Get lines from the file one at a time until there are no more.
        while ((line = br.readLine()) != null) {
            if(line.trim().isEmpty()) {
                continue;
            }
            String sample = line.replaceAll("\\s+,", ",").replaceAll(",+\\s",",");
            String[] result = sample.split(",");
            String pkgId = result[0].trim().toUpperCase();
            String pkgAddr = result[1].trim();


            Float f = Float.valueOf(result[2]);
            for(String str : result){
                // Trying to match for different types
                for(String pat : address){
                    if(str.matches(pat)){
                        System.out.println(pat);
                    }
                }



                if(f < 50 && !pkgId.matches(pattern)) {
                    Matcher m = r.matcher(str);
                    if(m.find()) {
                        foundaddr.add(str);
                    }
                }
            }
        }

        if(foundaddr != null) {
            System.out.println(foundaddr.size());
        }   

        // Close the buffer and the underlying file.
        br.close();
    }



    /**
     * @param args filename
     */
    public static void main(String[] args) {
        // Make an instance of the class.
        HelloCsi311 theApp = new HelloCsi311();
        String filename = null; 
        // If a command line argument was given, use it as the filename.
        if (args.length > 0) {
            filename = args[0]; 
        }
        try { 
            // Run the run(), passing in the filename, null if not specified.
            theApp.run(filename);
        }
        catch (Exception e) {
            // If anything bad happens, report it.
            System.out.println("Something bad happened!");
            e.printStackTrace();
        }    
    }
}

file di testo

123-ABC-4567, 15 W. 15th St., 50.1
456-BGT-9876,22 Broadway,24
QAZ-456-QWER, 100 East 20th Street,50
Q2Z-457-QWER, 200 East 20th Street, 49
6785-FGH-9845 ,45 5th Ave, 12.2,
678-FGH-9846 ,45 5th Ave, 12.2

123-ABC-9999, 46 Foo Bar, 220.0
347-poy-3465, 101 B'way,24

di seguito sono riportate le linee di codice che dovrebbero essere in grado di elaborare le linee di indirizzo, ma per qualche motivo non corrispondono al modello e gli output che separano correttamente le linee di indirizzo e può essere visto nella dichiarazione di stampa sopra il ciclo per trattare con gli indirizzi, ma per qualche motivo le linee di indirizzo arent anche essere rilevato come partite e im confuso sul perché che è.

la Linea di Numero del Codice è con

  for(String str : result){
      //System.out.println(str);
      // Trying to match for different types
      for(String pat : address){
          if(str.matches(pat)){
              System.out.println(pat);
          }
      }

output desiderato – Modifica come richiesto –

22 Broadway
45 5th Ave
101 B'way

EN From: Using pattern matching to sort from a file, Java

More similar articles:

9 Comments

  1. perché non dividere solo su virgole o utilizzare un parser CSV corretto? probabilmente non avete bisogno di un regex qui.

  2. le linee sono divisi su virgole e sono stampati separatamente bene, ma ho poi bisogno di essere in grado di abbinare il modello delle linee divise e poi separarli nelle loro sezioni specifiche che posso fare in arraylist, ma il problema è che per qualche motivo i modelli per le porzioni di indirizzo arent essere rilevato e im confuso sul perché questo è per tutto quello che ho letto su regex e formattazione suggeriscono che la mia formattazione per esso è corretto. questo e ha funzionato bene per individuare il modello corrispondente per la prima parte del testo nel file. questo e l’uso di regex è richiesto.

  3. esempio, 456-BGT-9876
    22 Broadway
    24
    678-FGH-9846
    45 5th Ave
    12.2
    347-poy-3465
    101 B'way
    24
    è ciò che viene stampato e ho bisogno di essere in grado di pattern corrispondono alle porzioni 22 Broadway. utilizzando un regex ho anche fatto a destinazione specifica che l’esempio, ma per qualche ragione anche allora la sua non viene rilevato come una partita. ho bisogno di essere in grado di rilevare questa corrispondenza, perché allora ho bisogno di regolare per essere in grado di rilevare la porzione Broadway e quindi aggiungere che ad un arraylist come una consegna necessaria per andare a un Broadway

  4. fatto, Questo è l’output im cercando di ottenere, dal file di testo il suo nulla dopo la prima virgola, Questo è la porzione di indirizzo della consegna e ho bisogno di pattern match per quegli indirizzi e di essere in grado di stampare fuori. una volta che posso arrivare al punto che gli indirizzi sono corrispondenti male poi preoccuparsi di corrispondenza per i modelli specifici di broadway o Ave o B'way che in questo caso Broadway and B'way sono entrambi considerati broadways e sarebbe lumped in array list raggruppamento.

  5. avrei dovuto accennato in precedenza, ma si dovrebbe dare un’occhiata a come scrivere un esempio minimo, completo e verificabile. la maggior parte delle persone non vogliono leggere un muro di codice irrilevante, in modo da mantenere il vostro esempio minimo, verificabile, e completo vi aiuterà a ottenere risposte più veloci.

  6. Ah sì il mio male lì, mi sono reso conto che era molto da postare, ma data la domanda ho pensato che la maggior parte del codice sarebbe voluto capire cosa sta succedendo, ma probabilmente avrei potuto tagliare il metodo principale del tutto
  7. credo che il problema è con il tuo regex. \\d\\d\\s\\[A-Za-z]{1,20} per esempio, dopo tutta la fuga diventa \d\d\s\[A-Za-z]{1,20}. questo si rompe come segue:

    • \d: abbina qualsiasi cifra
    • \d: abbina qualsiasi cifra
    • \s: corrisponde a qualsiasi carattere dello spazio bianco
    • \[: abbina il carattere [
    • A-Za-z: corrisponde al testo letterale A-Za-z
    • ]: abbina il carattere letterale ]
      • {1,20}: abbina il carattere precedente (]) 1-20 volte.

    il regex che probabilmente si desidera è \d\d\s[A-Za-z]{1,20} che, come una stringa sfuggita è \\d\\d\\s[A-Za-z]{1,20}. si noti che non c’è \ prima del [.

    qualcos’altro da tenere a mente è che le espressioni regolari possono corrispondere ovunque nella stringa. per esempio la regex a corrisponderebbe alla stringa a, ma corrisponderebbe anche a abc, bac, abracadabra, ecc. per evitare questo, è necessario utilizzare i simboli di ancoraggio ^ e $ per corrispondere rispettivamente l’inizio e la fine. il regex diventa quindi ^\\d\\d\\s[A-Za-z]{1,20}$.

    ho anche notato che si sta abbinando ogni colonna contro il regex utilizzando il ciclo for for(String str : result){. mi sembra che si dovrebbe essere solo corrispondenza contro result[1] o pkgAddr.

    una nota finale, date un’occhiata a regex 101. esso vi permetterà di testare le espressioni regolari contro un sacco di input per vedere se corrispondono.

    1. grazie mille! risolto il mio problema regex e ho una migliore comprensione di come funziona, ha avuto qualche singhiozzo ancora nel mio programma, ma niente che non dovrebbe essere in grado di risolvere.

Leave a Reply

Your email address will not be published. Required fields are marked *