读取文件并在找到分隔符时拆分其内容

Question

我的文件内容如下：

nellkb:company_dc
  rdfs:label "dC"  "WASHINGTON" , "Washington" ;
  skos:prefLabel "www.wikipedia.com" .
nellkb:politicsblog_quami_ekta
  rdfs:label "Quami Ekta" ;
  skos:prefLabel "Quami Ekta" .
nellkb:female_ramendra_kumar
  rdfs:label "Ramendra Kumar" ;
  skos:prefLabel "Ramendra Kumar" .

我需要在分隔符“”处拆分我的文件。并将前面的内容保存在字符串中。我怎么能那么做？我尝试了以下方法，但不起作用

try {
    String sCurrentLine = null;
    int i = 0;
    br = new BufferedReader(new FileReader(rdfInstanceFile));
    while ((sCurrentLine = br.readLine()) != null) {
        splitted = sCurrentLine.split(".");
    }
} catch (IOException e) {
    e.printStackTrace();
}

Answer 1

使用scanner类。这个场景非常适合它。您所需要做的就是指定'\\.'分隔符。

没有必要构建一个字符串然后拆分它...

import java.io.InputStream;
import java.util.Scanner;

public class ScanFile {
    public static void main(String[] args) {
        try {
            InputStream is = ScanFile.class.getClassLoader().getResourceAsStream("resources/foo.txt");
            Scanner scan = new Scanner(is);
            scan.useDelimiter("\\.[\r\n]+"); // Tokenize at dots (.) followed by CR/LF.
            
            int i = 1;
            while (scan.hasNext()) {
                String line = scan.next().trim();
                
                System.out.printf("Line #%d%n-------%n%n%s%n%n", i++, line);
            }
            
            scan.close();
            is.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Line #1
-------

nellkb:company_dc
  rdfs:label "dC"  "WASHINGTON" , "Washington" ;
  skos:prefLabel "WASHINGTON"

Line #2
-------

nellkb:politicsblog_quami_ekta
  rdfs:label "Quami Ekta" ;
  skos:prefLabel "Quami Ekta"

Line #3
-------

nellkb:female_ramendra_kumar
  rdfs:label "Ramendra Kumar" ;
  skos:prefLabel "Ramendra Kumar"

公共扫描程序useDelimiter（字符串模式）

扫描程序构造函数接受六（6）种不同类型的对象:文件、InputStream、路径、可读、ReadableByteChannel和String。

// Constructs a new Scanner that produces values scanned from the specified file.
Scanner(File source)
// Constructs a new Scanner that produces values scanned from the specified file.
Scanner(File source, String charsetName)
// Constructs a new Scanner that produces values scanned from the specified input stream.
Scanner(InputStream source)
// Constructs a new Scanner that produces values scanned from the specified input stream.
Scanner(InputStream source, String charsetName)
// Constructs a new Scanner that produces values scanned from the specified file.
Scanner(Path source)
// Constructs a new Scanner that produces values scanned from the specified file.
Scanner(Path source, String charsetName)
// Constructs a new Scanner that produces values scanned from the specified source.
Scanner(Readable source)
// Constructs a new Scanner that produces values scanned from the specified channel.
Scanner(ReadableByteChannel source)
// Constructs a new Scanner that produces values scanned from the specified channel.
Scanner(ReadableByteChannel source, String charsetName)
// Constructs a new Scanner that produces values scanned from the specified string.
Scanner(String source)

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class ScanFile {
    private static ClassLoader loader = ScanFile.class.getClassLoader();
    
    private static interface LineProcessor {
        void process(String line);
    }

    private static interface Reader<T> {
        T read(String resource, String delimiter) throws IOException;
        void flush();
    }

    private abstract static class FileScanner<T> implements Reader<T> {
        private LineProcessor processor;
        public void setProcessor(LineProcessor processor) {
            this.processor = processor;
        }

        public T read(Scanner scan, String delimiter, boolean close) throws IOException {
            scan.useDelimiter(delimiter);
            while (scan.hasNext()) {
                processor.process(scan.next().trim());
            }
            if (close) {
                scan.close();
            }
            return null;
        }

        public T read(InputStream is, String delimiter, boolean close) throws IOException {
            T t = read(new Scanner(is), delimiter, true);
            if (close) {
                is.close();
            }
            return t;
        }

        public T read(String resource, String delimiter) throws IOException {
            return read(loader.getResourceAsStream("resources/" + resource), delimiter, true);
        }
    }
    
    public static class FileTokenizer extends FileScanner<List<String>> {
        private List<String> tokens;
        public List<String> getTokens() {
            return tokens;
        }
        public FileTokenizer() {
            super();
            tokens = new ArrayList<String>();
            setProcessor(new LineProcessor() {
                @Override
                public void process(String token) {
                    tokens.add(token);
                }
            });
        }
        public List<String> read(Scanner scan, String delimiter, boolean close) throws IOException {
            super.read(scan, delimiter, close);
            return tokens;
        }
        @Override
        public void flush() {
            tokens.clear();
        }
    }
    
    public static void main(String[] args) {
        try {
            FileTokenizer scanner = new FileTokenizer();
            List<String> items = scanner.read("foo.txt", "\\.[\r\n]+");

            for (int i = 0; i < items.size(); i++) {
                System.out.printf("Line #%d%n-------%n%n%s%n%n", i + 1, items.get(i));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}