Java Files.newBufferedWriter方法代码示例

import java.nio.file.Files; //导入方法依赖的package包/类
/**
 * Generate a BIG xml file: temporary/bigfile.xml
 */
@Test
@Ignore
public void generateBigXmlFile() throws IOException {

    // make temporary/ dir if it doesn't exist
    Path temporaryPath = Paths.get(Constants.TMP_PATH);
    if (!Files.exists(temporaryPath)) {
        Files.createDirectory(temporaryPath);
    }

    // dump loads of xml in temporary/bigfile.xml
    BufferedWriter bufferedWriter = Files.newBufferedWriter(Paths.get(Constants.BIG_XML_FILE_PATH));
    PrintWriter printWriter = new PrintWriter(bufferedWriter);
    printWriter.println("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
    printWriter.println("<rootelement>");

    IntStream
            .rangeClosed(1, Integer.parseInt(TestProperties.getProperty("com.guido.test.upload.bigfile")))
            .forEach(i -> printWriter.println( String.format("<childelement id=\"%d\">HELLO%10d</childelement>", i, i) ));

    printWriter.println("</rootelement>");
    printWriter.flush();
    printWriter.close();

}
 

import java.nio.file.Files; //导入方法依赖的package包/类
private void save() {
    try {
        Path p = Options.path.resolve("recentfiles");
        Log.info("Save recent files to file: " + p);
        if (Files.notExists(p)) {
            Files.createFile(p);
        }
        try (PrintWriter pw = new PrintWriter(Files.newBufferedWriter(p))) {
            for (RecentFile recentFile : list) {
                pw.println(recentFile);
            }
        }
    } catch (IOException e) {
        Log.error(e);
    }
}
 

import java.nio.file.Files; //导入方法依赖的package包/类
public CsvMpiStatistics(Path dbDir, String dbName) throws IOException {
    Objects.requireNonNull(dbDir);
    Objects.requireNonNull(dbName);
    this.dbDir = dbDir;
    this.dbName = dbName;
    Path csvFile = dbDir.resolve(dbName + ".csv");
    // if file already exists, create a backup
    if (Files.exists(csvFile)) {
        int i = 1;
        Path savCsvFile;
        do {
            savCsvFile = csvFile.getParent().resolve(csvFile.getFileName() + "." + i++);
        } while (Files.exists(savCsvFile));
        Files.move(csvFile, savCsvFile);
    }
    internalWriter = Files.newBufferedWriter(csvFile, StandardCharsets.UTF_8);
}
 

import java.nio.file.Files; //导入方法依赖的package包/类
public static void createFileByTemplate(Path template, Path out, Map<String, Object> model) throws IOException {
    if (Files.exists(out) && Files.isRegularFile(out)) {
        try {
            Files.delete(out);
        } catch (Exception ex) {
            System.out.println("WARNING: " + out.toFile().getAbsolutePath() + " already exists - unable to remove old copy");
            ex.printStackTrace();
        }
    }

    try (BufferedReader br = Files.newBufferedReader(template, Charset.defaultCharset());
         BufferedWriter bw = Files.newBufferedWriter(out, Charset.defaultCharset())) {
        String line;
        while ((line = br.readLine()) != null) {
            if (model != null) {
                for (Map.Entry<String, Object> macro : model.entrySet()) {
                    line = line.replaceAll(Pattern.quote(macro.getKey()), macro.getValue().toString());
                }
            }

            bw.write(line, 0, line.length());
            bw.newLine();
        }
    }
}
 

import java.nio.file.Files; //导入方法依赖的package包/类
public void setTypeLabelID(long type_label_id) throws IOException {

        if (this.type_label_id != -1) {
            throw new IOException("Type label already set");
        }
        this.type_label_id = type_label_id; // cache it and keep a persistent copy of the label.

        Path path = directory.toPath();
        Path meta_path = path.resolve(META_BUCKET_NAME);
        FileManipulation.createDirectoryIfDoesNotExist(meta_path);

        Path typepath = meta_path.resolve(TYPE_LABEL_FILE_NAME);
        if (Files.exists(typepath)) {
            throw new IOException("Type label already set");
        }
        FileManipulation.createFileIfDoesNotExist((typepath));

        try (BufferedWriter writer = Files.newBufferedWriter(typepath, FileManipulation.FILE_CHARSET)) {

            writer.write(Long.toString(type_label_id)); // Write the id of the typelabel OID into this field.
            writer.newLine();
        }
    }
 

import java.nio.file.Files; //导入方法依赖的package包/类
public void dump(Path file) throws IOException {
    try (BufferedWriter writer = Files.newBufferedWriter(file, Charset.forName("UTF-8"))) {
        dump(writer);
    }
}
 

import java.nio.file.Files; //导入方法依赖的package包/类
private void exportBaudPeriodsCsv(String fileName, Set<BaudEntryPeriod> periods) {
    File f = new File(fileName);
    try(BufferedWriter bw = Files.newBufferedWriter(f.toPath(), Charset.forName("UTF-8"), StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING)) {
        bw.write(BaudEntryPeriod.CSV_HEADER);
        bw.newLine();
        for(BaudEntryPeriod period : periods) {
            bw.write(period.toCsvString());
            bw.newLine();
        }
    } catch(Exception e) {
        e.printStackTrace();
    }
}
 

import java.nio.file.Files; //导入方法依赖的package包/类
/**
 * Creates file blah of specified size in bytes.
 */
private static void initTestFile(File blah, long size) throws Exception {
    try (BufferedWriter writer = Files.newBufferedWriter(blah.toPath(), ISO_8859_1)) {
        for(int i=0; i<size; i++) {
            writer.write("e");
        }
    }
}
 

import java.nio.file.Files; //导入方法依赖的package包/类
/**
 * Gets cookbook path by ciClassname
 */
protected void writeChefRequest(CmsWorkOrderSimpleBase wo, String fileName) {
  // build a chef request
  Map<String, Object> chefRequest = assembleRequest(wo);
  // write the request to a .json file
  try (BufferedWriter out = Files.newBufferedWriter(Paths.get(fileName))) {
    out.write(gsonPretty.toJson(chefRequest));
  } catch (IOException e) {
    logger.error("Exception occurred in writing", e);
  }
}
 

import java.nio.file.Files; //导入方法依赖的package包/类
public void save(Path file) throws IOException {
	String fn = file.getFileName().toString();

	if (fn.endsWith(".csv")) {
		try (BufferedWriter out = Files.newBufferedWriter(file)) {
			saveCSV(out);
		}
	} else {
		try (DataOutputStream out = new DataOutputStream(Files.newOutputStream(file))) {
			save(out);
		}
	}
}
 

import java.nio.file.Files; //导入方法依赖的package包/类
private void process(Path inFile, Path outFile) throws IOException {
  try (BufferedReader in = Files.newBufferedReader(inFile)) {
    try (BufferedWriter out = Files.newBufferedWriter(outFile)) {
      process(in, out);
    }
  }
}
 

import java.nio.file.Files; //导入方法依赖的package包/类
public void overwrite() {
    try {
        Path javaFilePath = Paths.get(this.targetFolderPath + path);
        try (BufferedWriter writer = Files.newBufferedWriter(javaFilePath, StandardCharsets.UTF_8)) {
            writer.write(compilationUnit.toString());
        } catch (IOException x) {
            System.err.format("IOException: %s%n", x);
        }
    } catch (Exception e) {
        System.out.println("Error occured while opening the given file: " + e.getMessage());
    }
}
 

import java.nio.file.Files; //导入方法依赖的package包/类
private static void writeFile(String content, Path base, String... pathElements) {
    try {
        Path file = resolveFile(base, pathElements);

        Files.createDirectories(file.getParent());

        try (Writer out = Files.newBufferedWriter(file)) {
            out.append(content);
        }
    } catch (IOException ex) {
        throw new UncheckedIOException(ex);
    }
}
 

import java.nio.file.Files; //导入方法依赖的package包/类
@SuppressWarnings("unused")
public void print(final Path path) throws IOException {

    try (Writer writer = Files.newBufferedWriter(path)) {
        print(writer);
    }
}
 

import java.nio.file.Files; //导入方法依赖的package包/类
void generateOutput(String... args) throws Exception {
    Predicate<String> ignoreList = constructAcceptIgnoreList(args[1]);
    for (int i = 2; i < args.length; i += 4) {
        try (Writer actual = Files.newBufferedWriter(Paths.get(args[i + 2]));
             Writer expected = Files.newBufferedWriter(Paths.get(args[i + 3]))) {
            run(actual, args[i + 1]);
            realClasses(args[i], ignoreList, expected, args[i + 1]);
        }
    }
}