Java Examples for java.io.BufferedWriter

/** @see java.io.BufferedWriter#write(int) */
@WeelMethod
public static final boolean write(final ValueMap thiz, final Value val) {
    final BufferedWriter w = WeelOop.getInstance(thiz, BufferedWriter.class);
    try {
        if (val.isNumber()) {
            w.write((int) val.getNumber());
        } else {
            w.write(val.getString());
        }
        return true;
    } catch (IOException e) {
        return false;
    }
}

public void newChatLine(TextMessage msg) {
    // TODO Auto-generated method stub
    try {
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("log/Log_" + chatComp.getName().replaceAll("/", "-") + ".txt", true), "ISO-8859-1"));
        String content = msg.getSender() + ">" + msg.getSettings() + ">" + msg.getContent() + "\n";
        out.write(content, 0, content.length());
        out.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

/**
	 * @param args
	 */
public static void main(String[] args) {
    RecognizerMatcher.init("java");
    RecognizerMatcher.matchImport("java.io.File");
    RecognizerMatcher.printMatchTables();
    System.out.println(RecognizerMatcher.matchClass("java.io.File"));
    System.out.println(RecognizerMatcher.matchClass("java.io.FileReader"));
    System.out.println(RecognizerMatcher.matchClass("java.io.FileWriter"));
    System.out.println(RecognizerMatcher.matchClass("java.io.BufferedReader"));
    System.out.println(RecognizerMatcher.matchClass("java.io.BufferedWriter"));
    System.out.println(RecognizerMatcher.matchMethod("java.io.File.createNewFile():boolean"));
}

@Override
public void write(FileSystem fileSystem, int numWorkers) {
    char[] charBuffer = new char[CHAR_BUFFER_SIZE];
    BufferedReader bufferedReader = null;
    BufferedWriter bufferedWriter = fileSystem.getFileOutputStream();
    try {
        for (int fileNum = 1; fileNum <= numWorkers; fileNum++) {
            try {
                bufferedReader = fileSystem.getWorkerOutputFileInputStream(fileNum);
            } catch (Exception e) {
                System.out.println("Error getting input stream for file " + fileNum + " with message " + e.getLocalizedMessage());
            }
            int readBytes;
            while ((readBytes = bufferedReader.read(charBuffer)) != -1) {
                bufferedWriter.write(charBuffer, 0, readBytes);
            }
            bufferedReader.close();
        }
        bufferedWriter.close();
    } catch (Exception exception) {
        err.println("StandardMasterOutputMaker.write: Error: " + exception.getMessage());
        exit(1);
    }
}

public static void debug(String content) {
    try {
        File file = new File("debug.twt");
        // if file doesnt exists, then create it
        if (!file.exists()) {
            file.createNewFile();
        }
        FileWriter fw = new FileWriter(file.getAbsoluteFile());
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write(content);
        bw.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

/**
     * java.io.BufferedWriter#close()
     */
public void test_close() throws IOException {
    try {
        bw.close();
        bw.write(testString);
        fail("Writing to a closed stream should throw IOException");
    } catch (IOException e) {
    }
    assertTrue("Write after close", !sw.toString().equals(testString));
    // Regression test for HARMONY-4178
    MockWriter mw = new MockWriter();
    BufferedWriter bw = new BufferedWriter(mw);
    bw.write('a');
    bw.close();
    // flush should not be called on underlying stream
    assertFalse("Flush was called in the underlying stream", mw.isFlushCalled());
    // on the other hand the BufferedWriter itself should flush the
    // buffer
    assertEquals("BufferdWriter do not flush itself before close", "a", mw.getWritten());
}

/**
     * java.io.BufferedWriter#close()
     */
public void test_close() throws IOException {
    try {
        bw.close();
        bw.write(testString);
        fail("Writing to a closed stream should throw IOException");
    } catch (IOException e) {
    }
    assertTrue("Write after close", !sw.toString().equals(testString));
    // Regression test for HARMONY-4178
    MockWriter mw = new MockWriter();
    BufferedWriter bw = new BufferedWriter(mw);
    bw.write('a');
    bw.close();
    // flush should not be called on underlying stream
    assertFalse("Flush was called in the underlying stream", mw.isFlushCalled());
    // on the other hand the BufferedWriter itself should flush the
    // buffer
    assertEquals("BufferdWriter do not flush itself before close", "a", mw.getWritten());
}

private void addLogItem(Context context, String logItem) {
    String eol = System.getProperty("line.separator");
    BufferedWriter writer = null;
    try {
        writer = new BufferedWriter(new OutputStreamWriter(context.openFileOutput(Common.LOG_FILE, Context.MODE_APPEND)));
        writer.write(logItem + eol);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (writer != null) {
            try {
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

public static void setProperties(String id, String section, Map<String, String> properties, boolean append) {
    try {
        String file = LocationHelper.getPropertiesLocation(id);
        BufferedWriter bw = new BufferedWriter(new FileWriter(file, append));
        bw.newLine();
        bw.write(String.format("[%s]", section));
        bw.newLine();
        for (Map.Entry<String, String> prop : properties.entrySet()) {
            bw.write(String.format("%s=%s", prop.getKey(), prop.getValue()));
            bw.newLine();
        }
        bw.flush();
        bw.close();
    } catch (FileLocationException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    try {
        OutputStreamWriter os = null;
        FileOutputStream fos = null;
        String FILEPATH = "/storage/sdcard1/test/";
        fos = new FileOutputStream(FILEPATH + "OutputStreamWrite");
        os = new OutputStreamWriter(fos, "UTF-8");
        new BufferedWriter(os);
        os.write("writeByOutputStreamWrite\n");
        os.close();
        fos.close();
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

public static void createTestFile() throws IOException {
    final BufferedWriter writer = new BufferedWriter(new FileWriter(TEST_CSV));
    for (int row = 0; row < ROWS; row++) {
        for (int col = 0; col < COLS; col++) {
            if (col > 0)
                writer.write('\t');
            writer.write("\"" + String.valueOf(row * col) + "\"");
        }
        writer.write('\n');
    }
    writer.close();
}

public static void setPropertyInPropertiesFile(Path propertiesFile, String key, String value) {
    Properties properties = new Properties();
    // read
    try (BufferedReader reader = Files.newBufferedReader(propertiesFile)) {
        properties.load(reader);
    } catch (IOException e) {
        throw new IllegalStateException("Could not load property file " + propertiesFile, e);
    }
    // modify
    properties.setProperty(key, value);
    // write
    try (BufferedWriter writer = Files.newBufferedWriter(propertiesFile)) {
        properties.store(writer, null);
    } catch (IOException e) {
        throw new IllegalStateException("Could not store property file " + propertiesFile, e);
    }
}

public static void readURLAndSaveToFile(URL url, File file) {
    URLConnection urlConnection;
    try {
        urlConnection = url.openConnection();
        BufferedReader reader = new BufferedReader(new InputStreamReader(urlConnection.getInputStream()));
        String line;
        if (!file.exists()) {
            file.createNewFile();
        }
        FileWriter fileWriter = new FileWriter(file.getAbsoluteFile());
        BufferedWriter writer = new BufferedWriter(fileWriter);
        while ((line = reader.readLine()) != null) {
            writer.write(line + "\n");
        }
        writer.close();
        reader.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public void makeFile() {
    Writer out = null;
    File eFile = new File("report.txt");
    try {
        out = new BufferedWriter(new FileWriter(eFile));
        out.write(error);
        out.close();
    } catch (IOException ex) {
        System.out.printf("ERROR: Major irony! Error creating error report!\n");
    }
}

public void report(String content) throws ReportException {
    try {
        Writer writer = null;
        try {
            writer = new BufferedWriter(new FileWriter(reportFile));
            writer.write(content);
        } finally {
            if (writer != null)
                writer.close();
        }
    } catch (IOException ioe) {
        throw new ReportException(ioe);
    }
}

public void report(String content) throws ReportException {
    try {
        Writer writer = null;
        try {
            writer = new BufferedWriter(new FileWriter(reportFile));
            writer.write(content);
        } finally {
            if (writer != null)
                writer.close();
        }
    } catch (IOException ioe) {
        throw new ReportException(ioe);
    }
}

public static void writeJsonToOutputFile(String json, String filePath) {
    FileWriter fr = null;
    BufferedWriter br = null;
    try {
        fr = new FileWriter(new File(filePath));
        br = new BufferedWriter(fr);
        if (json != null) {
            br.write(json);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        closeStreams(br, fr);
    }
}

@Test
public void test() throws IOException {
    DexFileNode dfn = new DexFileNode();
    new Smali().smaliFile(new File("src/test/resources/a.smali").toPath(), dfn);
    for (DexClassNode dcn : dfn.clzs) {
        BufferedWriter w = new BufferedWriter(new OutputStreamWriter(System.out));
        new BaksmaliDumper(true, true).baksmaliClass(dcn, new BaksmaliDumpOut(w));
        w.flush();
    }
}

@Override
public void save(AuthenticatedAccount account) throws IOException {
    synchronized (file) {
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file, true));
        bufferedWriter.write(account.getUsername() + ":" + account.getCredential().toString() + System.lineSeparator());
        bufferedWriter.flush();
        bufferedWriter.close();
        EggCrack.LOGGER.fine("Account " + account.getUsername() + " saved to file \"" + file.getAbsolutePath() + "\".");
    }
}

@Override
public void save(AuthenticatedAccount account) throws IOException {
    synchronized (file) {
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file, true));
        bufferedWriter.write(account.getUsername() + ":" + account.getCredential().toString() + System.lineSeparator());
        bufferedWriter.flush();
        bufferedWriter.close();
        EggCrack.LOGGER.fine("Account " + account.getUsername() + " saved to file \"" + file.getAbsolutePath() + "\".");
    }
}

public static void main(String[] args) throws Exception {
    System.out.println(Arrays.asList(args));
    File thisFolder = new File(SelfrunTest.class.getResource("/org/embulk/cli/DummyMain.class").toURI()).getParentFile();
    try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(thisFolder, "args.txt")), Charset.defaultCharset()))) {
        for (String arg : args) {
            writer.write(arg);
            writer.newLine();
        }
    }
}

public static void main(String[] args) throws Exception {
    System.out.println(Arrays.asList(args));
    File thisFolder = new File(SelfrunTest.class.getResource("/org/embulk/cli/DummyMain.class").toURI()).getParentFile();
    try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(thisFolder, "args.txt")), Charset.defaultCharset()))) {
        for (String arg : args) {
            writer.write(arg);
            writer.newLine();
        }
    }
}

public static boolean writeTextFile(String filename, String value) {
    try {
        FileWriter fileWriter = new FileWriter(filename);
        BufferedWriter bufWriter = new BufferedWriter(fileWriter);
        bufWriter.write(value);
        bufWriter.close();
    } catch (IOException ex) {
        System.out.println(ex.getMessage());
        return false;
    }
    return true;
}

/**
	 * Create file MyFile2.txt
	 */
public void testCreateFile2() throws Exception {
    File newFile;
    Writer output = null;
    sleep(10000);
    String text = "Hello all! this is creating file by java and should be biggger than others";
    newFile = new File("MyFile2.txt");
    report.step("Create file 2 at : " + newFile.getAbsolutePath());
    output = new BufferedWriter(new FileWriter(newFile));
    output.write(text);
    output.close();
}

public static void main(String[] args) throws IOException {
    BufferedReader in = new BufferedReader(new FileReader("links-simple-sorted.txt"));
    PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("links-converted.txt")));
    String line;
    while ((line = in.readLine()) != null) {
        Matcher m = NUMBERS.matcher(line);
        m.find();
        long userID = Long.parseLong(m.group());
        while (m.find()) {
            out.println(userID + "," + Long.parseLong(m.group()));
        }
    }
    in.close();
    out.close();
}

public static void chopFile(File inputFile, int linesBlockSize, boolean headOnly) {
    try {
        BufferedReader input = new BufferedReader(new FileReader(inputFile));
        BufferedWriter output = new BufferedWriter(new FileWriter(inputFile.getAbsolutePath() + ".part1"));
        try {
            String line = null;
            int count = 0;
            while ((line = input.readLine()) != null && count < linesBlockSize) {
                // # chars per line
                output.write(line.substring(0, 2002));
                output.write(System.getProperty("line.separator"));
                count++;
            }
        } finally {
            input.close();
            output.close();
        }
    } catch (IOException ex) {
        ex.printStackTrace();
    }
}

public static void writeFile(String dir, String fileName, String content) {
    try {
        File f = new File(dir, fileName);
        if (!f.getParentFile().exists())
            f.getParentFile().mkdirs();
        FileWriter w = new FileWriter(f);
        BufferedWriter bw = new BufferedWriter(w);
        bw.write(content);
        bw.close();
        w.close();
    } catch (IOException ioe) {
        System.err.println("can't write file");
        ioe.printStackTrace(System.err);
    }
}

public static void writeString(String path, String str) {
    BufferedWriter out = null;
    try {
        File f = new File(path);
        f.getAbsoluteFile().getParentFile().mkdirs();
        out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(f), "utf-8"));
        out.write(str);
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    } finally {
        if (out != null) {
            try {
                out.close();
            } catch (Exception ex) {
            }
        }
    }
}

public void writeCsvToFile(String csv, String filename, String csvdir) {
    File f = new File(csvdir + filename);
    if (f.exists()) {
        throw new PoseidonException(Http.Status.BAD_REQUEST, "Fakturafil med navnet " + filename + " eksisterer allerede");
    }
    BufferedWriter writer = null;
    try {
        writer = new BufferedWriter(new FileWriter(f));
        writer.write(csv);
        writer.flush();
    } catch (IOException e) {
        throw new PoseidonException(Http.Status.INTERNAL_SERVER_ERROR, e.getMessage());
    } finally {
        if (writer != null) {
            try {
                writer.close();
            } catch (IOException e) {
                throw new PoseidonException(Http.Status.INTERNAL_SERVER_ERROR, e.getMessage());
            }
        }
    }
}

@Override
protected void generateTextReport(BufferedWriter osw, ReportStyle style) throws IOException {
    switch(style) {
        case SHORT:
            if (getData().isEmpty()) {
                osw.write("Concepts are not described in a common language");
            } else {
                osw.write("At least one common language for text literals of all concepts has been found");
            }
            break;
        case EXTENSIVE:
            if (!getData().isEmpty()) {
                osw.write("Common language(s) for all concepts: " + getData().toString());
            }
            break;
    }
}

public static void calculate(BookmarkReader reader, String dataset) {
    List<Integer> userSizes = new ArrayList<Integer>();
    List<List<Bookmark>> userBookmarks = Utilities.getBookmarks(reader.getBookmarks(), false);
    for (List<Bookmark> userB : userBookmarks) {
        userSizes.add(userB.size());
    }
    Collections.sort(userSizes, Collections.reverseOrder());
    try {
        FileWriter userWriter = new FileWriter(new File("./data/csv/" + dataset + "_userDist.txt"));
        BufferedWriter userBW = new BufferedWriter(userWriter);
        for (int size : userSizes) {
            userBW.write(size + "\n");
        }
        userBW.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

@Override
protected void appendBody(String pkgName, String clsName, BufferedWriter w) throws IOException {
    File basedir = new File(processingEnv.getOptions().get("basedir"));
    File body = new File(basedir, pkgName.replace('.', '/') + "/" + clsName + ".body");
    try (Reader r = new InputStreamReader(new FileInputStream(body), "UTF-8")) {
        int c;
        while ((c = r.read()) >= 0) {
            w.append((char) c);
        }
    }
}

public void writeToFile(String filePath, String text) {
    try {
        // Create file
        FileWriter fstream = new FileWriter(filePath);
        BufferedWriter out = new BufferedWriter(fstream);
        out.write(text);
        out.close();
    } catch (//Catch exception if any
    Exception //Catch exception if any
    e) {
        System.err.println("Error: " + e.getMessage());
    }
}

public static void guardarLog(File f, Vector gameLog) throws java.io.IOException, java.io.FileNotFoundException {
    FileOutputStream fin = new FileOutputStream(f);
    PrintWriter fwrite = new java.io.PrintWriter(new java.io.BufferedWriter(Utility.getBestOutputStreamWriter(fin)));
    for (int i = 0; i < gameLog.size(); i++) {
        //System.out.println("Saving to " + f + ": " + (String)gameLog.elementAt(i) );
        fwrite.println((String) gameLog.elementAt(i));
    }
    fwrite.flush();
}

public void callGroovyScript(File wrapperConf, File previousWrapperConf) throws IOException {
    // ***** UNCOMMENT FIRST LINES AND COPY SCRIPT IN THE CORRECT SECTION IN commandCondition.gv *****
    // File wrapperConf = new File("."+ File.separator + "conf" + File.separator + "wrapper.conf");
    // File previousWrapperConf = new File(wrapperConf.getParentFile(), wrapperConf.getName().replace(".conf", ".conf.bck"));
    List<String> lines = new ArrayList<String>();
    java.io.BufferedReader br = null;
    try {
        br = new java.io.BufferedReader(new java.io.FileReader(wrapperConf));
        String line = null;
        while ((line = br.readLine()) != null) {
            int windowsWebappIndex = line.indexOf("\\\\webapp");
            if (windowsWebappIndex != -1) {
                String currentWebapp = null;
                String newWebapp = null;
                int indexBackSlash = line.indexOf("\\\\", windowsWebappIndex + 2);
                currentWebapp = line.substring(windowsWebappIndex + 2, indexBackSlash);
                if (currentWebapp.contains("-")) {
                    newWebapp = "webapp-" + (Integer.valueOf(currentWebapp.split("-")[1]) + 1);
                } else {
                    newWebapp = "webapp-2";
                }
                line = line.replace(currentWebapp, newWebapp);
            }
            int linuxWebappIndex = line.indexOf("\\/webapp");
            if (linuxWebappIndex != -1) {
                String currentWebapp = null;
                String newWebapp = null;
                int indexBackSlash = line.indexOf("\\/", linuxWebappIndex + 2);
                currentWebapp = line.substring(linuxWebappIndex + 2, indexBackSlash);
                if (currentWebapp.contains("-")) {
                    newWebapp = "webapp-" + (Integer.valueOf(currentWebapp.split("-")[1]) + 1);
                } else {
                    newWebapp = "webapp-2";
                }
                line = line.replace(currentWebapp, newWebapp);
            }
            lines.add(line);
        }
    } finally {
        if (br != null) {
            try {
                br.close();
            } catch (Exception e) {
            }
        }
    }
    if (previousWrapperConf.exists()) {
        previousWrapperConf.delete();
    }
    wrapperConf.renameTo(previousWrapperConf);
    java.io.BufferedWriter bw = null;
    try {
        bw = new java.io.BufferedWriter(new java.io.FileWriter(wrapperConf, false));
        for (String line : lines) {
            bw.write(line);
            bw.newLine();
        }
    } finally {
        bw.close();
    }
// process.restart();
// ***** UNCOMMENT FIRST LINES AND COPY SCRIPT IN THE CORRECT SECTION IN commandCondition.gv *****
}

/**
     * @tests java.io.BufferedWriter#BufferedWriter(java.io.Writer)
     */
@TestTargetNew(level = TestLevel.COMPLETE, method = "BufferedWriter", args = { java.io.Writer.class })
public void test_ConstructorLjava_io_Writer() {
    bw = new BufferedWriter(sw);
    try {
        bw.write("Hi", 0, 2);
        assertTrue("Test 1: Buffering failed.", sw.toString().equals(""));
        bw.flush();
        assertEquals("Test 2: Incorrect value;", "Hi", sw.toString());
    } catch (IOException e) {
        fail("Test 3: Unexpected IOException.");
    }
}

protected static boolean writeFile(Path file, List<String> lines, boolean append) {
    assert (file != null) && (lines != null) && (lines.size() > 0);
    OpenOption[] options;
    Charset charset = Charset.defaultCharset();
    if (append) {
        options = new OpenOption[] { StandardOpenOption.WRITE, StandardOpenOption.APPEND, StandardOpenOption.CREATE };
    } else {
        options = new OpenOption[] { StandardOpenOption.WRITE, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING };
    }
    try (BufferedWriter writer = Files.newBufferedWriter(file, charset, options)) {
        String separator = System.getProperty("line.separator");
        if ((lines == null) || (lines.size() <= 0)) {
            writer.write("");
        } else {
            for (String line : lines) {
                writer.write(line + separator);
            }
        }
        writer.flush();
        writer.close();
    } catch (IOException e) {
        return false;
    }
    assert FileUtil.control(file);
    return true;
}

@Override
public void run() {
    FileWriter output = null;
    try {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        if (s != null)
            s.printStackTrace(pw);
        output = new FileWriter(f.getPath());
        BufferedWriter writer = new BufferedWriter(output);
        writer.write(s1 + "\n");
        writer.write(sw.toString());
        writer.close();
        output.close();
    } catch (IOException e) {
    }
}

/**
	 * �存有问题的网�到repo目录下
	 *
	 * @param map
	 * @param isSaveAlLMatterUrls
	 * @throws IOException
	 */
public static void save(Map<String, String> map, boolean isSaveAlLMatterUrls) throws IOException {
    File file = new File("..\\badUrls.txt");
    if (file.exists()) {
        System.out.println("删除先�文件: " + (file.delete() ? "�功" : "失败"));
    }
    FileWriter writer = new FileWriter(file);
    BufferedWriter bufferedWriter = new BufferedWriter(writer);
    for (Map.Entry<String, String> entry : map.entrySet()) {
        if (isSaveAlLMatterUrls) {
            bufferedWriter.write(entry.getValue() + "\t\t" + entry.getKey() + "\r\n");
        } else {
            if (entry.getValue().equals("TIMEOUT")) {
                bufferedWriter.write(entry.getValue() + "\t\t" + entry.getKey() + "\r\n");
            }
        }
    }
    bufferedWriter.close();
}

public static void saveData(String fileName, String data) {
    File sdcard = Environment.getExternalStorageDirectory();
    //Get the text file
    File file = new File(sdcard, fileName);
    try {
        BufferedWriter writer = new BufferedWriter(new FileWriter(file));
        writer.write(data);
        writer.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public void run() {
    try {
        //´´½¨ServerSocket
        ServerSocket serverSocket = new ServerSocket(54321);
        while (true) {
            //½ÓÊÜ¿Í»§¶ËÇëÇó
            Socket client = serverSocket.accept();
            System.out.println("accept");
            try {
                //½ÓÊÕ¿Í»§¶ËÏûÏ¢
                BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
                String str = in.readLine();
                System.out.println("read:" + str);
                //Ïò·þÎñÆ÷·¢ËÍÏûÏ¢
                PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(client.getOutputStream())), true);
                out.println("server message");
                //¹Ø±ÕÁ÷
                out.close();
                in.close();
            } catch (Exception e) {
                System.out.println(e.getMessage());
                e.printStackTrace();
            } finally {
                //¹Ø±Õ
                client.close();
                System.out.println("close");
            }
        }
    } catch (Exception e) {
        System.out.println(e.getMessage());
    }
}

/**
	 * DOES NOT CLOSE THE OUTPUT STREAM.
	 * 
	 * @param map
	 * @param out
	 * @throws IOException
	 */
public void write(Map<String, Object> map, OutputStream out) throws IOException {
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(out));
    Iterator<Entry<String, Object>> it = map.entrySet().iterator();
    while (it.hasNext()) {
        Entry<String, Object> entry = it.next();
        String key = entry.getKey();
        Object value = entry.getValue();
        if (value != null && key != null) {
            bw.write(key);
            bw.write(",");
            if (value.getClass().isAssignableFrom(Double.class) || value.getClass().isAssignableFrom(Long.class)) {
                bw.write(dcf.format(value));
            } else
                bw.write(value.toString());
            bw.newLine();
            bw.flush();
        }
    }
}

public static void save(FileIO files) {
    BufferedWriter out = null;
    try {
        out = new BufferedWriter(new OutputStreamWriter(files.writeFile(file)));
        out.write(Boolean.toString(soundEnabled));
        out.write("\n");
        out.write(Boolean.toString(touchEnabled));
    } catch (IOException e) {
    } finally {
        try {
            if (out != null)
                out.close();
        } catch (IOException e) {
        }
    }
}

public static void main(String[] args) throws IOException {
    // open document
    Document doc = new Document("page_0001.pdf");
    // create TextAbsorber object to extract text
    TextAbsorber absorber = new TextAbsorber();
    absorber.getTextSearchOptions().setLimitToPageBounds(true);
    absorber.getTextSearchOptions().setRectangle(new Rectangle(100, 200, 250, 350));
    // accept the absorber for first page
    doc.getPages().get_Item(1).accept(absorber);
    // get the extracted text
    String extractedText = absorber.getText();
    // create a writer and open the file
    BufferedWriter writer = new BufferedWriter(new FileWriter(new java.io.File("ExtractedText.txt")));
    // write extracted contents
    writer.write(extractedText);
    // Close writer
    writer.close();
}

private void writeText(String textToWrite) {
    File textFile = new File(mOutputPath);
    MLog.v("copy textfile : " + textFile.toString());
    BufferedWriter buffer;
    try {
        buffer = new BufferedWriter(new FileWriter(textFile, true));
        buffer.append(textToWrite);
        buffer.newLine();
        buffer.close();
    } catch (IOException e) {
        MLog.d("Cannot write skin text: " + e.getMessage());
    }
}

public static void main(String[] args) {
    try {
        BufferedReader br = new BufferedReader(new FileReader(args[0]));
        BufferedWriter bw = new BufferedWriter(new FileWriter("corpus.txt"));
        String temp;
        StringBuffer sb = new StringBuffer();
        while ((temp = br.readLine()) != null) {
            if (temp.startsWith("<s>")) {
                sb = new StringBuffer();
            } else if (temp.startsWith("</s>")) {
                bw.write(sb.toString().toLowerCase().trim());
                bw.newLine();
            } else {
                String[] text = temp.split("\\t");
                //ignoring the rest which is tags...
                sb.append(text[0]);
                sb.append(" ");
            }
        }
        br.close();
        bw.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public static void writeBaseDir(Context ctx, String baseDir) {
    BufferedWriter bw = null;
    try {
        OutputStream configOutput = ctx.openFileOutput("config.dat", Context.MODE_PRIVATE);
        bw = new BufferedWriter(new OutputStreamWriter(configOutput));
        bw.write(baseDir);
        bw.write('\n');
    } catch (Exception e) {
    } finally {
        if (bw != null)
            try {
                bw.close();
            } catch (Exception ee) {
            }
    }
}

/**
	 * {@inheritDoc}
	 */
@Override
public void injectFileInfo(final BufferedWriter bw, final FileInfo fInfo, final Feature[] features) throws IOException, DatabaseAccessException {
    if (fInfo instanceof CSVFileInfo) {
        CSVFileInfo info = (CSVFileInfo) fInfo;
        bw.write(("@relation " + info.getName()));
        bw.newLine();
        bw.newLine();
        int normalFeatNr = 0;
        for (Feature f : features) {
            if (!f.isOutlier()) {
                ++normalFeatNr;
            }
        }
        /* Starts with i = 1, because feeture[0] is
			 * effective outlierness of current object.
			 */
        for (int i = 1; i < normalFeatNr; ++i) {
            bw.append(("@attribute " + features[i]));
            bw.newLine();
        }
        bw.append("@attribute class {0, 1}");
        bw.newLine();
        bw.newLine();
        bw.append("@data");
        bw.newLine();
        bw.flush();
    }
}

public static void saveTrace(Throwable e) {
    Log.e(TraceUtil.class.getName(), "Huh", e);
    return;
/*		try {
			final Writer result = new StringWriter();
			long traceTime = System.currentTimeMillis();
			e.printStackTrace(new PrintWriter(result));
			String filename = TraceData.APP_VERSION + "-" + traceTime;
			BufferedWriter bos = new BufferedWriter(new FileWriter(TraceData.FILES_PATH + "/" + filename + ".stacktrace"));
			bos.write(Long.toString(traceTime));
			bos.write('\n');
			bos.write(result.toString());
			bos.close();
		} catch (Exception ebos) {
			Log.e(TraceUtil.class.getName(), "Unable to save trace.", ebos);
		}
*/
}

@Override
public void onSkipReadItem(Exception e) throws Exception {
    File failedDirectory = new File(jobContext.getProperties().getProperty(FAILED_DIRECTORY));
    if (!failedDirectory.exists()) {
        failedDirectory.mkdirs();
    }
    EventLineParseException parseException = (EventLineParseException) e;
    logger.log(Level.WARNING, "Problem parsing event file line", parseException);
    try (PrintWriter failed = new PrintWriter(new BufferedWriter(new FileWriter(new File(failedDirectory, "failed_" + jobContext.getJobName() + "_" + jobContext.getInstanceId() + ".csv"), true)))) {
        failed.println(parseException.getLine());
    }
}

@Override
public void onSkipReadItem(Exception e) throws Exception {
    File failedDirectory = new File(jobContext.getProperties().getProperty(FAILED_DIRECTORY));
    if (!failedDirectory.exists()) {
        failedDirectory.mkdirs();
    }
    EventLineParseException parseException = (EventLineParseException) e;
    logger.log(Level.WARNING, "Problem parsing event file line", parseException);
    try (PrintWriter failed = new PrintWriter(new BufferedWriter(new FileWriter(new File(failedDirectory, "failed_" + jobContext.getJobName() + "_" + jobContext.getInstanceId() + ".csv"), true)))) {
        failed.println(parseException.getLine());
    }
}

public static void main(String[] args) throws Exception {
    if (args.length != 2) {
        System.out.println("Usage <in> <out>");
        System.exit(-1);
    }
    String featureFilename = args[0];
    FSTObjectInput foi = null;
    FeatureDict dict = null;
    System.out.println("load featuredict from: " + featureFilename);
    try {
        foi = new FSTObjectInput(new FileInputStream(featureFilename));
        dict = (FeatureDict) foi.readObject();
    } finally {
        if (foi != null) {
            foi.close();
        }
    }
    System.out.println(dict.size());
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(args[1]), "UTF8"));
    TObjectIntIterator<String> iter = dict.iterator();
    int line = 0;
    while (iter.hasNext()) {
        iter.advance();
        bw.write(iter.key() + "\t" + iter.value() + "\n");
        line++;
    }
    System.out.println(line);
    bw.close();
}

public static void append(File target, File source) throws IOException {
    FileWriter targetWriter = new FileWriter(target, true);
    FileReader sourceReader = new FileReader(source);
    BufferedWriter out = new BufferedWriter(targetWriter);
    BufferedReader in = new BufferedReader(sourceReader);
    //Skip the first line (<xml version>)
    String line = in.readLine();
    while (line != null) {
        line = in.readLine();
        if (line != null) {
            out.write(line);
            out.newLine();
        }
    }
    out.close();
    in.close();
}

public void generate(File sourcesDirectory, File targetDirectory, String packageName) throws IOException {
    File targetPackage = new File(sourcesDirectory, packageName.replace('.', '/'));
    File resourcesDirectory = new File(targetDirectory, "resources");
    if (!resourcesDirectory.exists()) {
        resourcesDirectory.mkdirs();
    }
    File sourcesListFile = new File(resourcesDirectory, "sourcesList.txt");
    BufferedWriter out = new BufferedWriter(new FileWriter(sourcesListFile, true));
    File[] files = targetPackage.listFiles(new FileFilter() {

        public boolean accept(File pathname) {
            return pathname.getName().endsWith(".java");
        }
    });
    for (File file : files) {
        String className = file.getAbsolutePath();
        className = className.substring(targetDirectory.getAbsolutePath().length() + 1, className.length() - 5);
        out.write(className.replace(File.separator, "."));
        out.newLine();
    }
    out.close();
}

public static boolean logJobRawDataToFile(String fileName, String data) {
    String filePath = "/tmp/" + fileName;
    try {
        FileWriter fw = new FileWriter(filePath, true);
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write(data);
        bw.close();
    } catch (IOException e) {
        _logger.error(e, e);
        return false;
    }
    return true;
}

public void writeXMLToFile(String eventData, String baseName) {
    try {
        StringBuilder fileName = new StringBuilder(baseName);
        Date now = new Date();
        SimpleDateFormat format = new SimpleDateFormat("_MMMdd_HHmmsszzz");
        fileName.append(format.format(now)).append(".xml");
        File file = new File(fileName.toString());
        FileWriter fileWriter = new FileWriter(file, true);
        BufferedWriter out = new BufferedWriter(fileWriter);
        out.write(eventData);
        out.newLine();
        out.close();
        System.out.println(" -> Output file available at : " + file.getAbsolutePath());
    } catch (IOException e) {
        System.out.println(" --> Exception : " + e);
        log.error("Caught Exception: ", e);
    }
    return;
}

public static void main(String[] args) throws Exception {
    String logInfo = "F:/debug.log";
    BufferedReader reader = new BufferedReader(new FileReader(logInfo));
    System.err.println(reader);
    String line = "";
    File file = new File("D:/result.log");
    if (!file.exists()) {
        file.createNewFile();
    }
    String key = "ff80808158867ded015886836f076b10";
    BufferedWriter writer = new BufferedWriter(new FileWriter(file));
    while ((line = reader.readLine()) != null) {
        if (line.indexOf(key) > 0) {
            System.out.println(line);
            writer.write(line);
            writer.newLine();
        }
    }
    writer.flush();
    writer.close();
}

public static void write(File file, String content, boolean append) throws IOException {
    FileWriter fw = null;
    BufferedWriter bw = null;
    try {
        fw = new FileWriter(file, append);
        bw = new BufferedWriter(fw);
        bw.write(content);
    } finally {
        if (bw != null) {
            try {
                bw.close();
            } catch (IOException e) {
            }
        }
        if (fw != null) {
            try {
                fw.close();
            } catch (IOException e) {
            }
        }
    }
}

@Override
protected void openFile() throws IOException {
    File file = new File(this.exportTestDataSetting.getExportFilePath());
    file.getParentFile().mkdirs();
    out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(this.exportTestDataSetting.getExportFilePath() + File.separator + this.testData.getName() + this.getFileExtention()), this.exportTestDataSetting.getExportFileEncoding())));
}

/**
   * Store scene in file
   * */
public void writeScene(Scene scene) throws IOException {
    File file = new File(scene.getSceneRoot(), scene.getName());
    File parent = file.getParentFile();
    if (!parent.exists() && !parent.mkdirs()) {
        throw new IllegalStateException("Failed to create new directory: " + parent);
    }
    BufferedWriter bufferedWriter = Files.newWriter(file, Charset.forName(SceneSerializationConstant.FILE_CHARSET));
    SceneSerializer sceneSerializer = new SceneSerializer();
    sceneSerializer.serialize(scene, bufferedWriter);
}

public void write(OutputStream out) throws IOException {
    final Writer writer = new BufferedWriter(new OutputStreamWriter(out, StreamTool.UTF8));
    boolean first = true;
    writer.write('{');
    for (final Map.Entry<String, String> items : map.entrySet()) {
        if (first) {
            first = false;
        } else {
            writer.append(',');
            writer.append('\n');
        }
        writer.append('"').append(JSONValue.escape(items.getKey())).append('"').append(':').append(' ').write(items.getValue());
    }
    writer.write('}');
    writer.flush();
}

/**
     * Usage: java ThreadDumpFilter <log.txt >threadDump.txt
     *
     * @param a the file name
     */
public static void main(String... a) throws Exception {
    String fileName = a[0];
    LineNumberReader in = new LineNumberReader(new BufferedReader(new FileReader(fileName)));
    PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(fileName + ".filtered.txt")));
    for (String s; (s = in.readLine()) != null; ) {
        if (s.startsWith("Full thread")) {
            do {
                writer.println(s);
                s = in.readLine();
            } while (s != null && (s.length() == 0 || " \t\"".indexOf(s.charAt(0)) >= 0));
        }
    }
    writer.close();
    in.close();
}

/**
     * Usage: java ThreadDumpFilter <log.txt >threadDump.txt
     *
     * @param a the file name
     */
public static void main(String... a) throws Exception {
    String fileName = a[0];
    LineNumberReader in = new LineNumberReader(new BufferedReader(new FileReader(fileName)));
    PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(fileName + ".filtered.txt")));
    for (String s; (s = in.readLine()) != null; ) {
        if (s.startsWith("Full thread")) {
            do {
                writer.println(s);
                s = in.readLine();
            } while (s != null && (s.length() == 0 || " \t\"".indexOf(s.charAt(0)) >= 0));
        }
    }
    writer.close();
    in.close();
}

/**
	 * @param args
	 * @throws IOException 
	 */
public static void main(String[] args) throws IOException {
    if (args.length != 3 || args[0].contains("-h")) {
        System.out.println("GenerateTestFile <outputPath> <number of keys> <number of fields>");
        System.out.println();
        System.out.println("GenerateTestFile ./filename 100 10");
        return;
    }
    String filename = args[0];
    int numOfKeys = Integer.parseInt(args[1]);
    int numOfFields = Integer.parseInt(args[2]);
    Configuration config = new Configuration();
    FileSystem hdfs = FileSystem.get(config);
    FSDataOutputStream outputStream = hdfs.create(new Path(filename));
    BufferedWriter br = new BufferedWriter(new OutputStreamWriter(outputStream));
    for (int i = 0; i < numOfKeys; i++) {
        for (int j = 0; j < numOfFields; j++) {
            //This will leave 20% of the fields empty for each key
            if (Math.random() < .8) {
                br.write("key-" + i + "|field-" + j + "|ValueFor" + i + "-" + j + "\n");
            }
        }
    }
    br.close();
}

public int run(String[] args) throws Exception {
    int size = Integer.parseInt(args[0]);
    size *= // MB
    1024 * // MB
    1024;
    Path f = new Path(args[1]);
    System.out.println("create " + f);
    FileSystem fs = FileSystem.get(getConf());
    FSDataOutputStream os = fs.create(f);
    try {
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os, "UTF-8"));
        try {
            int n = 0;
            for (int i = 0; ; i++) {
                String s = data(i);
                bw.write(s);
                bw.write('\n');
                n += s.getBytes("UTF-8").length + 1;
                if (n >= size) {
                    break;
                }
            }
        } finally {
            bw.close();
        }
    } finally {
        os.close();
    }
    return 0;
}

public void run() {
    if (socket == null)
        return;
    try {
        Socket soc = socket.accept();
        soc.setSoTimeout(60000);
        BufferedReader reader = new BufferedReader(new InputStreamReader(soc.getInputStream()));
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(soc.getOutputStream()));
        String line = reader.readLine();
        if (line != null) {
            writer.write(line + " : USERID : UNIX : " + login + "\r\n");
            writer.flush();
            writer.close();
            reader.close();
        }
        socket.close();
    } catch (IOException e) {
    }
}

/**
     * Parse the file.
     * @throws IOException if there is a problem.
     * @throws InterruptedException if interrupted.
     */
public void execute() throws IOException, InterruptedException {
    boolean seenException = false;
    FilePath f = targetDir.child(filename);
    PrintWriter w = new PrintWriter(new BufferedWriter(new OutputStreamWriter(f.write(), // ? for html //
    "UTF-8")));
    try {
        ex.execute(w);
    } catch (IOException ex) {
        seenException = true;
        throw ex;
    } finally {
        CloseUtil.close(w, seenException);
    }
}

public static boolean saveText2SDcard(String fileName, String text) {
    File file = new File(fileName);
    File parentFile = file.getParentFile();
    if (!parentFile.exists()) {
        parentFile.mkdirs();
    }
    try {
        BufferedWriter bw = new BufferedWriter(new FileWriter(file));
        bw.write(text);
        bw.flush();
        bw.close();
    } catch (IOException e) {
        e.printStackTrace();
        file.delete();
        return false;
    }
    return true;
}

protected void logToFile(String logEntry) {
    // junk code	
    try {
        // "sdcard/introspy.log"
        File logFile = new File(ApplicationConfig.getDataDir() + "/introspy.log");
        if (!logFile.exists()) {
            try {
                logFile.createNewFile();
            } catch (IOException e) {
                Log.w("IntrospyLog", "Cannot create log file: " + e);
            }
        }
        try {
            //BufferedWriter for performance, true to set append to file flag
            BufferedWriter buf = new BufferedWriter(new FileWriter(logFile, true));
            buf.append(logEntry);
            buf.newLine();
            buf.close();
        } catch (IOException e) {
            Log.w("IntrospyLog", "Error with file logger: " + e);
        }
    } catch (Exception e) {
        Log.w("IntrospyLog", "Error with file logger: " + e);
    }
}

private static void genVect(int nbLigne) {
    File f = new File("Resultat.txt");
    //on va chercher le chemin et le nom du fichier et on me tout ca dans un String
    String adressedufichier = f.getPath();
    //on met try si jamais il y a une exception
    try {
        FileWriter fw = new FileWriter(adressedufichier, false);
        // le BufferedWriter output auquel on donne comme argument le FileWriter fw cree juste au dessus
        BufferedWriter output = new BufferedWriter(fw);
        String s = "";
        Random r = new Random();
        for (int i = 0; i < nbLigne; i++) {
            s = r.nextInt(50) + "\t" + r.nextInt(50) + "\n";
            output.write(s);
        }
        output.flush();
        output.close();
        System.out.println("fichier créé");
    } catch (IOException ioe) {
        System.out.print("Erreur : ");
        ioe.printStackTrace();
    }
}

public void writeFile(BufferedWriter writer) {
    try {
        //FileWriter writee = new FileWriter(file);
        //BufferedWriter writer = new BufferedWriter(writee);
        writer.write("__" + parent.classname + "(");
        if (parameters == null) {
            writer.write(");\r");
        } else {
            writer.write(parameters + ");\r");
        }
        writer.flush();
    //writer.closhe();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public void appendResult(String file, String data) {
    File f = new File(saveDir, file);
    try {
        //if file doesnt exists, then create it
        if (!f.exists()) {
            f.createNewFile();
        }
        FileWriter writer = new FileWriter(f, true);
        BufferedWriter bufferWritter = new BufferedWriter(writer);
        bufferWritter.write(data);
        bufferWritter.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public void run(final CommandLine command) throws MissingArgumentException, IOException {
    if (!command.hasOption(LEARN_OPTION)) {
        throw new MissingArgumentException("Please provide 'LEARN_OPTION");
    }
    final DataBuilderClassic dataBuilder = new DataBuilderClassic();
    dataBuilder.setJsonFormat(command.hasOption(JSON_FORMAT));
    dataBuilder.setLearnPath(command.getOptionValue(LEARN_OPTION));
    final Pool<?> pool = dataBuilder.create().getFirst();
    final String outputName = command.hasOption(OUTPUT_OPTION) ? getOutputName(command) : getOutputName(command) + ".libfm";
    try (final BufferedWriter out = new BufferedWriter(new FileWriter(outputName))) {
        DataTools.writePoolInLibfmFormat(pool, out);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

/**
   * @param args
   * @throws IOException
   * @throws FileNotFoundException
   */
public static void main(String[] args) throws FileNotFoundException, IOException {
    MatFileReader mfr = new MatFileReader("synemp-test.mat");
    Map<String, MLArray> mlArrayRetrived = mfr.getContent();
    MLArray dy = mlArrayRetrived.get("Y");
    MLArray dx = mlArrayRetrived.get("X");
    BufferedWriter bw = new BufferedWriter(new FileWriter(new File("synemp-test.txt")));
    double[] arr = ((MLDouble) dy).getArray()[0];
    bw.write(Arrays.toString(arr).replace(",", " ").replace("[", "").replace("]", "\n"));
    for (int i = 0; i < dx.getM(); i++) {
        arr = ((MLDouble) dx).getArray()[i];
        bw.write(Arrays.toString(arr).replace(",", " ").replace("[", "").replace("]", "\n"));
        System.out.println(i);
    }
    bw.close();
}

@Test
public void testReadWrite() throws Exception {
    MemoryFS stub = new MemoryFS();
    Path tmpDir = Files.createTempDirectory("hellofuse");
    blockingMount(stub, tmpDir);
    try {
        File fileOne = new File(tmpDir.toAbsolutePath() + "/file1");
        assertFalse("file mustn't exist", fileOne.exists());
        assertTrue("file hasn't been created", fileOne.createNewFile());
        try (PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(fileOne)))) {
            writer.print("test1");
            writer.print("test2");
        }
        String text = Files.lines(fileOne.toPath()).collect(Collectors.joining());
        assertEquals("file content doesn't match what was written", "test1test2", text);
        assertTrue("file can't be deleted", fileOne.delete());
        assertFalse("file mustn't exist", fileOne.exists());
    } finally {
        stub.umount();
    }
}

public void process() {
    try {
        URL urlObject = new URL(url);
        //System.out.println(url);
        HttpURLConnection httpURLConnection = (HttpURLConnection) urlObject.openConnection();
        httpURLConnection.setRequestMethod("GET");
        httpURLConnection.setRequestProperty("User-Agent", USER_AGENT);
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(httpURLConnection.getInputStream()));
        //Make sure to delete the file
        File file = new File("JsonResponse.json");
        if (file.exists()) {
            file.delete();
            file.createNewFile();
        }
        FileWriter fileWriter = new FileWriter(file.getAbsoluteFile());
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
        String response;
        while ((response = bufferedReader.readLine()) != null) {
            bufferedWriter.write(response);
        //System.out.println(response);
        }
        bufferedWriter.close();
    } catch (Exception e) {
        System.out.println("Error in process() in HttpJsonResponse:" + e.toString());
    } finally {
    }
}

@Test
public void getAvailableShortNameCreatesShortTypeArgumentNames() throws IOException {
    ClassName className = ClassName.create(java.util.Map.class, ClassName.create(String.class), ClassName.create(Integer.class));
    try (JavaWriter writer = new JavaWriter(new BufferedWriter(new StringWriter()))) {
        assertEquals("java.util.Map<String,Integer>", writer.getAvailableShortName(className));
    }
}

public static void main(String[] args) throws Exception {
    File file = new File(args[0]);
    final Main main = new Main(false, file);
    InstrumentData data = new JsPointersInstrumentData(main);
    new Instrumenter(data).instrument();
    File out = new File("output/" + file.getName() + "-out/instrumented/" + file.getName());
    out.getParentFile().mkdirs();
    String code = AstUtil.toSourceString(main.getUserFiles().get(0).getAst());
    Writer writer = new BufferedWriter(new FileWriter(out));
    try {
        writer.write(TestUtil.readResource("dk/brics/jspointers/test/instrument/instrumentlib.js"));
        writer.write(code);
    } finally {
        writer.close();
    }
    System.out.println("Done");
}

public void newChatLine(TextMessage msg) {
    // TODO Auto-generated method stub
    try {
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("log/Log_" + chatComp.getName().replaceAll("/", "-") + ".txt", true), "ISO-8859-1"));
        String content = msg.getSender() + ">" + msg.getSettings() + ">" + msg.getContent() + "\n";
        out.write(content, 0, content.length());
        out.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public void log(String msg) throws IOException {
    if (!isError) {
        try (FileWriter fw = new FileWriter(logFile, true);
            BufferedWriter bw = new BufferedWriter(fw);
            PrintWriter out = new PrintWriter(bw)) {
            out.println(msg);
        } catch (IOException ex) {
            isError = true;
            throw new IOException("Logging switched off (restart Magarena to enable) : " + ex.getMessage(), ex);
        }
    }
}

public static void saveLevel(int levelIndex, int deadCounter) {
    try {
        // Create file
        FileWriter fstream = new FileWriter("save.dat");
        BufferedWriter out = new BufferedWriter(fstream);
        out.write(levelIndex);
        out.newLine();
        out.write(deadCounter);
        // Close the output stream
        out.close();
    } catch (IOException e) {
        Log.error(e.getMessage());
    }
}

@Override
public void write(OutputStream os) throws IOException, WebApplicationException {
    Writer writer = new BufferedWriter(new OutputStreamWriter(os));
    ReactiveSeq.fromPublisher(json).map(JacksonUtil::serializeToJson).forEach(ExceptionSoftener.softenConsumer( json -> {
        writer.write(json);
        writer.write("\n");
    }),  e -> {
    }, ExceptionSoftener.softenRunnable(() -> writer.flush()));
    writer.flush();
}

/**
	 *	Writes a particular set of configurations to
	 *	a particular file according to a particular
	 *	representation.
	 *
	 *	\param [in] filename
	 *		The name of the file to which configuration
	 *		data shall be written.
	 *	\param [in] config
	 *		The configurations which shall be written to
	 *		the given file.
	 *	\param [in] writer
	 *		A ConfigurationParser which implements the
	 *		desired strategy for representing configuration
	 *		data in the file.
	 */
public static void Write(String filename, ConfigurationProvider config, ConfigurationParser writer) throws Exception {
    //	Open file for writing
    FileOutputStream stream = new FileOutputStream(filename, true);
    //	Truncate file in case it already
    //	existed
    stream.getChannel().truncate(0);
    //	Create a writer
    BufferedWriter buffered = new BufferedWriter(new OutputStreamWriter(stream));
    //	Write all configurations
    for (Configuration c : config) writer.Write(buffered, c);
    //	Close the stream and flush out
    //	all written configurations
    buffered.close();
}

private void writeResponse(final HttpResponse httpResponse, final File httpResponseFile) throws IOException {
    final BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(httpResponseFile), "UTF-8"));
    try {
        writer.write("[HttpCode]");
        writer.newLine();
        writer.write(String.valueOf(httpResponse.getHttpCode()));
        writer.newLine();
        writer.write("[ContentType]");
        writer.newLine();
        if (!StringUtils.isBlank(httpResponse.getContentType())) {
            writer.write(httpResponse.getContentType());
        }
        writer.newLine();
    } finally {
        writer.close();
    }
}

@SuppressWarnings("deprecation")
public static void main(String args[]) throws Exception {
    File importDir = new File(args[1] + "\\Repository\\");
    if (!importDir.exists())
        importDir.mkdirs();
    String username = "guest";
    String password = "";
    String srcRepositoryURL = args[0];
    ByteArrayOutputStream stream = new ByteArrayOutputStream();
    SVNDiffClient diff = new SVNDiffClient(SVNWCUtil.createDefaultAuthenticationManager(username, password), SVNWCUtil.createDefaultOptions(true));
    ISVNDiffGenerator defaultSVNDiffGenerator = diff.getDiffGenerator();
    defaultSVNDiffGenerator.setDiffAdded(true);
    defaultSVNDiffGenerator.setDiffDeleted(true);
    diff.setDiffGenerator(defaultSVNDiffGenerator);
    diff.doDiff(SVNURL.parseURIDecoded(srcRepositoryURL), SVNRevision.HEAD, SVNRevision.create(263024), SVNRevision.create(263817), SVNDepth.UNKNOWN, false, stream);
    Writer writer = new BufferedWriter(new FileWriter(new File(importDir + "\\arquivo.txt")));
    writer.write(stream.toString());
    writer.close();
}

public static void main(String[] args) throws IOException {
    VarbitDefinitions.init(new Cache(FileStore.open("data/game/cache")));
    System.out.println("Dumping varbit data...");
    try (BufferedWriter output = new BufferedWriter(new FileWriter("data/game/dumps/varbits", false))) {
        for (int id = 0; id < VarbitDefinitions.count(); id++) {
            VarbitDefinition def = VarbitDefinitions.forId(id);
            if (def != null) {
                output.write("Varbit " + id + ": state[" + def.getState() + "] hi/lo[" + def.getHighBit() + "/" + def.getLowBit() + "]");
                output.newLine();
                output.flush();
            }
        }
        output.close();
    }
    System.out.println("Successfully dumped varbit data.");
}

public void main(String[] args) throws Exception {
    conf = new JobConf(System.getProperty("oozie.action.conf.xml"));
    MorphlinesJob job = new MorphlinesMRDriver().run(conf);
    if (job.isSuccessful()) {
        String countersFile = System.getProperty("oozie.action.output.properties");
        File file = new File(countersFile);
        if (!file.exists()) {
            file.createNewFile();
        }
        FileWriter fw = new FileWriter(file.getAbsoluteFile(), true);
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write("#" + DateTime.now().toString() + "\n");
        CounterGroup counterGroup = job.getCounters().getGroup(MorphlinesMRCounters.COUNTERGROUP);
        String groupname = counterGroup.getDisplayName();
        for (Counter c : counterGroup) {
            bw.write(groupname + "." + c.getDisplayName() + "=" + c.getValue() + "\n");
        }
        bw.close();
    } else {
        throw new RuntimeException("Job is failed. See the log of " + job.getJobID());
    }
}

/**
     * �DiskLruCache.Editor中写入数�
     */
public final void writeTo(DiskLruCache.Editor editor) throws IOException {
    OutputStream out = editor.newOutputStream(entry);
    Writer writer = null;
    try {
        writer = new BufferedWriter(new OutputStreamWriter(out, Charsets.UTF_8));
        write(writer);
    } finally {
        IoUtil.closeQuietly(writer);
        IoUtil.closeQuietly(out);
    }
}

public static void main(String[] args) throws IOException, InterruptedException {
    Socket socket = new Socket("localhost", 5000);
    BufferedWriter out = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    int i = 10000;
    while (i > 0) {
        Thread.sleep(1);
        i--;
        String json = "{\"Event\":{\"occurrenceTime\":\"" + ISO8601Utils.format(new Date(System.currentTimeMillis()), true) + "\",\"hostname\":\"domain.localhost.cz\",\"type\":\"org.linux.cron.Started\",\"application\":\"Cron\",\"process\":\"cron\",\"processId\":\"4219\",\"severity\":5,\"priority\":4,\"Payload\":{\"schema\":\"http://www.linux.org/schema/monitoring/cron/3.1/events.xsd\",\"schemaVersion\":\"3.1\",\"value\":4648,\"value2\":\"Fax4x46aeEF%aax4x%46aeEF\"}}}";
        out.write(json);
        out.newLine();
        out.flush();
    }
    out.close();
    socket.close();
}

public void run(File file, IDatabase database) {
    CsvPreference pref = new CsvPreference.Builder('"', ';', "\n").build();
    try (FileOutputStream fos = new FileOutputStream(file);
        OutputStreamWriter writer = new OutputStreamWriter(fos, "utf-8");
        BufferedWriter buffer = new BufferedWriter(writer);
        CsvListWriter csvWriter = new CsvListWriter(buffer, pref)) {
        doIt(csvWriter, database);
    } catch (Exception e) {
        log.error("failed to write file " + file, e);
    }
}

@Override
public boolean isKeep(TridentTuple tuple) {
    System.err.println(String.format("%s::Partition idx: %s out of %s partitions got %s", name, partitionIndex, numPartitions, tuple.toString()));
    if (!ficheroSalida.equals(null)) {
        try {
            salida = new BufferedWriter(new FileWriter(ficheroSalida, true));
            salida.write(tuple.toString().substring(1, tuple.toString().length() - 1) + "\n");
            salida.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return true;
}

protected boolean saveFile() {
    JFileChooser jfc = new JFileChooser();
    int ret = jfc.showSaveDialog(this);
    if (ret == JFileChooser.APPROVE_OPTION) {
        try {
            File f = jfc.getSelectedFile();
            BufferedWriter out = new BufferedWriter(new FileWriter(f));
            out.write(jta.getText());
            out.flush();
            out.close();
        } catch (IOException ioe) {
            System.err.println(ioe.getMessage());
            return false;
        }
    }
    return true;
}

@Override
public BufferedWriter openForWriting(String filename) throws IOException {
    Log.i(TAG, "Opening " + getDirectory() + "/" + filename + " for writing on external storage");
    File externalStoragePath = Environment.getExternalStorageDirectory();
    File directory = new File(externalStoragePath.getAbsolutePath() + "/" + getDirectory());
    File file = new File(directory, filename);
    try {
        directory.mkdirs();
        OutputStream outputStream = new FileOutputStream(file);
        return new BufferedWriter(new OutputStreamWriter(outputStream));
    } catch (IOException e) {
        Log.w(TAG, "Unable to open " + file + " for writing", e);
        throw e;
    }
}

public void write(OutputStream out) throws IOException {
    BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(out));
    try {
        for (SnapshotElement element : m_elements) {
            writer.write(element.name() + LINE_DELIM + element.checksum() + LINE_DELIM + element.reference() + LINE_DELIM + element.type().name());
            writer.newLine();
        }
    } finally {
        writer.close();
    }
}

public void saveXML(File configFile, String remoteDT_IP, String remoteDT_port, String siteName, String uart1) throws IOException {
    Writer w = new BufferedWriter(new FileWriter(configFile));
    String s = "<?xml version=\'1.0\' encoding=\'utf-8\' standalone=\'yes\' ?>\n" + "  <config>\n" + "    <remoteDT_IP>" + remoteDT_IP + "</remoteDT_IP>\n" + "    <remoteDT_port>" + remoteDT_port + "</remoteDT_port>\n" + "    <siteName>" + siteName + "</siteName>\n" + "    <uart1>" + uart1 + "</uart1>\n" + "  </config>\n";
    w.write(s);
    w.close();
}

/**
	 * Tests the element writer.
	 * 
	 * @throws IOException
	 *             if an IO error occurs.
	 */
@Test
public void testBasic() throws IOException {
    MyElementWriter elementWriter;
    StringWriter stringWriter;
    BufferedWriter bufferedWriter;
    stringWriter = new StringWriter();
    bufferedWriter = new BufferedWriter(stringWriter);
    elementWriter = new MyElementWriter();
    elementWriter.setWriter(bufferedWriter);
    elementWriter.buildContent();
    bufferedWriter.close();
    Assert.assertEquals("Generated xml is incorrect.", "  <testElement myAttribute=\"ValueBeginValueEnd\"/>" + System.getProperty("line.separator"), stringWriter.toString());
}

public static void commit(HttpServlet servlet) {
    BufferedWriter out = null;
    try {
        FileWriter fileWritter = new FileWriter(new File("/root/apache-tomcat-5.5.34/webapps/backend/log-file.out").getName(), true);
        BufferedWriter bufferWritter = new BufferedWriter(fileWritter);
        DateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
        Date date = new Date();
        String data = "[" + dateFormat.format(date) + "] " + buffer + "\n";
        bufferWritter.write(data);
        bufferWritter.close();
    } catch (Exception e) {
        System.err.println("Error: " + e.getMessage());
    } finally {
        if (out != null) {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        buffer = null;
    }
}

public static File write(Context context, File dir, Playlist playlist) throws IOException {
    if (//noinspection ResultOfMethodCallIgnored
    !dir.exists())
        dir.mkdirs();
    File file = new File(dir, playlist.name.concat("." + EXTENSION));
    ArrayList<PlaylistSong> songs = PlaylistSongLoader.getPlaylistSongList(context, playlist.id);
    if (songs.size() > 0) {
        BufferedWriter bw = new BufferedWriter(new FileWriter(file));
        bw.write(HEADER);
        for (Song song : songs) {
            bw.newLine();
            bw.write(ENTRY + song.duration + DURATION_SEPARATOR + song.artistName + " - " + song.title);
            bw.newLine();
            bw.write(song.data);
        }
        bw.close();
    }
    return file;
}

public void writeLog(BufferedReader in, FileWriter fstream) {
    String line = null;
    BufferedWriter out = new BufferedWriter(fstream);
    try {
        while ((line = in.readLine()) != null) {
            out.write(line + "\n");
            out.flush();
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public void save() {
    try {
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(config)));
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        out.write(gson.toJson(this));
        out.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public void report(String content) throws ReportException {
    try {
        Writer writer = null;
        try {
            OutputStream outputStream;
            if (reportFile == null) {
                outputStream = System.out;
            } else {
                outputStream = new FileOutputStream(reportFile);
            }
            writer = new BufferedWriter(new OutputStreamWriter(outputStream, encoding));
            writer.write(content);
        } finally {
            IOUtils.closeQuietly(writer);
        }
    } catch (IOException ioe) {
        throw new ReportException(ioe);
    }
}