Best code snippets using java.io.BufferedWriter(Showing top 20 results out of 12,429)

 try(FileWriter fw = new FileWriter("outfilename", true);
  BufferedWriter bw = new BufferedWriter(fw);
  PrintWriter out = new PrintWriter(bw))
{
  out.println("the text");
  //more code
  out.println("more text");
  //more code
} catch (IOException e) {
  //exception handling left as an exercise for the reader
}

 Writer writer = null;

try {
  writer = new BufferedWriter(new OutputStreamWriter(
     new FileOutputStream("filename.txt"), "utf-8"));
  writer.write("Something");
} catch (IOException ex) {
 // report
} finally {
  try {writer.close();} catch (Exception ex) {/*ignore*/}
}

@Override
protected void processFile (Entry inputFile) throws Exception {
  filesScanned++;
  String content = new FileHandle(inputFile.inputFile).readString();
  if (content.trim().startsWith("package")) {
    System.out.println("File '" + inputFile.inputFile + "' header fixed");
    filesChanged++;
    BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileHandle(inputFile.outputFile).write(false)));
    writer.write(header + "\n\n" + content);
    writer.close();
  }
}

/**
 * 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));
}

  public static void saveTo(File file, InstructionPrinter printer) {
    try (BufferedWriter bw = new BufferedWriter(new FileWriter(file))) {
      for (String s : printer.createPrint()) {
        bw.write(s);
        bw.newLine();
      }
    } catch (IOException e) {
      new the.bytecode.club.bytecodeviewer.api.ExceptionUI(e);
    }
  }
}

 try (
  OutputStream outputStream = new FileOutputStream(createdFile);
  GZIPOutputStream gzipOutputStream = new GZIPOutputStream(outputStream);
  OutputStreamWriter osw = new OutputStreamWriter(gzipOutputStream);
  BufferedWriter bw = new BufferedWriter(osw)
  ) {
  // ...
}

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);
  }
}

/**
 * Write.
 *
 * @param domainEvent the domain event
 */
public void write(DomainEvent domainEvent) {
 Gson gson = new Gson();
 JsonElement jsonElement;
 if (domainEvent instanceof AccountCreateEvent) {
  jsonElement = gson.toJsonTree(domainEvent, AccountCreateEvent.class);
 } else if (domainEvent instanceof MoneyDepositEvent) {
  jsonElement = gson.toJsonTree(domainEvent, MoneyDepositEvent.class);
 }  else if (domainEvent instanceof MoneyTransferEvent) {
  jsonElement = gson.toJsonTree(domainEvent, MoneyTransferEvent.class);
 } else {
  throw new RuntimeException("Journal Event not recegnized");
 }
 try (Writer output = new BufferedWriter(
   new OutputStreamWriter(new FileOutputStream(aFile, true), "UTF-8"))) {
  String eventString = jsonElement.toString();
  output.write(eventString + "\r\n");
 } catch (IOException e) {
  throw new RuntimeException(e);
 }
}

private void writeConfigToFile( Config config, File file ) throws IOException
{
  try ( Writer fileWriter = new BufferedWriter( new FileWriter( file ) ) )
  {
    for ( Map.Entry<String,String> entry : config.getRaw().entrySet() )
    {
      fileWriter.write( String.format( "%s=%s\n", entry.getKey(), entry.getValue() ) );
    }
  }
}

 try {
  PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("myfile.txt", true)));
  out.println("the text");
  out.close();
} catch (IOException e) {
  //exception handling left as an exercise for the reader
}

protected static void outChars(File dest, char[] data, String encoding, boolean append) throws IOException {
  if (dest.exists()) {
    if (!dest.isFile()) {
      throw new IOException(MSG_NOT_A_FILE + dest);
    }
  }
  Writer out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(dest, append), encoding));
  try {
    out.write(data);
  } finally {
    StreamUtil.close(out);
  }
}

private void process(final Socket socket) throws IOException {
  try (
      BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
      BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
      Socket autoCloseSocket = socket) {
    String cmdLine = reader.readLine();
    if (null != cmdLine && DUMP_COMMAND.equalsIgnoreCase(cmdLine)) {
      List<String> result = new ArrayList<>();
      dumpDirectly("/" + jobName, result);
      outputMessage(writer, Joiner.on("\n").join(SensitiveInfoUtils.filterSensitiveIps(result)) + "\n");
    }
  }
}

private File setupFile(String testDir, String fileName, String content) throws Exception {
 File file = new File(testDir, fileName);
 if (file.exists()) {
  file.delete();
 }
 BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), "UTF-8"));
 out.write(content);
 out.close();
 return file;
}

 File inputFile = new File("myFile.txt");
File tempFile = new File("myTempFile.txt");

BufferedReader reader = new BufferedReader(new FileReader(inputFile));
BufferedWriter writer = new BufferedWriter(new FileWriter(tempFile));

String lineToRemove = "bbb";
String currentLine;

while((currentLine = reader.readLine()) != null) {
  // trim newline when comparing with lineToRemove
  String trimmedLine = currentLine.trim();
  if(trimmedLine.equals(lineToRemove)) continue;
  writer.write(currentLine + System.getProperty("line.separator"));
}
writer.close(); 
reader.close(); 
boolean successful = tempFile.renameTo(inputFile);

public TreeRecorder(Mode mode, String filename) {
 this.mode = mode;
 try {
  out = new BufferedWriter(new FileWriter(filename));
 } catch (IOException e) {
  throw new RuntimeIOException(e);
 }
}

public void translateLines(BufferedReader br, BufferedWriter bw) {
 try {
  String line;
  while ((line = br.readLine()) != null) {
   bw.write(apply(line));
   bw.newLine();
  }
 } catch (IOException e) {
  throw new RuntimeIOException(e);
 }
}

public static void writeToFile(File file, Set<String> content) throws IOException{
  FileWriter fw = new FileWriter(file, false);
  BufferedWriter bw = new BufferedWriter(fw);
  Iterator<String> iter = content.iterator();
  while(iter.hasNext()) {
    bw.write(iter.next());
    bw.write(System.lineSeparator());
  }
  bw.close();
}

 URL url = new URL("http://yoururl.com");
HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
conn.setReadTimeout(10000);
conn.setConnectTimeout(15000);
conn.setRequestMethod("POST");
conn.setDoInput(true);
conn.setDoOutput(true);

Uri.Builder builder = new Uri.Builder()
    .appendQueryParameter("firstParam", paramValue1)
    .appendQueryParameter("secondParam", paramValue2)
    .appendQueryParameter("thirdParam", paramValue3);
String query = builder.build().getEncodedQuery();

OutputStream os = conn.getOutputStream();
BufferedWriter writer = new BufferedWriter(
      new OutputStreamWriter(os, "UTF-8"));
writer.write(query);
writer.flush();
writer.close();
os.close();

conn.connect();

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);
 }
}

private void init(
  java.io.Writer writer,
  String documentEncoding,
  boolean printHeader)
  throws java.io.IOException
{
  this.writer = new java.io.BufferedWriter(writer, IO_BUFFER_SIZE);
  if (printHeader) {
    if (documentEncoding != null) {
      this.writer.write(XMLConstants.XML_HEADER(documentEncoding));
    } else {
      this.writer.write(XMLConstants.XML_HEADER());
    }
  }
}