Example usage for java.util Arrays sort

List of usage examples for java.util Arrays sort

  1. HOME
  2. Java
  3. java
  4. java.util.*
  5. Arrays
  6. sort

Introduction

In this page you can find the example usage for java.util Arrays sort.

Prototype

public static void sort(Object[] a)

Source Link

Document

Sorts the specified array of objects into ascending order, according to the Comparable natural ordering of its elements.

Usage

From source file:com.p2p.peercds.cli.TorrentMain.java

/**
 * Torrent reader and creator./* w w  w .ja v a 2 s .  co  m*/
 *
 * <p>
 * You can use the {@code main()} function of this class to read or create
 * torrent files. See usage for details.
 * </p>
 *
 */
public static void main(String[] args) {
    BasicConfigurator.configure(new ConsoleAppender(new PatternLayout("%-5p: %m%n")));

    CmdLineParser parser = new CmdLineParser();
    CmdLineParser.Option help = parser.addBooleanOption('h', "help");
    CmdLineParser.Option filename = parser.addStringOption('t', "torrent");
    CmdLineParser.Option create = parser.addBooleanOption('c', "create");
    CmdLineParser.Option announce = parser.addStringOption('a', "announce");

    try {
        parser.parse(args);
    } catch (CmdLineParser.OptionException oe) {
        System.err.println(oe.getMessage());
        usage(System.err);
        System.exit(1);
    }

    // Display help and exit if requested
    if (Boolean.TRUE.equals((Boolean) parser.getOptionValue(help))) {
        usage(System.out);
        System.exit(0);
    }

    String filenameValue = (String) parser.getOptionValue(filename);
    if (filenameValue == null) {
        usage(System.err, "Torrent file must be provided!");
        System.exit(1);
    }

    Boolean createFlag = (Boolean) parser.getOptionValue(create);

    //For repeated announce urls
    @SuppressWarnings("unchecked")
    Vector<String> announceURLs = (Vector<String>) parser.getOptionValues(announce);

    String[] otherArgs = parser.getRemainingArgs();

    if (Boolean.TRUE.equals(createFlag) && (otherArgs.length != 1 || announceURLs.isEmpty())) {
        usage(System.err,
                "Announce URL and a file or directory must be " + "provided to create a torrent file!");
        System.exit(1);
    }

    OutputStream fos = null;
    try {
        if (Boolean.TRUE.equals(createFlag)) {
            if (filenameValue != null) {
                fos = new FileOutputStream(filenameValue);
            } else {
                fos = System.out;
            }

            //Process the announce URLs into URIs
            List<URI> announceURIs = new ArrayList<URI>();
            for (String url : announceURLs) {
                announceURIs.add(new URI(url));
            }

            //Create the announce-list as a list of lists of URIs
            //Assume all the URI's are first tier trackers
            List<List<URI>> announceList = new ArrayList<List<URI>>();
            announceList.add(announceURIs);

            File source = new File(otherArgs[0]);
            if (!source.exists() || !source.canRead()) {
                throw new IllegalArgumentException(
                        "Cannot access source file or directory " + source.getName());
            }

            String creator = String.format("%s (ttorrent)", System.getProperty("user.name"));

            Torrent torrent = null;
            if (source.isDirectory()) {
                File[] files = source.listFiles(Constants.hiddenFilesFilter);
                Arrays.sort(files);
                torrent = Torrent.create(source, Arrays.asList(files), announceList, creator);
            } else {
                torrent = Torrent.create(source, announceList, creator);

            }

            torrent.save(fos);
        } else {
            Torrent.load(new File(filenameValue), true);
        }
    } catch (Exception e) {
        logger.error("{}", e.getMessage(), e);
        System.exit(2);
    } finally {
        if (fos != System.out) {
            IOUtils.closeQuietly(fos);
        }
    }
}

From source file:generators.ElementMetaValidator.java

public static void main(String[] args) {
    ClassicEngineBoot.getInstance().start();
    int invalidExpressionsCounter = 0;
    int deprecatedExpressionsCounter = 0;
    final HashNMap expressionsByGroup = new HashNMap();

    ElementTypeRegistry registry = ElementTypeRegistry.getInstance();
    final ElementMetaData[] elementMetaDatas = registry.getAllElementTypes();
    for (int i = 0; i < elementMetaDatas.length; i++) {
        final ElementMetaData metaData = elementMetaDatas[i];
        if (metaData == null) {
            logger.warn("Null Expression encountered");
            continue;
        }/*w  ww. j a v  a2  s  .  co  m*/

        missingProperties.clear();

        try {
            final Object type = metaData.create();
        } catch (InstantiationException e) {
            logger.warn("Expression class is null");

        }

        final String typeName = metaData.getName();
        logger.debug("Processing " + typeName);

        final Locale locale = Locale.getDefault();
        final String displayName = metaData.getDisplayName(locale);
        if (isValid(displayName, metaData.getName()) == false) {
            logger.warn("ElementType '" + typeName + ": No valid display name");
        }
        if (metaData.isDeprecated()) {
            deprecatedExpressionsCounter += 1;
            final String deprecateMessage = metaData.getDeprecationMessage(locale);
            if (isValid(deprecateMessage, "Use a Formula instead") == false) {
                logger.warn("ElementType '" + typeName + ": No valid deprecate message");
            }
        }
        final String grouping = metaData.getGrouping(locale);
        if (isValid(grouping, "Group") == false) {
            logger.warn("ElementType '" + typeName + ": No valid grouping message");
        }

        expressionsByGroup.add(grouping, metaData);

        final StyleMetaData[] styleMetaDatas = metaData.getStyleDescriptions();
        for (int j = 0; j < styleMetaDatas.length; j++) {
            final StyleMetaData propertyMetaData = styleMetaDatas[j];
            final String propertyDisplayName = propertyMetaData.getDisplayName(locale);
            if (isValid(propertyDisplayName, propertyMetaData.getName()) == false) {
                logger.warn("ElementType '" + typeName + ": Style " + propertyMetaData.getName()
                        + ": No DisplayName");
            }

            final String propertyGrouping = propertyMetaData.getGrouping(locale);
            if (isValid(propertyGrouping, "Group") == false) {
                logger.warn("ElementType '" + typeName + ": Style " + propertyMetaData.getName()
                        + ": Grouping is not valid");
            }
            if (propertyMetaData.isDeprecated()) {
                final String deprecateMessage = propertyMetaData.getDeprecationMessage(locale);
                if (isValid(deprecateMessage, "Deprecated") == false) {
                    logger.warn("ElementType '" + typeName + ": Style " + propertyMetaData.getName()
                            + ": No valid deprecate message");
                }
            }
        }

        final AttributeMetaData[] attributeMetaDatas = metaData.getAttributeDescriptions();
        for (int j = 0; j < attributeMetaDatas.length; j++) {
            final AttributeMetaData propertyMetaData = attributeMetaDatas[j];
            final String propertyDisplayName = propertyMetaData.getDisplayName(locale);
            if (isValid(propertyDisplayName, propertyMetaData.getName()) == false) {
                logger.warn("ElementType '" + typeName + ": Attr " + propertyMetaData.getName()
                        + ": No DisplayName");
            }

            final String propertyGrouping = propertyMetaData.getGrouping(locale);
            if (isValid(propertyGrouping, "Group") == false) {
                logger.warn("ElementType '" + typeName + ": Attr " + propertyMetaData.getName()
                        + ": Grouping is not valid");
            }
            if (propertyMetaData.isDeprecated()) {
                final String deprecateMessage = propertyMetaData.getDeprecationMessage(locale);
                if (isValid(deprecateMessage, "Deprecated") == false) {
                    logger.warn("ElementType '" + typeName + ": Attr " + propertyMetaData.getName()
                            + ": No valid deprecate message");
                }
            }
        }

        System.err.flush();
        try {
            Thread.sleep(25);
        } catch (InterruptedException e) {
        }

        for (int x = 0; x < missingProperties.size(); x++) {
            final String property = (String) missingProperties.get(x);
            System.out.println(property);
        }

        if (missingProperties.isEmpty() == false) {
            invalidExpressionsCounter += 1;
            missingProperties.clear();
        }
        System.out.flush();
        try {
            Thread.sleep(25);
        } catch (InterruptedException e) {
        }
    }

    logger.info("Validated " + elementMetaDatas.length + " expressions. Invalid: " + invalidExpressionsCounter
            + " Deprecated: " + deprecatedExpressionsCounter);

    final Object[] keys = expressionsByGroup.keySet().toArray();
    Arrays.sort(keys);
    for (int i = 0; i < keys.length; i++) {
        final Object key = keys[i];
        logger.info("Group: '" + key + "' Size: " + expressionsByGroup.getValueCount(key));
        final Object[] objects = expressionsByGroup.toArray(key);
        for (int j = 0; j < objects.length; j++) {
            ElementMetaData metaData = (ElementMetaData) objects[j];
            logger.info("   " + metaData.getName());

        }
    }
}

From source file:org.silverpeas.dbbuilder.DBBuilder.java

/**
 * @param args//from ww  w. ja v  a  2s. c o m
 * @see
 */
public static void main(String[] args) {
    ClassPathXmlApplicationContext springContext = new ClassPathXmlApplicationContext(
            "classpath:/spring-jdbc-datasource.xml");
    try {
        // Ouverture des traces
        Date startDate = new Date();
        System.out.println(
                MessageFormat.format(messages.getString("dbbuilder.start"), DBBuilderAppVersion, startDate));
        console = new Console(DBBuilder.class);
        console.printMessage("*************************************************************");
        console.printMessage(
                MessageFormat.format(messages.getString("dbbuilder.start"), DBBuilderAppVersion, startDate));
        // Lecture des variables d'environnement  partir de dbBuilderSettings
        dbBuilderResources = FileUtil
                .loadResource("/org/silverpeas/dbBuilder/settings/dbBuilderSettings.properties");
        // Lecture des paramtres d'entre
        params = new CommandLineParameters(console, args);

        if (params.isSimulate() && DatabaseType.ORACLE == params.getDbType()) {
            throw new Exception(messages.getString("oracle.simulate.error"));
        }
        console.printMessage(messages.getString("jdbc.connection.configuration"));
        console.printMessage(ConnectionFactory.getConnectionInfo());
        console.printMessage("\tAction        : " + params.getAction());
        console.printMessage("\tVerbose mode  : " + params.isVerbose());
        console.printMessage("\tSimulate mode : " + params.isSimulate());
        if (Action.ACTION_CONNECT == params.getAction()) {
            // un petit message et puis c'est tout
            console.printMessage(messages.getString("connection.success"));
            System.out.println(messages.getString("connection.success"));
        } else {
            // Modules en place sur la BD avant install
            console.printMessage("DB Status before build :");
            List<String> packagesIntoDB = checkDBStatus();
            // initialisation d'un vecteur des instructions SQL  passer en fin d'upgrade
            // pour mettre  niveau les versions de modules en base
            MetaInstructions sqlMetaInstructions = new MetaInstructions();
            File dirXml = new File(params.getDbType().getDBContributionDir());
            DBXmlDocument destXml = loadMasterContribution(dirXml);
            UninstallInformations processesToCacheIntoDB = new UninstallInformations();

            File[] listeFileXml = dirXml.listFiles();
            Arrays.sort(listeFileXml);

            List<DBXmlDocument> listeDBXmlDocument = new ArrayList<DBXmlDocument>(listeFileXml.length);
            int ignoredFiles = 0;
            // Ouverture de tous les fichiers de configurations
            console.printMessage(messages.getString("ignored.contribution"));

            for (File xmlFile : listeFileXml) {
                if (xmlFile.isFile() && "xml".equals(FileUtil.getExtension(xmlFile))
                        && !(FIRST_DBCONTRIBUTION_FILE.equalsIgnoreCase(xmlFile.getName()))
                        && !(MASTER_DBCONTRIBUTION_FILE.equalsIgnoreCase(xmlFile.getName()))) {
                    DBXmlDocument fXml = new DBXmlDocument(dirXml, xmlFile.getName());
                    fXml.load();
                    // vrification des dpendances et prise en compte uniquement si dependences OK
                    if (hasUnresolvedRequirements(listeFileXml, fXml)) {
                        console.printMessage(
                                '\t' + xmlFile.getName() + " (because of unresolved requirements).");
                        ignoredFiles++;
                    } else if (ACTION_ENFORCE_UNINSTALL == params.getAction()) {
                        console.printMessage('\t' + xmlFile.getName() + " (because of "
                                + ACTION_ENFORCE_UNINSTALL + " mode).");
                        ignoredFiles++;
                    } else {
                        listeDBXmlDocument.add(fXml);
                    }
                }
            }
            if (0 == ignoredFiles) {
                console.printMessage("\t(none)");
            }

            // prpare une HashMap des modules prsents en fichiers de contribution
            Map packagesIntoFile = new HashMap();
            int j = 0;
            console.printMessage(messages.getString("merged.contribution"));
            console.printMessage(params.getAction().toString());
            if (ACTION_ENFORCE_UNINSTALL != params.getAction()) {
                console.printMessage('\t' + FIRST_DBCONTRIBUTION_FILE);
                j++;
            }
            for (DBXmlDocument currentDoc : listeDBXmlDocument) {
                console.printMessage('\t' + currentDoc.getName());
                j++;
            }
            if (0 == j) {
                console.printMessage("\t(none)");
            }
            // merge des diffrents fichiers de contribution ligibles :
            console.printMessage("Build decisions are :");
            // d'abord le fichier dbbuilder-contribution ...
            DBXmlDocument fileXml;
            if (ACTION_ENFORCE_UNINSTALL != params.getAction()) {
                try {
                    fileXml = new DBXmlDocument(dirXml, FIRST_DBCONTRIBUTION_FILE);
                    fileXml.load();
                } catch (Exception e) {
                    // contribution de dbbuilder non trouve -> on continue, on est certainement en train
                    // de desinstaller la totale
                    fileXml = null;
                }
                if (null != fileXml) {
                    DBBuilderFileItem dbbuilderItem = new DBBuilderFileItem(fileXml);
                    packagesIntoFile.put(dbbuilderItem.getModule(), null);
                    mergeActionsToDo(dbbuilderItem, destXml, processesToCacheIntoDB, sqlMetaInstructions);
                }
            }

            // ... puis les autres
            for (DBXmlDocument currentDoc : listeDBXmlDocument) {
                DBBuilderFileItem tmpdbbuilderItem = new DBBuilderFileItem(currentDoc);
                packagesIntoFile.put(tmpdbbuilderItem.getModule(), null);
                mergeActionsToDo(tmpdbbuilderItem, destXml, processesToCacheIntoDB, sqlMetaInstructions);
            }

            // ... et enfin les pices BD  dsinstaller
            // ... attention, l'ordonnancement n'tant pas dispo, on les traite dans
            // l'ordre inverse pour faire passer busCore a la fin, de nombreuses contraintes
            // des autres modules referencant les PK de busCore
            List<String> itemsList = new ArrayList<String>();

            boolean foundDBBuilder = false;
            for (String dbPackage : packagesIntoDB) {
                if (!packagesIntoFile.containsKey(dbPackage)) {
                    // Package en base et non en contribution -> candidat  desinstallation
                    if (DBBUILDER_MODULE.equalsIgnoreCase(dbPackage)) {
                        foundDBBuilder = true;
                    } else if (ACTION_ENFORCE_UNINSTALL == params.getAction()) {
                        if (dbPackage.equals(params.getModuleName())) {
                            itemsList.add(0, dbPackage);
                        }
                    } else {
                        itemsList.add(0, dbPackage);
                    }
                }
            }

            if (foundDBBuilder) {
                if (ACTION_ENFORCE_UNINSTALL == params.getAction()) {
                    if (DBBUILDER_MODULE.equals(params.getModuleName())) {
                        itemsList.add(itemsList.size(), DBBUILDER_MODULE);
                    }
                } else {
                    itemsList.add(itemsList.size(), DBBUILDER_MODULE);
                }
            }
            for (String item : itemsList) {
                console.printMessage("**** Treating " + item + " ****");
                DBBuilderDBItem tmpdbbuilderItem = new DBBuilderDBItem(item);
                mergeActionsToDo(tmpdbbuilderItem, destXml, processesToCacheIntoDB, sqlMetaInstructions);
            }
            destXml.setName("res.txt");
            destXml.save();
            console.printMessage("Build parts are :");
            // Traitement des pices slectionnes
            // remarque : durant cette phase, les erreurs sont traites -> on les catche en
            // retour sans les retraiter
            if (ACTION_INSTALL == params.getAction()) {
                processDB(destXml, processesToCacheIntoDB, sqlMetaInstructions, TAGS_TO_MERGE_4_INSTALL);
            } else if (ACTION_UNINSTALL == params.getAction()
                    || ACTION_ENFORCE_UNINSTALL == params.getAction()) {
                processDB(destXml, processesToCacheIntoDB, sqlMetaInstructions, TAGS_TO_MERGE_4_UNINSTALL);
            } else if (ACTION_OPTIMIZE == params.getAction()) {
                processDB(destXml, processesToCacheIntoDB, sqlMetaInstructions, TAGS_TO_MERGE_4_OPTIMIZE);
            } else if (ACTION_ALL == params.getAction()) {
                processDB(destXml, processesToCacheIntoDB, sqlMetaInstructions, TAGS_TO_MERGE_4_ALL);
            }
            // Modules en place sur la BD en final
            console.printMessage("Finally DB Status :");
            checkDBStatus();
        }
        Date endDate = new Date();
        console.printMessage(MessageFormat.format(messages.getString("dbbuilder.success"), endDate));
        System.out.println("*******************************************************************");
        System.out.println(MessageFormat.format(messages.getString("dbbuilder.success"), endDate));
    } catch (Exception e) {
        e.printStackTrace();
        console.printError(e.getMessage(), e);
        Date endDate = new Date();
        console.printError(MessageFormat.format(messages.getString("dbbuilder.failure"), endDate));
        System.out.println("*******************************************************************");
        System.out.println(MessageFormat.format(messages.getString("dbbuilder.failure"), endDate));
        System.exit(1);
    } finally {
        springContext.close();
        console.close();
    }
}

From source file:Main.java

private static String alphabetize(String s) {
    char[] a = s.toCharArray();
    Arrays.sort(a);
    return new String(a);
}

From source file:Dir.java

static void listPath(File path) {
    File files[];/*from   w  ww . j a v  a2 s.  c om*/
    indentLevel++;

    files = path.listFiles();

    Arrays.sort(files);
    for (int i = 0, n = files.length; i < n; i++) {
        for (int indent = 0; indent < indentLevel; indent++) {
            System.out.print("  ");
        }
        System.out.println(files[i].toString());
        if (files[i].isDirectory()) {

            listPath(files[i]);
        }
    }
    indentLevel--;
}

From source file:Main.java

public static String orderAlphabetically(String word) {
    char chars[] = word.toCharArray();
    Arrays.sort(chars);
    return String.valueOf(chars);
}

From source file:Main.java

public static String[] getStringsFormat(List<String> mapValuesList) {
    final String[] arr = new String[mapValuesList.size()];
    mapValuesList.toArray(arr);// www  .  jav a 2 s  .c o  m
    Arrays.sort(arr);
    return arr;
}

From source file:Main.java

public static void Init(String home) {
    HOME_PATH = home;
    Arrays.sort(SERVICES);
}

From source file:Main.java

public static void top_k_competition(float[] response_array, int size, int k) {
    float[] copy_of_array = new float[size];
    System.arraycopy(response_array, 0, copy_of_array, 0, size);
    Arrays.sort(copy_of_array);

    for (int i = 0; i < size; i++) {
        if (response_array[i] < copy_of_array[size - k]) {
            response_array[i] = 0;//from w  ww.j av a 2s .c o  m
        } else {
            //response_array[i]= (response_array[i]- copy_of_array[size-k-1])/
            //      (copy_of_array[size-1]-copy_of_array[size-k-1]);
            response_array[i] = 1;
        }
    }
}

From source file:Main.java

public static List<String> getAllSameElement2(String[] strArr1, String[] strArr2) {
    if (strArr1 == null || strArr2 == null) {
        return null;
    }//ww w . jav a  2s .c  o  m
    Arrays.sort(strArr1);
    Arrays.sort(strArr2);
    List<String> list = new ArrayList<String>();
    int k = 0;
    int j = 0;
    while (k < strArr1.length && j < strArr2.length) {
        if (strArr1[k].compareTo(strArr2[j]) == 0) {
            if (strArr1[k].equals(strArr2[j])) {
                list.add(strArr1[k]);
                k++;
                j++;
            }
            continue;
        } else if (strArr1[k].compareTo(strArr2[j]) < 0) {
            k++;
        } else {
            j++;
        }
    }
    return list;
}