How to use

BufferedWriter

in

java.io

public void initialize(OutputStream processIn, InputStream processOut) {
  try {
    this.processIn = new BufferedWriter(new OutputStreamWriter(processIn, DEFAULT_CHARSET));
    this.processOut = new BufferedReader(new InputStreamReader(processOut, DEFAULT_CHARSET));
  } catch (UnsupportedEncodingException e) {
    throw new RuntimeException(e);
  }
}

private static void writeTrees(String filename, List<Tree> trees, List<Integer> treeIds) {
 try {
  FileOutputStream fos = new FileOutputStream(filename);
  BufferedWriter bout = new BufferedWriter(new OutputStreamWriter(fos));
  for (Integer id : treeIds) {
   bout.write(trees.get(id).toString());
   bout.write("\n");
  }
  bout.flush();
  fos.close();
 } catch (IOException e) {
  throw new RuntimeIOException(e);
 }
}

 public void stripDuplicatesFromFile(String filename) {
  BufferedReader reader = new BufferedReader(new FileReader(filename));
  Set<String> lines = new HashSet<String>(10000); // maybe should be bigger
  String line;
  while ((line = reader.readLine()) != null) {
    lines.add(line);
  }
  reader.close();
  BufferedWriter writer = new BufferedWriter(new FileWriter(filename));
  for (String unique : lines) {
    writer.write(unique);
    writer.newLine();
  }
  writer.close();
}

private void writeString(String str) throws IOException {
  processIn.write(str);
  processIn.write("\nend\n");
  processIn.flush();
}

@Override
protected void convertCorpus(Sentence sentence, BufferedWriter bw) throws IOException
{
  List<String[]> collector = Utility.convertSentenceToNER(sentence, tagSet);
  for (String[] tuple : collector)
  {
    bw.write(tuple[0]);
    bw.write('\t');
    bw.write(tuple[1]);
    bw.write('\t');
    bw.write(tuple[2]);
    bw.newLine();
  }
}

public static void print(String[][] cols) throws Exception {
 BufferedWriter out = new BufferedWriter(new FileWriter(outputFilename));
 for (String[] col : cols) {
  if (col.length >= 2) {
   out.write(col[0] + "\t" + col[1] + "\n");
  } else {
   out.write("\n");
  }
 }
 out.flush();
 out.close();
}

BufferedWriter writer = new BufferedWriter(
    new OutputStreamWriter(os, "UTF-8"));
writer.write(getPostDataString(postDataParams));
writer.flush();
writer.close();
os.close();
int responseCode=conn.getResponseCode();
  BufferedReader br=new BufferedReader(new InputStreamReader(conn.getInputStream()));
  while ((line=br.readLine()) != null) {
    response+=line;

 String encoding = "UTF-8";
int maxlines = 100;
BufferedReader reader = null;
BufferedWriter writer = null;

try {
  reader = new BufferedReader(new InputStreamReader(new FileInputStream("/bigfile.txt"), encoding));
  int count = 0;
  for (String line; (line = reader.readLine()) != null;) {
    if (count++ % maxlines == 0) {
      close(writer);
      writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("/smallfile" + (count / maxlines) + ".txt"), encoding));
    }
    writer.write(line);
    writer.newLine();
  }
} finally {
  close(writer);
  close(reader);
}

public void translateFile(String input, String output) {
 try {
  FileInputStream fis = new FileInputStream(input);
  InputStreamReader isr = new InputStreamReader(fis, "utf-8");
  BufferedReader br = new BufferedReader(isr);
  FileOutputStream fos = new FileOutputStream(output);
  OutputStreamWriter osw = new OutputStreamWriter(fos, "utf-8");
  BufferedWriter bw = new BufferedWriter(osw);
  translateLines(br, bw);
  bw.close();
  osw.close();
  fos.close();
  br.close();
  isr.close();
  fis.close();
 } catch (IOException e) {
  throw new RuntimeIOException(e);
 }
}

 @Override
 public void run() {
  try {
   BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(chooser.getSelectedFile()), FileTreeModel.getCurEncoding()));
   String str = MatchesPanel.getInstance().getMatchedSentences();
   out.write(str);
   out.flush();
   out.close();
  } catch(Exception e) {
   log.info("Exception in save");
   e.printStackTrace();
  }
 }
};

@Test
public void openFile() throws Exception {
  File tempFile = File.createTempFile("textdata", "txt");
  BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(tempFile)));
  writer.write("Hello World. This is used by IOUtilsTest.");
  writer.close();
  InputStream inputStream = IOUtils.open(tempFile.toURI().toURL().toString());
  assertNotNull(inputStream);
  BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
  assertEquals("Hello World. This is used by IOUtilsTest.", reader.readLine());
}

BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(os, "UTF-8"));
writer.write(data);
writer.close();
os.close();
BufferedReader br = new BufferedReader(new InputStreamReader(httpcon.getInputStream(),"UTF-8"));
while ((line = br.readLine()) != null) {  
 sb.append(line); 
br.close();  
result = sb.toString();

private JsonNode sendQuery(String query)
  throws Exception {
 URLConnection urlConnection = new URL("http://" + _brokerAddress + "/query").openConnection();
 urlConnection.setDoOutput(true);
 BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(urlConnection.getOutputStream(), "UTF-8"));
 writer.write(JsonUtils.newObjectNode().put("pql", query).toString());
 writer.flush();
 BufferedReader reader = new BufferedReader(new InputStreamReader(urlConnection.getInputStream(), "UTF-8"));
 return JsonUtils.stringToJsonNode(reader.readLine());
}

InputStream inputStream = SandBoxMaker.class.getClassLoader().getResourceAsStream(SANBOX_TEMPLATE_NAME);
PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(tmpPolicy)));
BufferedReader reader = null;
InputStreamReader inputReader = null;
try {
  inputReader = new InputStreamReader(inputStream);
  reader = new BufferedReader(new LineNumberReader(inputReader));
  String line;
  while ((line = reader.readLine()) != null) {
    String replaced = replaceLine(line, replaceMap);
    writer.println(replaced);
    reader.close();
    inputReader.close();

 try (Writer writer = new BufferedWriter(new OutputStreamWriter(
       new FileOutputStream("filename.txt"), "utf-8"))) {
  writer.write("something");
}

 static URL substitute(URL input, String variable, String substitution) throws IOException {
  File output = File.createTempFile(input.getFile(), ".substituted", new File("build"));
  try (BufferedWriter writer = new BufferedWriter(new FileWriter(output));
     BufferedReader reader = new BufferedReader(new InputStreamReader(input.openStream(), "UTF-8"))) {
   while (true) {
    String line = reader.readLine();
    if (line == null) {
     break;
    } else {
     writer.write(line.replace("${" + variable + "}", substitution));
     writer.newLine();
    }
   }
  }
  return output.toURI().toURL();
 }
}

/**
 * Returns a buffered writer that writes to a file using the given character set.
 *
 * <p><b>{@link java.nio.file.Path} equivalent:</b> {@link
 * java.nio.file.Files#newBufferedWriter(java.nio.file.Path, Charset,
 * java.nio.file.OpenOption...)}.
 *
 * @param file the file to write to
 * @param charset the charset used to encode the output stream; see {@link StandardCharsets} for
 *     helpful predefined constants
 * @return the buffered writer
 */
public static BufferedWriter newWriter(File file, Charset charset) throws FileNotFoundException {
 checkNotNull(file);
 checkNotNull(charset);
 return new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), charset));
}

protected void writeFilteredLogFile(Path originalLogFile, Path filteredLogFile)
  throws IOException {
 this.logFilter.startNewFile();
 try (BufferedReader reader = new BufferedReader(new FileReader(originalLogFile.toFile()))) {
  try (BufferedWriter writer = new BufferedWriter(new FileWriter(filteredLogFile.toFile()))) {
   String line;
   while ((line = reader.readLine()) != null) {
    LogFilter.LineFilterResult result = this.logFilter.acceptsLine(line);
    if (result == LogFilter.LineFilterResult.REMAINDER_OF_FILE_REJECTED) {
     break;
    }
    if (result == LogFilter.LineFilterResult.LINE_ACCEPTED) {
     writeLine(line, writer);
    }
   }
  }
 }
}

public void filter() throws IOException {
  SerializerFactory factory = new DefaultSerializerFactory();
  @SuppressWarnings("unchecked")
  Serializer<Object> keySerializer = (Serializer<Object>) factory.getSerializer(storeDefinition.getKeySerializer());
  BufferedReader in = new BufferedReader(new FileReader(inputFile));
  BufferedWriter out = new BufferedWriter(new FileWriter(outputFile));
  try {
    String line = null;
    while((line = in.readLine()) != null) {
      String keyStr = line.replaceAll("\\s+$", "");
      Object key = null;
      if(stringKeys) {
        key = keyStr;
      } else {
        key = Integer.valueOf(keyStr);
      }
      byte[] keyBytes = keySerializer.toBytes(key);
      List<Node> nodes = routingStrategy.routeRequest(keyBytes);
      if(nodes.contains(node)) {
        out.write(key + "\n");
      }
    }
  } finally {
    try {
      in.close();
    } finally {
      out.close();
    }
  }
}

private File subUserAndPassword(String parent, String filename) throws IOException {
 File createFile = File.createTempFile("create-hive-user-" + schemaTool.getDbType(), ".sql");
 BufferedWriter writer = new BufferedWriter(new FileWriter(createFile));
 File proto = new File(parent, filename);
 BufferedReader reader = new BufferedReader(new FileReader(proto));
 reader.lines()
   .map(s -> s.replace("_REPLACE_WITH_USER_", schemaTool.getHiveUser())
     .replace("_REPLACE_WITH_PASSWD_", schemaTool.getHivePasswd())
     .replace("_REPLACE_WITH_DB_", schemaTool.getHiveDb()))
   .forEach(s -> {
    try {
     writer.write(s);
     writer.newLine();
    } catch (IOException e) {
     throw new RuntimeException("Unable to write to tmp file ", e);
    }
   });
 reader.close();
 writer.close();
 return createFile;
}