Java Code Examples for java.io.OutputStreamWriter

public void testExtract() throws Exception
{
    List<File> fileList = FolderWalker.open(FOLDER);
    Map<String, String> phraseMap = new TreeMap<String, String>();
    int i = 0;
    for (File file : fileList)
    {
        System.out.print(++i + " / " + fileList.size() + " " + file.getName() + " ");
        String path = file.getAbsolutePath();
        List<String> phraseList = MutualInformationEntropyPhraseExtractor.extract(IOUtil.readTxt(path), 3);
        System.out.print(phraseList);
        for (String phrase : phraseList)
        {
            phraseMap.put(phrase, file.getAbsolutePath());
        }
        System.out.println();
    }
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("data/phrase.txt")));
    for (Map.Entry<String, String> entry : phraseMap.entrySet())
    {
        bw.write(entry.getKey() + "\t" + entry.getValue());
        bw.newLine();
    }
    bw.close();
}
 

/**
 * Write reader to request body
 * <p>
 * The given reader will be closed once sending completes
 *
 * @param input
 * @return this request
 * @throws HttpRequestException
 */
public HttpRequest send(final Reader input) throws HttpRequestException {
    try {
        openOutput();
    } catch (IOException e) {
        throw new HttpRequestException(e);
    }
    final Writer writer = new OutputStreamWriter(output,
            output.encoder.charset());
    return new FlushOperation<HttpRequest>(writer) {

        @Override
        protected HttpRequest run() throws IOException {
            return copy(input, writer);
        }
    }.call();
}
 

/**
 * This method tests if Repositinioning Information works.
 * It creates a document using an xml file with preserveOriginalContent
 * and collectRepositioningInfo options keeping true and which has all
 * sorts of special entities like &amp, &quot etc. + it contains both
 * kind of unix and dos stype new line characters.  It then saves the
 * document to the temporary location on the disk using
 * "save preserving document format" option and then compares the contents of
 * both the original and the temporary document to see if they are equal.
 * @throws java.lang.Exception
 */
public void testRepositioningInfo() throws Exception {

  // here we need to save the document to the file
    String encoding = ((DocumentImpl)doc).getEncoding();
    File outputFile = File.createTempFile("test-inline1","xml");
    OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(outputFile),encoding);
    writer.write(doc.toXml(null, true));
    writer.flush();
    writer.close();
    Reader readerForSource = new BomStrippingInputStreamReader(new URL(testFile).openStream(),encoding);
    Reader readerForDesti = new BomStrippingInputStreamReader(new FileInputStream(outputFile),encoding);
    while(true) {
      int input1 = readerForSource.read();
      int input2 = readerForDesti.read();
      if(input1 < 0 || input2 < 0) {
        assertTrue(input1 < 0 && input2 < 0);
        readerForSource.close();
        readerForDesti.close();
        outputFile.delete();
        return;
      } else {
        assertEquals(input1,input2);
      }
    }
}
 

/**
 * 多语料文件合并功能：文件夹的分词标注数据合并为一个文件
 *
 * @throws Exception
 */
public void dumpCorpusFolderToFile() throws Exception {
    final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(CORPUS_FILE_PATH)));
    CorpusLoader.walk(CORPUS_FOLDER_PATH, document -> {
        List<List<Word>> simpleSentenceList = document.getSimpleSentenceList();
        for (List<Word> wordList : simpleSentenceList) {
            try {
                for (Word word : wordList) {
                    bw.write(word.toString());
                    bw.write(' ');
                }
                bw.newLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    });
    bw.close();
}
 

public void save(OutputStream outStream) throws IOException {
    BufferedWriter out = new BufferedWriter(new OutputStreamWriter(outStream, "UTF-8"));
    String aKey;
    Object aValue;
    for (Enumeration e = keys(); e.hasMoreElements();) {
        aKey = (String) e.nextElement();
        aValue = get(aKey);
        out.write(aKey + " = " + aValue);
        out.newLine();
    }
    out.flush();
    out.close();
}
 

@Override
protected void writeInternal(Object o, Type type, HttpOutputMessage outputMessage)
    throws IOException, HttpMessageNotWritableException {
    Charset charset = getCharset(outputMessage.getHeaders());

    try (OutputStreamWriter writer = new OutputStreamWriter(outputMessage.getBody(), charset)) {
        if (ignoreType) {
            gsonForWriter.toJson(o, writer);
            return;
        }

        if (type != null) {
            gsonForWriter.toJson(o, type, writer);
            return;
        }

        gsonForWriter.toJson(o, writer);
    } catch (JsonIOException ex) {
        throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getMessage(), ex);
    }
}
 

@Override
public RequestBody convert(T value) throws IOException {
  //if (String.class.getName().equals(value.getClass().getName())) {
  //  return RequestBody.create(MediaType.parse("text/plain"), value.toString());
  //}

  Buffer buffer = new Buffer();
  Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);
  JsonWriter jsonWriter = gson.newJsonWriter(writer);
  try {
    adapter.write(jsonWriter, value);
    jsonWriter.flush();
  } catch (IOException e) {
    throw new AssertionError(e); // Writing to Buffer does no I/O.
  } finally {
    jsonWriter.close();
  }

  return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
}
 

public static void writetxt(String txtPath, String txtCont)
{
	try
	{
		File f = new File(txtPath);
		if (!f.exists())
		{
			f.createNewFile();
		}
		OutputStreamWriter write = new OutputStreamWriter(new FileOutputStream(f,true), "UTF-8");
		BufferedWriter writer = new BufferedWriter(write);
		writer.write(txtCont);
		writer.close();
	} catch (Exception e)
	{
		e.printStackTrace();
	}
}
 

/**
 * Posts string data (i.e. JSON string) to the specified URL 
 * connection.
 *
 * @param con  The URL connection. Must be in HTTP POST mode. Must not 
 *             be {@code null}.
 * @param data The string data to post. Must not be {@code null}.
 *
 * @throws JSONRPC2SessionException If an I/O exception is encountered.
 */
private static void postString(final URLConnection con, final String data)
	throws JSONRPC2SessionException {
	
	try {
		OutputStreamWriter wr = new OutputStreamWriter(con.getOutputStream(), "UTF-8");
		wr.write(data);
		wr.flush();
		wr.close();

	} catch (IOException e) {

		throw new JSONRPC2SessionException(
				"Network exception: " + e.getMessage(),
				JSONRPC2SessionException.NETWORK_EXCEPTION,
				e);
	}
}
 

void copyFile(Path src, Path target) throws Exception {

        try (InputStream in = Files.newInputStream(src);
                BufferedReader reader
                = new BufferedReader(new InputStreamReader(in));
                OutputStream out = new BufferedOutputStream(
                        Files.newOutputStream(target, CREATE, APPEND));
                BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(out))) {
            String line = null;
            while ((line = reader.readLine()) != null) {
                bw.write(line);
            }
        } catch (IOException x) {
            throw new Exception(x.getMessage());
        }
    }
 

@Override
protected void handleStatusOk(final HttpServletRequest req, final HttpServletResponse resp, String escapdPathInfo)
		throws ServletException {

	try {
		final String body = catalogSupplier.get();
		try (final OutputStream os = resp.getOutputStream();
				final OutputStreamWriter osw = new OutputStreamWriter(os)) {
			osw.write(body);
			osw.flush();
		}
	} catch (final Exception e) {
		final String msg = "Error while assembling test catalog for all tests.";
		LOGGER.error(msg, e);
		throw new ServletException(msg, e);
	}

}
 

static public byte[] calulateHash(JsonElement contents) {
  MessageDigest md;
  try {
    md = MessageDigest.getInstance("MD5");
  } catch (NoSuchAlgorithmException e) {
    throw new InternalError("MD5 MessageDigest is not available");
  }
  OutputStream byteSink = new OutputStream() {
    @Override
    public void write(int b) throws IOException {
      // ignore, since this is only used to calculate MD5
    }
  };
  DigestOutputStream dis = new DigestOutputStream(byteSink, md);
  new Gson().toJson(contents, new OutputStreamWriter(dis, Charset.forName(DEFAULT_CHARSET_NAME)));
  return dis.getMessageDigest().digest();
}
 

/**
 * Writes the user's password to a tmp file with 0600 permissions.
 * @return the filename used.
 */
public static String writePasswordFile(Configuration conf)
    throws IOException {
  // Create the temp file to hold the user's password.
  String tmpDir = conf.get(
      ConfigurationConstants.PROP_JOB_LOCAL_DIRECTORY, "/tmp/");
  File tempFile = File.createTempFile("mysql-cnf", ".cnf", new File(tmpDir));

  // Make the password file only private readable.
  DirectImportUtils.setFilePermissions(tempFile, "0600");

  // If we're here, the password file is believed to be ours alone.  The
  // inability to set chmod 0600 inside Java is troublesome. We have to
  // trust that the external 'chmod' program in the path does the right
  // thing, and returns the correct exit status. But given our inability to
  // re-read the permissions associated with a file, we'll have to make do
  // with this.
  String password = DBConfiguration.getPassword((JobConf) conf);
  BufferedWriter w = new BufferedWriter(new OutputStreamWriter(
      new FileOutputStream(tempFile)));
  w.write("[client]\n");
  w.write("password=" + password + "\n");
  w.close();

  return tempFile.toString();
}
 

public T httpsPost(String jsonBody, Class<T> clazz) throws IOException {
URL url = new URL(HTTPS_PROTOCOL, ACCOUNT_KEY_SERVICE_HOST, HTTPS_PORT,
	ACCOUNT_KEY_ENDPOINT);
httpsConnection = (HttpsURLConnection) url.openConnection();
httpsConnection.setRequestMethod(HttpRequestMethod.POST.toString());
setConnectionParameters(httpsConnection, HttpRequestMethod.POST);

httpsConnection.setFixedLengthStreamingMode(jsonBody.getBytes().length);
try (OutputStreamWriter out = new OutputStreamWriter(
	httpsConnection.getOutputStream())) {
    out.write(jsonBody);
}
StringBuilder sb = new StringBuilder();
try (BufferedReader in = new BufferedReader(new InputStreamReader(
	httpsConnection.getInputStream()))) {
    String inputLine;
    while ((inputLine = in.readLine()) != null) {
	sb.append(inputLine);
    }
}
// setFieldNamingPolicy is used to here to convert from
// lower_case_with_underscore names retrieved from end point to camel
// case to match POJO class
Gson gson = new GsonBuilder().setFieldNamingPolicy(
	FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES).create();
return gson.fromJson(sb.toString(), clazz);
   }
 

private static FileObject createTestFile (FileObject root, String path, String fileName, String content) throws IOException {
    FileObject pkg = path != null ?
            FileUtil.createFolder(root, path) :
            root;
    assertNotNull (pkg);
    FileObject data = pkg.createData(fileName);
    FileLock lock = data.lock();
    try {
        PrintWriter out = new PrintWriter (new OutputStreamWriter (data.getOutputStream(lock)));
        try {
            out.println (content);
        } finally {
            out.close();
        }
    } finally {
        lock.releaseLock();
    }
    return data;
}
 

public static void main(String[] args) {
   try {
      ServerSocket ss = new ServerSocket(8888);
      System.out.println("opening the Server....");
      Socket s = ss.accept();
      System.out.println("Client:"+s.getInetAddress().getLocalHost()+"have connected to the Server");
      
      BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
      //read the message from the client
      String UserName = br.readLine();
      String PassWord = br.readLine();

      System.out.println("Name:"+UserName);
      System.out.println("PassWord:"+PassWord);



      BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
      bw.write("OK\n");
      bw.flush();
   } catch (IOException e) {
      e.printStackTrace();
   }
}
 

@Override
public FileObject createFromTemplate(FileObject template,
                                        FileObject targetFolder,
                                        String name,
                                        Map<String, Object> parameters) throws IOException {
    String nameUniq = FileUtil.findFreeFileName(targetFolder, name, template.getExt());
    FileObject newFile = FileUtil.createData(targetFolder, nameUniq + '.' + template.getExt());

    Charset templateEnc = FileEncodingQuery.getEncoding(template);
    Charset newFileEnc = FileEncodingQuery.getEncoding(newFile);

    InputStream is = template.getInputStream();
    Reader reader = new BufferedReader(new InputStreamReader(is, templateEnc));
    OutputStream os = newFile.getOutputStream();
    Writer writer = new BufferedWriter(new OutputStreamWriter(os, newFileEnc));
    int cInt;
    while ((cInt = reader.read()) != -1) {
        writer.write(cInt);
    }
    writer.close();
    reader.close();

    return newFile;
}
 

public Cfg() throws IOException {

            ByteArrayOutputStream os = new ByteArrayOutputStream();
            OutputStreamWriter w = new OutputStreamWriter(os);
            w.write("handlers=java.util.logging.FileHandler\n");
            w.write(".level=100\n");
            w.write("java.util.logging.FileHandler.pattern=" + log.toString().replace('\\', '/') +"\n");
            w.close();

            LogManager.getLogManager().readConfiguration(new ByteArrayInputStream(os.toByteArray()));
            
        }
 

public void sendContent(FacesContext context, OutputStream out)
  throws IOException
{
  Writer outw = new OutputStreamWriter(out, "UTF-8");
  UIXTable table = getTable();
  Object rowKey = table.getRowKey();
  for (int i = 0; i < table.getRowCount(); i++)
  {
    table.setRowIndex(i);
    if (!table.isRowAvailable())
      break;
    _exportRow(table, outw);
  }

  outw.flush();
  table.setRowKey(rowKey);
}
 

public void update() throws IOException {
	try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out))/*Files.newBufferedWriter(outputPath)*/) {
		writeHeader(writer);

		for (Iterator<ClassNode> it = application.iterator(); it.hasNext();) {
			final ClassNode clazz = it.next();
			if (hooks.isEmpty()) break;

			for (MethodNode method : clazz.methods) {
				for (Iterator<Hook> hit = hooks.iterator(); hit.hasNext();) {
					Hook hook = hit.next();
					if (hook.match(clazz, method, writer)) hit.remove();
				}
			}
		}

		writeFooter(writer);
	}

	if (!hooks.isEmpty()) {
		System.err.println(hooks);
		throw new RuntimeException("Unconsumed hooks");
	}
}
 

@Test
public void test48() throws Exception {
	byte[] buffer;

	String test = "M�nchen";

	ByteArrayOutputStream stream = new ByteArrayOutputStream();
	PrintWriter writer = new PrintWriter(new OutputStreamWriter(stream,
			Charset.forName("UTF-8")));
	writer.write(test);
	writer.close();

	buffer = stream.toByteArray();
	stream.close();

	CsvReader reader = new CsvReader(new InputStreamReader(
			new ByteArrayInputStream(buffer), Charset.forName("UTF-8")));
	Assert.assertTrue(reader.readRecord());
	Assert.assertEquals(test, reader.get(0));
	reader.close();
}
 

@ApiMethod
public static void write(File file, String text) throws Exception
{
   if (!file.exists())
      file.getParentFile().mkdirs();

   BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), "UTF-8"));
   bw.write(text);
   bw.flush();
   bw.close();
}
 

/**
 * Utility method to create a writer when passed an OutputStream. Make
 * sure to wrap an <code>OutputStreamWriter</code> using an
 * <code>XMLWriter</code> for performance reasons.
 *
 * @param os        Underlying OutputStream
 * @param encoding  Encoding used to convert chars into bytes
 */
private void setOutputUsingStream(OutputStream os, String encoding)
    throws IOException {
    fOutputStream = os;

    if (encoding != null) {
        if (encoding.equalsIgnoreCase("utf-8")) {
            fWriter = new UTF8OutputStreamWriter(os);
        }
        else {
            fWriter = new XMLWriter(new OutputStreamWriter(os, encoding));
            fEncoder = Charset.forName(encoding).newEncoder();
        }
    } else {
        encoding = SecuritySupport.getSystemProperty("file.encoding");
        if (encoding != null && encoding.equalsIgnoreCase("utf-8")) {
            fWriter = new UTF8OutputStreamWriter(os);
        } else {
            fWriter = new XMLWriter(new OutputStreamWriter(os));
        }
    }
}
 

@Override
public void writeTo(Object o,
                    Class<?> type,
                    Type genericType,
                    Annotation[] annotations,
                    MediaType mediaType,
                    MultivaluedMap<String,Object> httpHeaders,
                    OutputStream entityStream) throws IOException {
  Writer out = new OutputStreamWriter(entityStream, StandardCharsets.UTF_8);
  if (Iterable.class.isAssignableFrom(type)) {
    for (Object row : (Iterable<?>) o) {
      out.append(toCSV(row)).append('\n');
    }
  } else {
    out.append(toCSV(o)).append('\n');
  }
  out.flush();
}
 

/**
 * write lines.
 * 
 * @param os output stream.
 * @param lines lines.
 * @throws IOException
 */
public static void writeLines(OutputStream os, String[] lines) throws IOException
{
	PrintWriter writer = new PrintWriter(new OutputStreamWriter(os));
	try
	{
		for( String line : lines )
			writer.println(line);
		writer.flush();
	}
	finally
	{
		writer.close();
	}
}
 

private Supplier<FileObject> writeFile(
        @NonNull final FileObject folder,
        @NonNull final String name,
        @NonNull final Supplier<String> content) {
    return () -> {
        try {
            final FileObject file = FileUtil.createData(folder, name);
            try (PrintWriter out = new PrintWriter(new OutputStreamWriter(file.getOutputStream(), "UTF-8"))) {  //NOI18N
                out.println(content.get());
            }
            return file;
        } catch (IOException ioe) {
            throw new RuntimeException(ioe);
        }
    };
}
 

public SU(boolean root, String tag) {
    mRoot = root;
    mTag = tag;
    try {
        if (mTag != null) {
            Log.i(mTag, String.format("%s initialized", root ? "SU" : "SH"));
        }
        firstTry = true;
        mProcess = Runtime.getRuntime().exec(root ? "su" : "sh");
        mWriter = new BufferedWriter(new OutputStreamWriter(mProcess.getOutputStream()));
        mReader = new BufferedReader(new InputStreamReader(mProcess.getInputStream()));
    } catch (IOException e) {
        if (mTag != null) {
            Log.e(mTag, root ? "Failed to run shell as su" : "Failed to run shell as sh");
        }
        denied = true;
        closed = true;
    }
}
 

public void onClick(View v){
    try{
        File myFile = new File(v.getContext().getExternalFilesDir(null), "myFile.txt");
        myFile.createNewFile();

        FileOutputStream fOut = new FileOutputStream(myFile);
        OutputStreamWriter myOutWriter = new OutputStreamWriter(fOut);

        myOutWriter.append(this.TextArea.getText());
        myOutWriter.close();
        fOut.close();
    }
    catch (Exception e){
        e.printStackTrace();
    }
}
 

private void responseClient(Socket client) throws IOException {
    //用于接收客户端消息
    BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
    //用于向客户端发送消息
    PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(client.getOutputStream())), true);
    out.println("欢迎来到聊天室！");
    while (!mIsServiceDestroyed) {
        String str = in.readLine();
        System.out.println("msg from client: " + str);
        if (str == null) {
            break;
        }
        int i = new Random().nextInt(mDefinedMessages.length);
        String msg = mDefinedMessages[i];
        out.println(msg);
        System.out.println("send: " + msg);
    }
    System.out.println("client quit.");
    //关闭流
    MyUtil.close(out);
    MyUtil.close(in);
    client.close();
}
 

public ResponseWriter(
        final OutputStream outStream, 
        final String lineSeparator, 
        final String encoding) throws UnsupportedEncodingException {
    super(new BufferedWriter(new OutputStreamWriter(outStream, encoding)));
    this.outStream = outStream;
    this.encoding = encoding;
}
 

/**
 * Construct a new ResponseWriter, wrapping the specified writer and
 * attached to the specified response.
 *
 * @param writer OutputStreamWriter to which we are attached
 * @param stream ResponseStream to which we are attached
 */
public ResponseWriter(OutputStreamWriter writer, ResponseStream stream) {

    super(writer);
    this.stream = stream;
    this.stream.setCommit(false);

}
 

/**
 * 把内容写入文件
 * 
 * @param filePath
 * @param fileContent
 */
public static void write(String filePath, String fileContent) {

	try {
		FileOutputStream fo = new FileOutputStream(filePath);
		OutputStreamWriter out = new OutputStreamWriter(fo, "UTF-8");
		out.write(fileContent);
		out.close();
	} catch (IOException ex) {
		System.err.println("Create File Error!");
		ex.printStackTrace();
	}
}
 

/**
 * Creates a {@link CSVPrinter} instance
 *
 * @param delimiter    The delimiter
 * @param outputStream The outputStream where the csv will be printed to
 * @return The CSVPrinter
 * @throws IOException if any IO error occurs
 */
CSVPrinter createInstance(char delimiter, OutputStream outputStream) throws IOException {
    final OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream);
    return new CSVPrinter(outputStreamWriter,
            CSVFormat
                    .DEFAULT
                    .withDelimiter(delimiter)
                    .withTrim()
    );
}
 

public void write(char[] cbuf, int off, int len) throws IOException {

            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            OutputStreamWriter writer = m_encoding == null
                                        ? new OutputStreamWriter(baos)
                                        : new OutputStreamWriter(baos,
                                            m_charset);

            writer.write(cbuf, off, len);
            writer.close();
            m_randomAccessFile.write(baos.toByteArray());
        }
 

/**
 * SSL/TLS negotiation. Acquires an SSL socket of a control
 * connection and carries out handshake processing.
 * @throws java.io.IOException If server negotiation fails
 */
protected void sslNegotiation() throws IOException {
    plainSocket = _socket_;
    initSslContext();

    SSLSocketFactory ssf = context.getSocketFactory();
    String ip = _socket_.getInetAddress().getHostAddress();
    int port = _socket_.getPort();
    SSLSocket socket =
        (SSLSocket) ssf.createSocket(_socket_, ip, port, false);
    socket.setEnableSessionCreation(isCreation);
    socket.setUseClientMode(isClientMode);
    // server mode
    if (!isClientMode) {
        socket.setNeedClientAuth(isNeedClientAuth);
        socket.setWantClientAuth(isWantClientAuth);
    }

    if (protocols != null) {
        socket.setEnabledProtocols(protocols);
    }
    if (suites != null) {
        socket.setEnabledCipherSuites(suites);
    }
    socket.startHandshake();

    _socket_ = socket;
    _controlInput_ = new BufferedReader(new InputStreamReader(
            socket .getInputStream(), getControlEncoding()));
    _controlOutput_ = new BufferedWriter(new OutputStreamWriter(
            socket.getOutputStream(), getControlEncoding()));
}
 

public static void updateConjs(Connection con) throws SQLException, IOException {
    MyDictionary dictionary = new MyDictionary();
    Statement stmt = con.createStatement();
    long k = 0;
    ResultSet rs = stmt.executeQuery("SELECT \n"
            + "		lexem.formUtf8General as lemma,\n"
            + "             definition.internalRep as definition\n"
            + "from lexem \n"
            + "JOIN lexemdefinitionmap on lexemdefinitionmap.lexemId=lexem.Id \n"
            + "JOIN definition on definition.id = lexemdefinitionmap.definitionId \n"
            + "where definition.internalRep LIKE '%#conj.%' \n"
            + "ORDER BY lexem.formUtf8General");

    BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(MyDictionary.folder + "grabedForUse/" + conjsFile), "UTF8"));

    while (rs.next()) {
        MyDictionaryEntry entry = new MyDictionaryEntry(rs.getString("lemma"), null, null, null);
        entry.setLemma(rs.getString("lemma"));
        entry.setMsd("Cs");
        preprocessEntry(entry, 84);
        if (!dictionary.contains(entry)) {
            out.write(entry.toString() + "\n");
            dictionary.Add(entry);
            k++;
        }
    }
    stmt.close();
    rs.close();
    out.close();
    System.out.println("Finished conjunctions (" + k + " added)");
}
 

public StatusQuery(String ip, int port) {
	this.hostname = ip;
	this.port = port;
	
	try {
		socket = new Socket(ip, port);
		bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
	} catch (IOException e) {
		e.printStackTrace();
	}
	
}
 

/**
 * Open the new log file for the date specified by <code>dateStamp</code>.
 */
protected synchronized void open() {
    // Open the current log file
    // If no rotate - no need for dateStamp in fileName
    File pathname = getLogFile(rotatable && !renameOnRotate);

    Charset charset = null;
    if (encoding != null) {
        try {
            charset = B2CConverter.getCharset(encoding);
        } catch (UnsupportedEncodingException ex) {
            log.error(sm.getString(
                    "accessLogValve.unsupportedEncoding", encoding), ex);
        }
    }
    if (charset == null) {
        charset = Charset.defaultCharset();
    }

    try {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
                new FileOutputStream(pathname, true), charset), 128000),
                false);

        currentLogFile = pathname;
    } catch (IOException e) {
        writer = null;
        currentLogFile = null;
        log.error(sm.getString("accessLogValve.openFail", pathname), e);
    }
}
 

private void buildSurveyHtml() throws Exception{
		HttpServletRequest request=Struts2Utils.getRequest();
		HttpServletResponse response=Struts2Utils.getResponse();
		String url = "";
		String name = "";
		ServletContext sc = ServletActionContext.getServletContext();

		String file_name = request.getParameter("file_name");
		url = "/design/my-collect.action?surveyId=402880ea4675ac62014675ac7b3a0000";
		// 这是生成的html文件名,如index.htm.
		name = "/survey.htm";
		name = sc.getRealPath(name);
		
		RequestDispatcher rd = sc.getRequestDispatcher(url);
		final ByteArrayOutputStream os = new ByteArrayOutputStream();

		final ServletOutputStream stream = new ServletOutputStream() {
			public void write(byte[] data, int offset, int length) {
				os.write(data, offset, length);
			}

			public void write(int b) throws IOException {
				os.write(b);
			}
		};
		
		final PrintWriter pw = new PrintWriter(new OutputStreamWriter(os,"utf-8"));

		HttpServletResponse rep = new HttpServletResponseWrapper(response) {
			public ServletOutputStream getOutputStream() {
				return stream;
			}

			public PrintWriter getWriter() {
				return pw;
			}
		};

//		rd.include(request, rep);
		rd.forward(request,rep);
		pw.flush();
		
		// 把jsp输出的内容写到xxx.htm
		File file = new File(name);
		if (!file.exists()) {
			file.createNewFile();
		}
		FileOutputStream fos = new FileOutputStream(file);
		
		os.writeTo(fos);
		fos.close();
	}
 

/**
 * Method write.
 * 
 * @param actions
 * @param writer
 * @param document
 * @throws java.io.IOException
 */
public void write(ActionToGoalMapping actions, Document document, OutputStreamWriter writer)
    throws java.io.IOException
{
    Format format = Format.getRawFormat()
    .setEncoding(writer.getEncoding())
    .setLineSeparator(System.getProperty("line.separator"));
    write(actions, document, writer, format);
}
 

public static String encodeCanonical(JsonObject obj) {
    try {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        JsonWriterUnchecked writer = new JsonWriterUnchecked(new OutputStreamWriter(out, StandardCharsets.UTF_8));
        writer.setIndent("");
        writer.setHtmlSafe(false);
        writer.setLenient(false);

        encodeCanonical(obj, writer);
        writer.close();
        return out.toString(StandardCharsets.UTF_8.name());
    } catch (IOException e) {
        throw new JsonCanonicalException(e);
    }
}
 

private byte[] encodeFormParameters(HttpServletRequest request, String defaultEncoding) {
    try {
        String encoding = request.getCharacterEncoding();
        if (encoding == null) {
            encoding = defaultEncoding;
        }
        Map<String, List<String>> formParameters = parseFormParameters(request, encoding);
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        OutputStreamWriter writer = new OutputStreamWriter(outputStream, encoding);
        boolean firstFormParameter = true;
        for (Map.Entry<String, List<String>> formParameter : formParameters.entrySet()) {
            String formParameterName = formParameter.getKey();
            String encodedFormParameterName = URLEncoder.encode(formParameterName, encoding);
            for (String formParameterValue : formParameter.getValue()) {
                String encodedFormParameterValue = URLEncoder.encode(formParameterValue, encoding);
                if (firstFormParameter) {
                    firstFormParameter = false;
                } else {
                    writer.write('&');
                }
                writer.write(encodedFormParameterName);
                writer.write('=');
                writer.write(encodedFormParameterValue);
            }
        }
        writer.close();
        return outputStream.toByteArray();
    } catch (Throwable error) {
        LOGGER.error("failed to encode form parameters", error);
        return new byte[0];
    }
}
 

@Test
public void writesToByteArray() {
    final ByteArrayOutputStream baos = new ByteArrayOutputStream();
    final String content = "Hello, товарищ! How are you?";
    MatcherAssert.assertThat(
        "Can't copy Input to Writer",
        new TextOf(
            new TeeInput(
                new InputOf(content),
                new OutputTo(
                    new WriterAsOutputStream(
                        new OutputStreamWriter(
                            baos, StandardCharsets.UTF_8
                        ),
                        StandardCharsets.UTF_8,
                        // @checkstyle MagicNumber (1 line)
                        13
                    )
                )
            )
        ),
        new TextHasString(
            new MatcherOf<>(
                str -> {
                    return new String(
                        baos.toByteArray(), StandardCharsets.UTF_8
                    ).equals(str);
                }
            )
        )
    );
}
 

public static void updateRelPronouns(Connection con) throws SQLException, IOException {
    MyDictionary dictionary = new MyDictionary();
    Statement stmt = con.createStatement();
    long k = 0;
    ResultSet rs = stmt.executeQuery("SELECT \n"
            + "             inflectedform.formUtf8General as inflForm, \n"
            + "             inflectedform.inflectionId as inflId, \n"
            + "		lexem.formUtf8General as lemma,\n"
            + "             definition.internalRep as definition\n"
            + "FROM inflectedform \n"
            + "JOIN lexemmodel on inflectedform.lexemmodelId=lexemmodel.id \n"
            + "JOIN lexem on lexemmodel.lexemId=lexem.id \n"
            + "JOIN lexemdefinitionmap on lexemdefinitionmap.lexemId=lexem.Id \n"
            + "JOIN definition on definition.id = lexemdefinitionmap.definitionId \n"
            + "WHERE (inflectedform.inflectionId=84 || (inflectedform.inflectionId>40 && inflectedform.inflectionId<49)) AND definition.internalRep REGEXP '#pron\\..?.?#?(interog\\.|rel\\.|int\\.|inter\\.)' \n"
            + "ORDER BY inflectedform.formUtf8General");

    BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(MyDictionary.folder + "grabedForUse/" + pronRelFile), "UTF8"));
    while (rs.next()) {
        MyDictionaryEntry entry = new MyDictionaryEntry(rs.getString("inflForm"), null, null, null);
        entry.setLemma(rs.getString("lemma"));
        entry.setMsd("Pw");
        preprocessEntry(entry, rs.getInt("inflId"));

        if (!dictionary.contains(entry)) {
            out.write(entry.toString() + "\n");
            dictionary.Add(entry);
            k++;
        }
    }
    stmt.close();
    rs.close();
    out.close();
    System.out.println("Finished relative pronouns (" + k + " added)");
}
 

/**
 * method to write the kerberos config in the standard MIT kerberos format
 *
 * This is required cause the JGSS api is not able to recognize the port value set
 * in the system property java.security.krb5.kdc this issue makes it impossible
 * to set a kdc running non standard ports (other than 88)
 *
 * e.g localhost:6088
 *
 * <pre>
 * [libdefaults]
 *     default_realm = EXAMPLE.COM
 *
 * [realms]
 *     EXAMPLE.COM = {
 *         kdc = localhost:6088
 *     }
 * </pre>
 *
 * @return the full path of the config file
 */
private String createKrb5ConfFile( String realmName, String kdcHost, int kdcPort ) throws IOException
{
    StringBuilder sb = new StringBuilder();

    sb.append( "[libdefaults]" )
        .append( "\n\t" );
    sb.append( "default_realm = " )
        .append( realmName )
        .append( "\n" );

    sb.append( "[realms]" )
        .append( "\n\t" );

    sb.append( realmName )
        .append( " = {" )
        .append( "\n\t\t" );
    sb.append( "kdc = " )
        .append( kdcHost )
        .append( ":" )
        .append( kdcPort )
        .append( "\n\t}\n" );

    File krb5Conf = File.createTempFile( "client-api-krb5", ".conf" );
    krb5Conf.deleteOnExit();

    try ( Writer writer = new OutputStreamWriter( Files.newOutputStream( Paths.get( krb5Conf.getPath() ) ), 
        Charset.defaultCharset() ) )
    {
        writer.write( sb.toString() );
    }

    String krb5ConfPath = krb5Conf.getAbsolutePath();

    LOG.debug( "krb 5 config file created at {}", krb5ConfPath );

    return krb5ConfPath;
}
 

@Override
public void onClick(View view) {
    switch (view.getId()) {
        case R.id.bStart:
            startRecording();
            break;
        case R.id.bStop:
            stopRecording();
            break;
        case R.id.bExport:
            try {
                // create and write output file in cache directory
                File outputFile = new File(getActivity().getCacheDir(), "recording.csv");
                OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(outputFile));
                writer.write(Util.recordingToCSV(mRecording));
                writer.close();

                // get Uri from FileProvider
                Uri contentUri = FileProvider.getUriForFile(getActivity(), "com.martindisch.accelerometer.fileprovider", outputFile);

                // create sharing intent
                Intent shareIntent = new Intent();
                shareIntent.setAction(Intent.ACTION_SEND);
                // temp permission for receiving app to read this file
                shareIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
                shareIntent.setType("text/csv");
                shareIntent.putExtra(Intent.EXTRA_STREAM, contentUri);
                startActivity(Intent.createChooser(shareIntent, "Choose an app"));
            } catch (IOException e) {
                Toast.makeText(getActivity(), R.string.error_file, Toast.LENGTH_SHORT).show();
            }
            break;
    }
}
 

public void export(File out, int w, int h, int glaze) throws IOException {
	FileOutputStream fos = new FileOutputStream(out);
	OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
	PrintWriter pw = new PrintWriter(osw, true);
	export(pw, w, h, glaze);
	pw.flush();
	pw.close();
}
 

public static void writeFile(String fileName, String encoding, String content) throws IOException
{
	Writer out = new BufferedWriter(new OutputStreamWriter(
			new FileOutputStream(fileName), encoding));
	out.append(content);
	out.flush();
	out.close();
}
 

private synchronized void rebuildJournal() throws IOException {
    if (this.journalWriter != null) {
        this.journalWriter.close();
    }
    Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(this.journalFileTmp), Util.US_ASCII));
    try {
        writer.write(MAGIC);
        writer.write("\n");
        writer.write("1");
        writer.write("\n");
        writer.write(Integer.toString(this.appVersion));
        writer.write("\n");
        writer.write(Integer.toString(this.valueCount));
        writer.write("\n");
        writer.write("\n");
        for (Entry entry : this.lruEntries.values()) {
            if (entry.currentEditor != null) {
                writer.write("DIRTY " + entry.key + '\n');
            } else {
                writer.write("CLEAN " + entry.key + entry.getLengths() + '\n');
            }
        }
        writer.close();
        if (this.journalFile.exists()) {
            renameTo(this.journalFile, this.journalFileBackup, true);
        }
        renameTo(this.journalFileTmp, this.journalFile, false);
        this.journalFileBackup.delete();
        this.journalWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(this.journalFile, true), Util.US_ASCII));
    } catch (Throwable th) {
        writer.close();
    }
}
 

public void saveModel(Model model, String modelFile, boolean saveGzipped) {
    try {
        if (saveGzipped) {
            model.save(new OutputStreamWriter(new GZIPOutputStream(new FileOutputStream(modelFile + ".svm.gz")), "UTF-8"));
        } else {
            model.save(new File(modelFile));
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}
 

public Multipart(String requestURL, String encoding)
        throws IOException {
    this.encoding = encoding;
    URL url = new URL(requestURL);
    cnt = (HttpURLConnection) url.openConnection();
    cnt.setUseCaches(false);
    cnt.setDoOutput(true);
    cnt.setDoInput(true);
    cnt.setRequestProperty("Content-Type",
            "multipart/form-data; boundary=" + boundary);
    stream = cnt.getOutputStream();
    Writer writer = new OutputStreamWriter(stream, encoding);
    out = new PrintWriter(new BufferedWriter(writer));
}
 

/**
 * Persist data for recovering the given segment from disk.
 */
private void persistPaxosData(long segmentTxId,
    PersistedRecoveryPaxosData newData) throws IOException {
  File f = storage.getPaxosFile(segmentTxId);
  boolean success = false;
  AtomicFileOutputStream fos = new AtomicFileOutputStream(f);
  try {
    newData.writeDelimitedTo(fos);
    fos.write('\n');
    // Write human-readable data after the protobuf. This is only
    // to assist in debugging -- it's not parsed at all.
    OutputStreamWriter writer = new OutputStreamWriter(fos, Charsets.UTF_8);
    
    writer.write(String.valueOf(newData));
    writer.write('\n');
    writer.flush();
    
    fos.flush();
    success = true;
  } finally {
    if (success) {
      IOUtils.closeStream(fos);
    } else {
      fos.abort();
    }
  }
}
 

private void save() {
	FileFilter HTMLfilter = new FileFilter(".html", "Html");
	FileChooser fileChooser = new FileChooser(HTMLfilter);
	fileChooser.setFileFilter(HTMLfilter);
	//fileChooser.addChoosableFileFilter(XMLfilter);
	int r = fileChooser.showSaveDialog(TextualPanel.this);
	if (r == JFileChooser.APPROVE_OPTION) {
		File file = fileChooser.getSelectedFile();
		if (fileChooser.getFileFilter().equals(HTMLfilter)) {
			try {

				String Title = new String("<font size=\"4\"><b>Burstiness Results</b><br><br>");
				String temp = new String(synView.getText());
				OutputStreamWriter fileStream = new OutputStreamWriter(new FileOutputStream(file));
				fileStream.write(Title);
				fileStream.write(temp);
				fileStream.flush();
				fileStream.close();
			} catch (FileNotFoundException fnf) {
				JOptionPane.showMessageDialog(fileChooser, "File not found", "JMT - Error", JOptionPane.ERROR_MESSAGE);
			} catch (IOException ioe) {
				JOptionPane.showMessageDialog(fileChooser, "I/O exception", "JMT - Error", JOptionPane.ERROR_MESSAGE);
			}
		}

	}

}
 

/**
 * constructor.
 * creates a csv file for writing data to it
 * @param file the file to write data to
 * @param encoding encoding to use or null (=defualt)
 */
public CSVWriter(File file, String encoding) throws IOException {

    if (encoding == null) {
        encoding = System.getProperty("file.encoding");
    }

    FileOutputStream fout = new FileOutputStream(file);

    writer = new OutputStreamWriter(fout, encoding);
}
 

/**
 * 生成静态页面主方法
 * 
 * @param context
 *            ServletContext
 * @param data
 *            一个Map的数据结果集
 * @param templatePath
 *            ftl模版路径
 * @param targetHtmlPath
 *            生成静态页面的路径
 */
public static void crateHTML(ServletContext context, Object data, String templatePath, String targetHtmlPath) {
    Configuration freemarkerCfg = new Configuration();
    // 加载模版
    freemarkerCfg.setServletContextForTemplateLoading(context, "/");
    freemarkerCfg.setEncoding(Locale.getDefault(), "UTF-8");
    try {
        // 指定模版路径
        Template template = freemarkerCfg.getTemplate(templatePath, "UTF-8");
        template.setEncoding("UTF-8");
        // 静态页面路径
        String htmlPathString = context.getRealPath("/") + "/" + targetHtmlPath;
        File htmlFile = new File(htmlPathString);

        if (!htmlFile.getParentFile().exists()) {
            htmlFile.getParentFile().mkdirs();
        }
        htmlFile.createNewFile();
        Writer out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(htmlFile), "UTF-8"));
        // 处理模版
        template.process(data, out);
        out.flush();
        out.close();
    } catch (Exception e) {
        logger.error("error occured where generate Html file.", e);
    }
}
 

private void checkTokenSequence(String resource) throws Exception {
    clearWorkDir();
    String text = lexDocument(resource);
    String path = getClass().getName();
    path = path.substring(0, path.lastIndexOf('.')).replace('.', '/');
    
    FileObject w = FileUtil.toFileObject(getWorkDir()).createData(resource + ".out");
    File g = new File(getDataDir(), "goldenfiles/" + path + "/" + resource + ".pass");
    try (OutputStream o = w.getOutputStream(); 
        OutputStreamWriter wr = new OutputStreamWriter(o)) {
        wr.write(text);
    }
    File d = new File(getWorkDir(), resource + ".diff");
    assertFile(FileUtil.toFile(w), g, d);
}
 

/**
 * 合并多个词典
 * @param path 多个词典的路径，第一个是主词典。主词典与其他词典的区别详见com.hankcs.hanlp.corpus.dictionary.TFDictionary#combine(com.hankcs.hanlp.corpus.dictionary.TFDictionary, int, boolean)
 * @return 词条的增量
 */
public static int combine(String... path)
{
    TFDictionary dictionaryMain = new TFDictionary();
    dictionaryMain.load(path[0]);
    int preSize = dictionaryMain.trie.size();
    for (int i = 1; i < path.length; ++i)
    {
        TFDictionary dictionary = new TFDictionary();
        dictionary.load(path[i]);
        dictionaryMain.combine(dictionary, 1, true);
    }
    try
    {
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(IOUtil.newOutputStream(path[0]), "UTF-8"));
        for (Map.Entry<String, TermFrequency> entry : dictionaryMain.trie.entrySet())
        {
            bw.write(entry.getKey());
            bw.write(' ');
            bw.write(String.valueOf(entry.getValue().getValue()));
            bw.newLine();
        }
        bw.close();
    }
    catch (Exception e)
    {
        e.printStackTrace();
        return -1;
    }

    return dictionaryMain.trie.size() - preSize;
}
 

/**
 * constructor.
 * creates a csv file for writing data to it
 * @param file the file to write data to
 * @param encoding encoding to use or null (=defualt)
 */
public CSVWriter(File file, String encoding) throws IOException {

    if (encoding == null) {
        encoding = System.getProperty("file.encoding");
    }

    FileOutputStream fout = new FileOutputStream(file);

    writer = new OutputStreamWriter(fout, encoding);
}
 

@Override
public OctaveEngine makeObject() {
    final OctaveEngineFactory factory = new OctaveEngineFactory();
    factory.setErrorWriter(new OutputStreamWriter(new Slf4jWarnOutputStream(IScriptTaskRunnerMatlab.LOG)));
    if (JavaOctaveProperties.OCTAVE_COMMAND != null) {
        factory.setOctaveProgram(new File(JavaOctaveProperties.OCTAVE_COMMAND));
    }
    final OctaveEngine scriptEngine = factory.getScriptEngine();
    scriptEngine.setWriter(new OutputStreamWriter(new Slf4jDebugOutputStream(IScriptTaskRunnerMatlab.LOG)));
    return scriptEngine;
}
 

/**
 * Makes an HTTP request using POST method to the specified URL.
 *
 * @param requestURL
 *            the URL of the remote server
 * @param params
 *            A map containing POST data in form of key-value pairs
 * @return An HttpURLConnection object
 * @throws IOException
 *             thrown if any I/O error occurred
 */
public static HttpURLConnection sendPostRequest(String requestURL,
        Map<String, String> params) throws IOException {
    URL url = new URL(requestURL);
    httpConn = (HttpURLConnection) url.openConnection();
    httpConn.setUseCaches(false);
 
    httpConn.setDoInput(true); // true indicates the server returns response
 
    StringBuffer requestParams = new StringBuffer();
 
    if (params != null && params.size() > 0) {
 
        httpConn.setDoOutput(true); // true indicates POST request
 
        // creates the params string, encode them using URLEncoder
        Iterator<String> paramIterator = params.keySet().iterator();
        while (paramIterator.hasNext()) {
            String key = paramIterator.next();
            String value = params.get(key);
            requestParams.append(URLEncoder.encode(key, "UTF-8"));
            requestParams.append("=").append(
                    URLEncoder.encode(value, "UTF-8"));
            requestParams.append("&");
        }
 
        // sends POST data
        OutputStreamWriter writer = new OutputStreamWriter(
                httpConn.getOutputStream());
        writer.write(requestParams.toString());
        writer.flush();
    }
 
    return httpConn;
}