java类java.io.InputStreamReader的实例源码

/**
 * Get the readme file as a string.
 */
protected String getReadme(DirContext directory)
    throws IOException, ServletException {

    if (readmeFile != null) {
        try {
            Object obj = directory.lookup(readmeFile);
            if ((obj != null) && (obj instanceof Resource)) {
                StringWriter buffer = new StringWriter();
                InputStream is = ((Resource) obj).streamContent();
                copyRange(new InputStreamReader(is),
                        new PrintWriter(buffer));
                return buffer.toString();
            }
        } catch (NamingException e) {
            if (debug > 10)
                log("readme '" + readmeFile + "' not found", e);

            return null;
        }
    }

    return null;
}

/**
 * Read the PEM file and save the DER encoded octet
 * stream and begin marker.
 * 
 * @throws IOException
 */
protected void readFile() throws IOException {

    String  line;
    BufferedReader reader = new BufferedReader(
            new InputStreamReader(stream));
    try {
        while ((line = reader.readLine()) != null)
        {
            if (line.indexOf(BEGIN_MARKER) != -1)
            {
                beginMarker = line.trim();
                String endMarker = beginMarker.replace("BEGIN", "END");
                derBytes = readBytes(reader, endMarker);
                return;
            }
        }           
        throw new IOException("Invalid PEM file: no begin marker");
    } finally {
        reader.close();
    }
}

/**
 * Reads an LDIF into a collection of LDAP entries. The components performs a simple property
 * replacement in the LDIF data where <pre>${ldapBaseDn}</pre> is replaced with the environment-specific base
 * DN.
 *
 * @param ldif LDIF resource, typically a file on filesystem or classpath.
 * @param baseDn The directory branch where the entry resides.
 *
 * @return LDAP entries contained in the LDIF.
 *
 * @throws IOException On IO errors reading LDIF.
 */
public static Collection<LdapEntry> readLdif(final InputStream ldif, final String baseDn) throws IOException {
    final StringBuilder builder = new StringBuilder();
    try (final BufferedReader reader = new BufferedReader(new InputStreamReader(ldif))) {
        String line;
        while ((line = reader.readLine()) != null) {
            if (line.contains(BASE_DN_PLACEHOLDER)) {
                builder.append(line.replace(BASE_DN_PLACEHOLDER, baseDn));
            } else {
                builder.append(line);
            }
            builder.append(NEWLINE);
        }
    }
    return new LdifReader(new StringReader(builder.toString())).read().getEntries();
}

public static void main(String[] args) throws Exception {
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

    //напишите тут ваш код
    int [] vct = new int[5];

    for (int i=0;i<vct.length;i++) {
        vct[i] = Integer.parseInt(reader.readLine());
    }

    int tmp;
    for (int i=0;i<vct.length;i++)
        for (int j=i+1; j<vct.length; j++)
            if (vct[i]>vct[j]){
                tmp = vct[i];
                vct[i] = vct[j];
                vct[j] = tmp;
            }


    for (int i=0; i<vct.length; i++) {
        System.out.println(vct[i]);
    }
}

private void loadUserList() throws IOException {
    String delimiter = PropertyLoader.getInstance()
            .load(COMMON_PROPERTIES_PATH).getProperty(DELIMITER);
    try (InputStream in = Thread.currentThread().getContextClassLoader()
            .getResourceAsStream("UserList");
            BufferedReader reader = new BufferedReader(
                    new InputStreamReader(in));) {
        userList = new HashMap<String, String>();
        String data = null;
        while ((data = reader.readLine()) != null) {
            if (!data.trim().isEmpty()) {
                String[] userData = data.split(delimiter);
                userList.put(userData[0], userData[1]);
            }
        }
    }
}

private StringBuilder readFile(final File file) {        
    StringBuilder sb = new StringBuilder();
    try {
        final Reader in = new InputStreamReader (new FileInputStream (file),"UTF-8");   //NOI18N
        try {
            char[] buffer = new char[1024];
            int len;
            while ((len=in.read(buffer))>0) {
                sb.append(buffer, 0, len);
            }
        } finally {
            in.close();
        }
    } catch (IOException ioe) {
        if (sb.length() != 0) {
            sb = new StringBuilder();
        }
    }
    return sb;
}

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

/**
 * 
 * @param accessToken
 * @return JSON with user info
 * @throws IOException
 */
public String getUserInformation(String accessToken) throws IOException {
    String endpoint = AuthProperties.inst().getUserInformationEndpoint();

    URL url = new URL(endpoint);
    HttpURLConnection con = (HttpURLConnection) url.openConnection();

    String authorizationHeader = String.format("Bearer %s", accessToken);
    con.addRequestProperty("Authorization", authorizationHeader);

    con.setRequestMethod("GET");
    con.connect();

    BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();

    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }

    in.close();

    return response.toString();
}

/**
 * Returns a DataFrame parsed from the stream specified stream
 * @param stream    the stream to parse
 * @return          the DataFrame parsed from stream
 * @throws IOException      if there stream read error
 */
private DataFrame<R,String> parse(CsvSourceOptions<R> options, InputStream stream) throws IOException {
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, options.getCharset().orElse(StandardCharsets.UTF_8)))) {
        final CsvRequestHandler handler = new CsvRequestHandler(options);
        final CsvParserSettings settings = new CsvParserSettings();
        settings.getFormat().setDelimiter(options.getDelimiter());
        settings.setHeaderExtractionEnabled(options.isHeader());
        settings.setLineSeparatorDetectionEnabled(true);
        settings.setRowProcessor(handler);
        settings.setIgnoreTrailingWhitespaces(true);
        settings.setIgnoreLeadingWhitespaces(true);
        settings.setMaxColumns(10000);
        settings.setReadInputOnSeparateThread(false);
        final CsvParser parser = new CsvParser(settings);
        parser.parse(reader);
        return handler.getFrame();
    }
}

@Override
public javax.swing.text.Document loadSwingDocument(InputStream in)
throws IOException, BadLocationException {

    javax.swing.text.Document sd = new PlainDocument();
    BufferedReader br = new BufferedReader(new InputStreamReader(in));
    try {
        String line = null;
        while ((line = br.readLine()) != null) {
            sd.insertString(sd.getLength(), line+System.getProperty("line.separator"), null); // NOI18N
        }
    } finally {
        br.close();
    }
    return sd;
}