Example usage for java.util Scanner hasNext

List of usage examples for java.util Scanner hasNext

  1. HOME
  2. Java
  3. java
  4. java.util.*
  5. Scanner
  6. hasNext

Introduction

In this page you can find the example usage for java.util Scanner hasNext.

Prototype

public boolean hasNext()

Source Link

Document

Returns true if this scanner has another token in its input.

Usage

From source file:MainClass.java

public static void main(String args[]) throws IOException {

    FileWriter fout = new FileWriter("test.txt");
    fout.write("2, 3.4,    5,6, 7.4, 9.1, 10.5, done");
    fout.close();/*from w ww .  j av  a2 s .  c  o m*/

    FileReader fin = new FileReader("Test.txt");
    Scanner src = new Scanner(fin);
    // Set delimiters to space and comma.
    // ", *" tells Scanner to match a comma and zero or more spaces as
    // delimiters.

    src.useDelimiter(", *");

    // Read and sum numbers.
    while (src.hasNext()) {
        if (src.hasNextDouble()) {
            System.out.println(src.nextDouble());
        } else {
            break;
        }
    }
    fin.close();
}

From source file:org.slc.sli.encryption.tool.Encryptor.java

/**
 * New functionality allows encrypting using the same algorithm
 * the api uses for encrypting PII fields in MongoDB.
 *
 * for example://from w ww  .j a va 2  s. co  m
  java -jar encryption-tool.java --decrypt
  ../data-access/dal/keyStore/localKeyStore.jks
  ../data-access/dal/keyStore/localEncryption.properties
  aDvgicSt81j/YdPUhvr4Ig==
        
 * or to encrypt:
  java -jar encryption-tool.java
  ../data-access/dal/keyStore/localKeyStore.jks
  ../data-access/dal/keyStore/localEncryption.properties
  Lauretta
        
 * you can also exclude the message at the end, then this program works
 * in streaming mode: every line received from System.in is en/decrypted
 * and returned to System.out
        
 * @param args
 * @throws Exception
 */

public static void main(String[] args) throws Exception {
    PrintStream out = System.out;
    if (args.length < 2 || args.length > 6) {
        out.println("For encryption:");
        out.println(
                "Usage: java -jar encryption-tool.jar <keystore_location> <keystore_password> <key_alias> <key_password> <string>");
        out.println("For decryption");
        out.println(
                "Usage: java -jar encryption-tool.jar --decrypt <keystore_location> <keystore_password> <key_alias> <key_password> <string>");
        out.println();
        out.println("Using a properties file: \n  Property names must end with the following values. ");
        out.println("  " + KEYSTOREPASS + " (required)");
        out.println("  " + DALKEYALIAS + " (required)");
        out.println("  " + DALKEYPASS + " (required) ");
        out.println("  " + DALINITVEC + " (optional)");
        out.println("  " + DALALGORITHM + "(optional, defaults to \"AES/CBC/PKCS5Padding\")");

        out.println("Encryption:");
        out.println(
                "  Usage: java jar encyption-tool-1.0-jar <keystore_location> <properties_file> [<string>]");
        out.println("Decryption:");
        out.println(
                "  Usage: java jar encyption-tool-1.0-jar -decrypt <keystore_location> <properties_file> [<string>]");

        return;
    }

    boolean decrypt = false;
    String[] effectiveArgs = args;
    if (args[0].equals("--decrypt")) {
        decrypt = true;
        effectiveArgs = new String[args.length - 1];
        System.arraycopy(args, 1, effectiveArgs, 0, args.length - 1);
    }

    String propertiesLocation = null;
    String keystoreLocation = null;
    String keystorePassword = null;
    String keyAlias = null;
    String keyPassword = null;
    String message = null;
    String initVector = null;
    String algorithm = "AES/CBC/PKCS5Padding";

    if (args.length == 5 || args.length == 6) {
        //OLDER FUNCTIONALITY
        keystoreLocation = effectiveArgs[0];
        keystorePassword = effectiveArgs[1];
        keyAlias = effectiveArgs[2];
        keyPassword = effectiveArgs[3];
        message = effectiveArgs[4];

        Encryptor encryptor = new Encryptor(keystoreLocation, keystorePassword);

        if (!decrypt) {
            String encryptedString = encryptor.encrypt(keyAlias, keyPassword, message);
            out.println("Encrypted string for " + message + " is: " + encryptedString + "\n");
        } else {
            String decryptedString = encryptor.decrypt(keyAlias, keyPassword, message);
            out.println("Descrypted string for " + message + " is: " + decryptedString + "\n");
        }

    } else {
        //NEWER FUNCTIONALITY
        keystoreLocation = effectiveArgs[0];
        propertiesLocation = effectiveArgs[1];

        if (effectiveArgs.length == 3) {
            message = effectiveArgs[2];
        } else {
            message = null;
        }

        Map<String, String> properties = parsePropertiesFile(propertiesLocation);

        keystorePassword = properties.get(KEYSTOREPASS);
        keyPassword = properties.get(DALKEYPASS);
        keyAlias = properties.get(DALKEYALIAS);

        if (properties.containsKey(DALINITVEC)) {
            initVector = properties.get(DALINITVEC);
        }
        if (properties.containsKey(DALALGORITHM)) {
            algorithm = properties.get(DALALGORITHM);
        }

        Encryptor encryptor = new Encryptor(keystoreLocation, keystorePassword);

        if (!decrypt) {
            if (message != null) {
                String encrypted = encryptor.encrypt(keyAlias, keyPassword, algorithm, initVector, message);
                out.println(encrypted);
            } else {
                Scanner s = new Scanner(System.in);
                s.useDelimiter("\n");
                while (s.hasNext()) {
                    String cleartext = s.next();
                    String encrypted = encryptor.encrypt(keyAlias, keyPassword, algorithm, initVector,
                            cleartext);
                    out.println(encrypted);
                }
            }
        } else {
            if (message != null) {
                String decrypted = encryptor.decrypt(keyAlias, keyPassword, algorithm, initVector, message);
                out.println(decrypted);
            } else {
                Scanner s = new Scanner(System.in);
                s.useDelimiter("\n");
                while (s.hasNext()) {
                    String ciphertext = s.next().trim();
                    String decrypted = encryptor.decrypt(keyAlias, keyPassword, algorithm, initVector,
                            ciphertext);
                    out.println(decrypted);
                }
            }
        }
    }
}

From source file:com.sds.acube.ndisc.xadmin.XNDiscAdminUtil.java

public static void main(String args[]) {

    if (args.length == 0) {
        XNDiscAdminUtil.printAdminUsage(null, null);
        // System.exit(0);
    }/*w  ww  . j  a  v a2  s .c o m*/

    XNDiscAdminFile file = new XNDiscAdminFile(printlog, out, logger);
    XNDiscAdminMedia media = new XNDiscAdminMedia(printlog, out, logger);
    XNDiscAdminVolume volume = new XNDiscAdminVolume(printlog, out, logger);
    XNDiscAdminEnDecrypt endecrypt = new XNDiscAdminEnDecrypt(printlog, out, logger);

    Scanner in = new Scanner(System.in);
    String input = "";
    List<String> options = null;
    Scanner part = null;
    do {
        input = in.nextLine();
        part = new Scanner(input).useDelimiter(" ");
        options = new ArrayList<String>();
        while (part.hasNext()) {
            String val = part.next().trim();
            if (StringUtils.isEmpty(val)) {
                continue;
            }
            options.add(val);
        }
        if (options.size() < 2 || input.equalsIgnoreCase("q")) {
            if (input != null && input.trim().equalsIgnoreCase("q")) {
                System.out.println(LINE_SEPERATOR + "XNDiscAdminUtil quit!!!" + LINE_SEPERATOR);
            } else {
                System.out
                        .println(LINE_SEPERATOR + "XNDiscAdminUtil are invalid parameters!!!" + LINE_SEPERATOR);
            }
            System.exit(0);
        }

        String main_op = (StringUtils.isEmpty(options.get(0))) ? "" : options.get(0);
        String process_op = (StringUtils.isEmpty(options.get(1))) ? "" : options.get(1);
        if (main_op.equals("clear")) {
            if (process_op.equals("screen")) {
                clearConsoleOutput();
            }
        } else if (main_op.equals("file")) {
            if (process_op.equals("ls")) {
                String fileid = "";
                if (options.size() > 2) {
                    fileid = options.get(2);
                }
                if (StringUtils.isEmpty(fileid)) {
                    file.selectFileList();
                } else {
                    file.selectFileById(fileid);
                }
            } else if (process_op.equals("reg")) {
                String host = "";
                int port = -1;
                String filepath = "";
                int vol = -1;
                if (options.size() == 4) {
                    host = XNDiscAdminConfig.getString(XNDiscAdminConfig.HOST);
                    port = XNDiscAdminConfig.getInt(XNDiscAdminConfig.PORT);
                    filepath = options.get(2);
                    if (isInteger(options.get(3))) {
                        vol = Integer.parseInt(options.get(3));
                    }
                } else if (options.size() > 5) {
                    host = options.get(2);
                    port = Integer.parseInt(options.get(3));
                    filepath = options.get(4);
                    if (isInteger(options.get(5))) {
                        vol = Integer.parseInt(options.get(5));
                    }
                }
                if (!StringUtils.isEmpty(host) && !StringUtils.isEmpty(filepath) && port > 0 && vol > 0) {
                    file.regFile(host, port, filepath, vol, "0");
                } else {
                    XNDiscAdminUtil.printAdminUsage(main_op, process_op);
                }
            } else if (process_op.equals("get")) {
                String host = "";
                int port = -1;
                String fileid = "";
                String filepath = "";
                if (options.size() == 4) {
                    host = XNDiscAdminConfig.getString(XNDiscAdminConfig.HOST);
                    port = XNDiscAdminConfig.getInt(XNDiscAdminConfig.PORT);
                    fileid = options.get(2);
                    filepath = options.get(3);
                } else if (options.size() > 5) {
                    host = options.get(2);
                    if (isInteger(options.get(3))) {
                        port = Integer.parseInt(options.get(3));
                    }
                    fileid = options.get(4);
                    filepath = options.get(5);
                }
                if (!StringUtils.isEmpty(host) && !StringUtils.isEmpty(fileid) && !StringUtils.isEmpty(filepath)
                        && port > 0) {
                    file.getFile(host, port, fileid, filepath);
                } else {
                    XNDiscAdminUtil.printAdminUsage(main_op, process_op);
                }
            } else if (process_op.equals("wh")) {
                String fileid = "";
                if (options.size() > 2) {
                    fileid = options.get(2);
                }
                if (!StringUtils.isEmpty(fileid)) {
                    file.getFilePathByFileId(fileid);
                } else {
                    XNDiscAdminUtil.printAdminUsage(main_op, process_op);
                }
            } else if (process_op.equals("rm")) {
                String host = "";
                int port = -1;
                String fileid = "";
                if (options.size() == 3) {
                    host = XNDiscAdminConfig.getString(XNDiscAdminConfig.HOST);
                    port = XNDiscAdminConfig.getInt(XNDiscAdminConfig.PORT);
                    fileid = options.get(2);
                } else if (options.size() > 4) {
                    host = options.get(2);
                    if (isInteger(options.get(3))) {
                        port = Integer.parseInt(options.get(3));
                    }
                    fileid = options.get(4);
                }
                if (!StringUtils.isEmpty(host) && !StringUtils.isEmpty(fileid) && port > 0) {
                    file.removeFile(host, port, fileid);
                } else {
                    XNDiscAdminUtil.printAdminUsage(main_op, process_op);
                }
            }
        } else if (main_op.equals("media")) {
            if (process_op.equals("mk")) {
                String host = "";
                int port = -1;
                String name = "";
                int type = 0;
                String path = "";
                String desc = " ";
                int maxsize = -1;
                int vol = -1;
                if (options.size() == 7) {
                    host = XNDiscAdminConfig.getString(XNDiscAdminConfig.HOST);
                    port = XNDiscAdminConfig.getInt(XNDiscAdminConfig.PORT);
                    name = options.get(2);
                    if (isInteger(options.get(3))) {
                        type = Integer.parseInt(options.get(3));
                    }
                    path = options.get(4);
                    if (isInteger(options.get(5))) {
                        maxsize = Integer.parseInt(options.get(5));
                    }
                    if (isInteger(options.get(6))) {
                        vol = Integer.parseInt(options.get(6));
                    }
                } else if (options.size() == 8) {
                    host = XNDiscAdminConfig.getString(XNDiscAdminConfig.HOST);
                    port = XNDiscAdminConfig.getInt(XNDiscAdminConfig.PORT);
                    name = options.get(2);
                    if (isInteger(options.get(3))) {
                        type = Integer.parseInt(options.get(3));
                    }
                    path = options.get(4);
                    desc = options.get(5) + " ";
                    if (isInteger(options.get(6))) {
                        maxsize = Integer.parseInt(options.get(6));
                    }
                    if (isInteger(options.get(7))) {
                        vol = Integer.parseInt(options.get(7));
                    }
                } else if (options.size() == 9) {
                    host = options.get(2);
                    if (isInteger(options.get(3))) {
                        port = Integer.parseInt(options.get(3));
                    }
                    name = options.get(4);
                    if (isInteger(options.get(5))) {
                        type = Integer.parseInt(options.get(5));
                    }
                    path = options.get(6);
                    if (isInteger(options.get(7))) {
                        maxsize = Integer.parseInt(options.get(7));
                    }
                    if (isInteger(options.get(8))) {
                        vol = Integer.parseInt(options.get(8));
                    }
                } else if (options.size() > 9) {
                    host = options.get(2);
                    if (isInteger(options.get(3))) {
                        port = Integer.parseInt(options.get(3));
                    }
                    name = options.get(4);
                    if (isInteger(options.get(5))) {
                        type = Integer.parseInt(options.get(5));
                    }
                    path = options.get(6);
                    desc = options.get(7) + " ";
                    if (isInteger(options.get(8))) {
                        maxsize = Integer.parseInt(options.get(8));
                    }
                    if (isInteger(options.get(9))) {
                        vol = Integer.parseInt(options.get(9));
                    }
                }
                if (!StringUtils.isEmpty(host) && !StringUtils.isEmpty(name) && !StringUtils.isEmpty(path)
                        && port > 0 && vol > 0 && maxsize > 0) {
                    media.makeMedia(host, port, name, type, path, desc, maxsize, vol);
                } else {
                    XNDiscAdminUtil.printAdminUsage(main_op, process_op);
                }
            } else if (process_op.equals("ls")) {
                String mediaid = "-1";
                if (options.size() > 2) {
                    mediaid = options.get(2);
                }
                if (StringUtils.isEmpty(mediaid) || mediaid.equals("-1")) {
                    media.selectMediaList();
                } else {
                    int id = -1;
                    if (isInteger(mediaid)) {
                        id = Integer.parseInt(mediaid);
                    }
                    if (id > 0) {
                        media.selectMediaById(id);
                    } else {
                        XNDiscAdminUtil.printAdminUsage(main_op, process_op);
                    }
                }
            } else if (process_op.equals("rm")) {
                String mediaid = "-1";
                if (options.size() > 2) {
                    mediaid = options.get(2);
                }
                if (!StringUtils.isEmpty(mediaid)) {
                    int id = -1;
                    if (isInteger(mediaid)) {
                        id = Integer.parseInt(options.get(2));
                    }
                    if (id > 0) {
                        media.removeMedia(id);
                    } else {
                        XNDiscAdminUtil.printAdminUsage(main_op, process_op);
                    }
                }
            } else if (process_op.equals("ch")) {
                int mediaid = -1;
                String name = "";
                int type = 0;
                String path = "";
                String desc = "";
                int maxsize = -1;
                int vol = -1;
                if (options.size() == 8) {
                    if (isInteger(options.get(2))) {
                        mediaid = Integer.parseInt(options.get(2));
                    }
                    name = options.get(3);
                    if (isInteger(options.get(4))) {
                        type = Integer.parseInt(options.get(4));
                    }
                    path = options.get(5);
                    if (isInteger(options.get(6))) {
                        maxsize = Integer.parseInt(options.get(6));
                    }
                    if (isInteger(options.get(7))) {
                        vol = Integer.parseInt(options.get(7));
                    }
                } else if (options.size() > 8) {
                    if (isInteger(options.get(2))) {
                        mediaid = Integer.parseInt(options.get(2));
                    }
                    name = options.get(3);
                    if (isInteger(options.get(4))) {
                        type = Integer.parseInt(options.get(4));
                    }
                    path = options.get(5);
                    desc = options.get(6);
                    if (isInteger(options.get(7))) {
                        maxsize = Integer.parseInt(options.get(7));
                    }
                    if (isInteger(options.get(8))) {
                        vol = Integer.parseInt(options.get(8));
                    }
                }
                if (!StringUtils.isEmpty(name) && !StringUtils.isEmpty(path) && mediaid > 0 && maxsize > 0
                        && vol > 0) {
                    media.changeMedia(mediaid, name, type, path, desc, maxsize, vol);
                } else {
                    XNDiscAdminUtil.printAdminUsage(main_op, process_op);
                }
            }
        } else if (main_op.equals("vol")) {
            if (process_op.equals("mk")) {
                String name = "";
                String access = "";
                String desc = " ";
                if (options.size() == 4) {
                    name = options.get(2);
                    access = options.get(3);
                } else if (options.size() > 4) {
                    name = options.get(2);
                    access = options.get(3);
                    desc = options.get(4) + " ";
                }
                if (!StringUtils.isEmpty(name) && !StringUtils.isEmpty(access)) {
                    volume.makeVolume(name, access, desc);
                } else {
                    XNDiscAdminUtil.printAdminUsage(main_op, process_op);
                }
            } else if (process_op.equals("ls")) {
                String volid = "-1";
                if (options.size() > 2) {
                    volid = options.get(2);
                }
                if (StringUtils.isEmpty(volid) || volid.equals("-1")) {
                    volume.selectVolumeList();
                } else {
                    int volumeid = -1;
                    if (isInteger(volid)) {
                        volumeid = Integer.parseInt(volid);
                    }
                    if (volumeid > 0) {
                        volume.selectVolumeById(volumeid);
                    } else {
                        XNDiscAdminUtil.printAdminUsage(main_op, process_op);
                    }
                }
            } else if (process_op.equals("rm")) {
                String volid = "-1";
                if (options.size() > 2) {
                    volid = options.get(2);
                }
                if (!StringUtils.isEmpty(volid)) {
                    int volumeid = -1;
                    if (isInteger(volid)) {
                        volumeid = Integer.parseInt(volid);
                    }
                    if (volumeid > 0) {
                        volume.removeVolume(volumeid);
                    }
                } else {
                    XNDiscAdminUtil.printAdminUsage(main_op, process_op);
                }
            } else if (process_op.equals("ch")) {
                int volumeid = -1;
                String name = "";
                String access = "";
                String desc = "";
                if (options.size() == 5) {
                    if (isInteger(options.get(2))) {
                        volumeid = Integer.parseInt(options.get(2));
                    }
                    name = options.get(3);
                    access = options.get(4);
                } else if (options.size() > 5) {
                    if (isInteger(options.get(2))) {
                        volumeid = Integer.parseInt(options.get(2));
                    }
                    name = options.get(3);
                    access = options.get(4);
                    desc = options.get(5) + " ";
                }
                if (!StringUtils.isEmpty(name) && !StringUtils.isEmpty(access) && volumeid > 0) {
                    volume.changeVolume(volumeid, name, access, desc);
                } else {
                    XNDiscAdminUtil.printAdminUsage(main_op, process_op);
                }
            }
        } else if (main_op.equals("id")) {
            String id = "";
            if (options.size() > 2) {
                id = options.get(2);
            }
            if (process_op.equals("enc")) {
                if (!StringUtils.isEmpty(id)) {
                    endecrypt.encrypt(id);
                } else {
                    XNDiscAdminUtil.printAdminUsage(main_op, process_op);
                }
            } else if (process_op.equals("dec")) {
                if (!StringUtils.isEmpty(id)) {
                    endecrypt.decrypt(id);
                } else {
                    XNDiscAdminUtil.printAdminUsage(main_op, process_op);
                }
            }
        }
        part.close();
    } while (!input.equalsIgnoreCase("q"));
    in.close();
}

From source file:TwitterClustering.java

public static void main(String[] args) throws FileNotFoundException, IOException {
    // TODO code application logic here

    File outFile = new File(args[3]);
    Scanner s = new Scanner(new File(args[1])).useDelimiter(",");
    JSONParser parser = new JSONParser();
    Set<Cluster> clusterSet = new HashSet<Cluster>();
    HashMap<String, Tweet> tweets = new HashMap();
    FileWriter fw = new FileWriter(outFile.getAbsoluteFile());
    BufferedWriter bw = new BufferedWriter(fw);

    // init// w w w.j a va2s  .c  o m
    try {

        Object obj = parser.parse(new FileReader(args[2]));

        JSONArray jsonArray = (JSONArray) obj;

        for (int i = 0; i < jsonArray.size(); i++) {

            Tweet twt = new Tweet();
            JSONObject jObj = (JSONObject) jsonArray.get(i);
            String text = jObj.get("text").toString();

            long sum = 0;
            for (int y = 0; y < text.toCharArray().length; y++) {

                sum += (int) text.toCharArray()[y];
            }

            String[] token = text.split(" ");
            String tID = jObj.get("id").toString();

            Set<String> mySet = new HashSet<String>(Arrays.asList(token));
            twt.setAttributeValue(sum);
            twt.setText(mySet);
            twt.setTweetID(tID);
            tweets.put(tID, twt);

        }

        // preparing initial clusters
        int i = 0;
        while (s.hasNext()) {
            String id = s.next();// id
            Tweet t = tweets.get(id.trim());
            clusterSet.add(new Cluster(i + 1, t, new LinkedList()));
            i++;
        }

        Iterator it = tweets.entrySet().iterator();

        for (int l = 0; l < 2; l++) { // limit to 25 iterations

            while (it.hasNext()) {
                Map.Entry me = (Map.Entry) it.next();

                // calculate distance to each centroid
                Tweet p = (Tweet) me.getValue();
                HashMap<Cluster, Float> distMap = new HashMap();

                for (Cluster clust : clusterSet) {

                    distMap.put(clust, jaccardDistance(p.getText(), clust.getCentroid().getText()));
                }

                HashMap<Cluster, Float> sorted = (HashMap<Cluster, Float>) sortByValue(distMap);

                sorted.keySet().iterator().next().getMembers().add(p);

            }

            // calculate new centroid and update Clusterset
            for (Cluster clust : clusterSet) {

                TreeMap<String, Long> tDistMap = new TreeMap();

                Tweet newCentroid = null;
                Long avgSumDist = new Long(0);
                for (int j = 0; j < clust.getMembers().size(); j++) {

                    avgSumDist += clust.getMembers().get(j).getAttributeValue();
                    tDistMap.put(clust.getMembers().get(j).getTweetID(),
                            clust.getMembers().get(j).getAttributeValue());
                }
                if (clust.getMembers().size() != 0) {
                    avgSumDist /= (clust.getMembers().size());
                }

                ArrayList<Long> listValues = new ArrayList<Long>(tDistMap.values());

                if (tDistMap.containsValue(findClosestNumber(listValues, avgSumDist))) {
                    // found closest
                    newCentroid = tweets
                            .get(getKeyByValue(tDistMap, findClosestNumber(listValues, avgSumDist)));
                    clust.setCentroid(newCentroid);
                }

            }

        }
        // create an iterator
        Iterator iterator = clusterSet.iterator();

        // check values
        while (iterator.hasNext()) {

            Cluster c = (Cluster) iterator.next();
            bw.write(c.getId() + "\t");
            System.out.print(c.getId() + "\t");

            for (Tweet t : c.getMembers()) {
                bw.write(t.getTweetID() + ", ");
                System.out.print(t.getTweetID() + ",");

            }
            bw.write("\n");
            System.out.println("");
        }

        System.out.println("");

        System.out.println("SSE " + sumSquaredErrror(clusterSet));

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        bw.close();
        fw.close();
    }
}

From source file:Main.java

public static String convertStreamToString(java.io.InputStream is) {
    Scanner s = new Scanner(is).useDelimiter("\\A");
    return s.hasNext() ? s.next() : "";
}

From source file:Main.java

private static String drainStream(InputStream in) {
    Scanner s = new Scanner(in).useDelimiter("\\A");
    return s.hasNext() ? s.next() : "";
}

From source file:Main.java

static String convertStreamToString(InputStream is) {
    Scanner s = new Scanner(is, "utf-8").useDelimiter("\\A");
    return s.hasNext() ? s.next() : "";
}

From source file:Main.java

public static String convertStreamToString(java.io.InputStream is) {
    java.util.Scanner s = new java.util.Scanner(is).useDelimiter("\\A");
    return s.hasNext() ? s.next() : "";
}

From source file:Main.java

public static String convertStreamToString(InputStream is) {
    java.util.Scanner s = new java.util.Scanner(is).useDelimiter("\\A");
    return s.hasNext() ? s.next() : "";
}

From source file:Main.java

public static String convertStreamToString(InputStream inputStream) {
    java.util.Scanner s = new java.util.Scanner(inputStream).useDelimiter("\\A");
    return s.hasNext() ? s.next() : "";
}