Example usage for java.lang StringBuilder reverse

Introduction

In this page you can find the example usage for java.lang StringBuilder reverse.

Prototype

@Override
    public StringBuilder reverse() 

Source Link

Usage

From source file:Main.java

private static String deriveLongerString(String str) {
    StringBuilder sb = new StringBuilder(str);
    StringBuilder builder = new StringBuilder();
    builder.append(sb.toString().toLowerCase());
    builder.append(sb.toString().toUpperCase());
    StringBuilder result = new StringBuilder();
    result.append(sb);//  w ww .  ja v a2 s  . co m
    result.append(mix(builder.toString()));
    result.append(mix(builder.reverse().toString()));
    return result.toString();
}

---

From source file:msi.gaml.operators.Strings.java

@operator(value = "reverse", can_be_const = true, category = { IOperatorCategory.STRING }, concept = {
        IConcept.STRING })/* ww  w . j  a v  a 2 s.c  om*/
@doc(usages = @usage(value = "if it is a string, reverse returns a new string with characters in the reversed order", examples = @example(value = "reverse ('abcd')", equals = "'dcba'")))
static public String reverse(final String s) {
    final StringBuilder buf = new StringBuilder(s);
    buf.reverse();
    return buf.toString();
}

---

From source file:io.digibyte.tools.util.Utils.java

public static String reverseHex(String hex) {
    if (hex == null)
        return null;
    StringBuilder result = new StringBuilder();
    for (int i = 0; i <= hex.length() - 2; i = i + 2) {
        result.append(new StringBuilder(hex.substring(i, i + 2)).reverse());
    }//from   ww  w . j a va 2  s. c  om
    return result.reverse().toString();
}

---

From source file:Main.java

public static Pair<String, String> ReorderRTLTextForPebble(String source, int charLimit) {
    if (source == null || source.equals(""))
        return new Pair<>("", "");

    if (!hebrewPattern.matcher(source).find()) {
        return new Pair<>(source, "");
    } else {// w ww  .  j av a 2  s  . c  o  m

        StringBuilder sbResult = new StringBuilder();
        StringBuilder sbExtraResult = new StringBuilder();
        StringBuilder sbTemp = new StringBuilder();
        String[] words = source.split(" ");
        int charCount = 0;

        for (int wordIndex = 0; wordIndex < words.length; wordIndex++, sbTemp.setLength(0)) {
            sbTemp.append(words[wordIndex]);
            charCount += sbTemp.length();
            Matcher hebrewWord = hebrewPattern.matcher(words[wordIndex]);

            if (hebrewWord.find()) {
                sbTemp.reverse();
                if (sbTemp.charAt(0) == ')') {
                    sbTemp.replace(0, 1, "(");
                }
                if (sbTemp.charAt(sbTemp.length() - 1) == '(') {
                    sbTemp.replace(sbTemp.length() - 1, sbTemp.length(), ")");
                }
            }

            if (charCount <= charLimit) {
                sbResult.insert(0, sbTemp + " ");
            } else {
                sbExtraResult.insert(0, sbTemp + " ");
            }

            charCount++;
        }

        if (sbExtraResult.length() > charLimit) {
            sbExtraResult.replace(0, sbExtraResult.length() - charLimit, "...");
        }

        return new Pair<>(sbResult.toString().trim(), sbExtraResult.toString().trim());
    }
}

---

From source file:org.hyperledger.common.ByteUtils.java

/**
 * convert a byte array to a human readable base58 string. Base58 is a Bitcoin specific encoding similar to widely used base64 but avoids using characters
 * of similar shape, such as 1 and l or O an 0
 *
 * @param b/*from   w  ww  .j av  a 2s.  c  o m*/
 * @return
 */
public static String toBase58(byte[] b) {
    if (b.length == 0) {
        return "";
    }

    int lz = 0;
    while (lz < b.length && b[lz] == 0) {
        ++lz;
    }

    StringBuilder s = new StringBuilder();
    BigInteger n = new BigInteger(1, b);
    while (n.compareTo(BigInteger.ZERO) > 0) {
        BigInteger[] r = n.divideAndRemainder(BigInteger.valueOf(58));
        n = r[0];
        char digit = b58[r[1].intValue()];
        s.append(digit);
    }
    while (lz > 0) {
        --lz;
        s.append("1");
    }
    return s.reverse().toString();
}

---

From source file:org.jrimum.vallia.digitoverificador.Modulo.java

/**
 * <p>//from  w  ww. j a v  a2s.  co m
 * Realiza o clculo da soma na forma do mdulo 11.
 * </p>
 * <p>
 * O mdulo 11 funciona da seguinte maneira:
 * </p>
 * <p>
 * Cada dgito do nmero, comeando da direita para a esquerda (menos
 * significativo para o mais significativo),  multiplicado pelo nmeros
 * limite mnimo, limite mnimo + 1, limite mnimo + 2 e assim
 * sucessivamente at o limite mxmio definido, ento inicia-se novamente a
 * contagem.
 * </p>
 * <p>
 * Exemplo para o nmero <tt>654321</tt>:
 * 
 * <pre>
 * +---+---+---+---+---+---+
 * | 6 | 5 | 4 | 3 | 2 | 1 |
 * +---+---+---+---+---+---+
 *   |   |   |   |   |   |
 *  x7  x6  x5  x4  x3  x2
 *   |   |   |   |   |   |
 *  =42 =30 =20 =12 =6  =2
 *   +---+---+---+---+---+-&gt;
 * </pre
 * 
 * </p>
 * 
 * @param numero
 * @param limiteMin
 * @param limiteMax
 * @return
 * @throws IllegalArgumentException
 * 
 * @since 0.2
 */
public static int calculeSomaSequencialMod11(String numero, int limiteMin, int limiteMax)
        throws IllegalArgumentException {

    int peso = 0;
    int soma = 0;

    if (StringUtils.isNotBlank(numero) && StringUtils.isNumeric(numero)) {

        StringBuilder sb = new StringBuilder(numero);
        sb.reverse();

        peso = limiteMin;

        for (char c : sb.toString().toCharArray()) {
            soma += peso * Character.getNumericValue(c);
            peso++;

            if (peso > limiteMax)
                peso = limiteMin;
        }

    } else
        throw new IllegalArgumentException(O_ARGUMENTO_DEVE_CONTER_APENAS_NUMEROS);

    return soma;
}

---

From source file:br.com.nordestefomento.jrimum.vallia.digitoverificador.Modulo.java

/**
 * <p>/*from www  .j  a  va 2  s.c  o  m*/
 * Realiza o clculo da soma na forma do mdulo 11.
 * </p>
 * <p>
 * O mdulo 11 funciona da seguinte maneira:
 * </p>
 * <p>
 * Cada dgito do nmero, comeando da direita para a esquerda (menos
 * significativo para o mais significativo),  multiplicado pelo nmeros
 * limite mnimo, limite mnimo + 1, limite mnimo + 2 e assim
 * sucessivamente at o limite mxmio definido, ento inicia-se novamente a
 * contagem.
 * </p>
 * <p>
 * Exemplo para o nmero <tt>654321</tt>:
 * 
 * <pre>
 * +---+---+---+---+---+---+
 * | 6 | 5 | 4 | 3 | 2 | 1 |
 * +---+---+---+---+---+---+
 *   |   |   |   |   |   |
 *  x7  x6  x5  x4  x3  x2
 *   |   |   |   |   |   |
 *  =42 =30 =20 =12 =6  =2
 *   +---+---+---+---+---+-&gt;
 * </pre
 * 
 * </p>
 * 
 * @param numero
 * @param limiteMin
 * @param limiteMax
 * @return
 * @throws IllegalArgumentException
 * 
 * @since 0.2
 */

public static int calculeSomaSequencialMod11(String numero, int limiteMin, int limiteMax)
        throws IllegalArgumentException {

    int peso = 0;
    int soma = 0;

    if (StringUtils.isNotBlank(numero) && StringUtils.isNumeric(numero)) {

        StringBuilder sb = new StringBuilder(numero);
        sb.reverse();

        peso = limiteMin;

        for (char c : sb.toString().toCharArray()) {
            soma += peso * Character.getNumericValue(c);
            peso++;

            if (peso > limiteMax)
                peso = limiteMin;
        }

    } else
        throw new IllegalArgumentException(O_ARGUMENTO_DEVE_CONTER_APENAS_NUMEROS);

    return soma;
}

---

From source file:br.com.nordestefomento.jrimum.vallia.digitoverificador.Modulo.java

/**
 * <p>// ww  w  .  j av a 2  s  .co m
 * Realiza o clculo da soma na forma do mdulo 10.
 * </p>
 * <p>
 * O mdulo 10 funciona da seguinte maneira:
 * </p>
 * <p>
 * Cada dgito do nmero, comeando da direita para a esquerda (menos
 * significativo para o mais significativo),  multiplicado pelo nmeros
 * limite mnimo, limite mnimo + 1, limite mnimo + 2 e assim
 * sucessivamente at o limite mxmio definido, ento inicia-se novamente a
 * contagem.
 * </p>
 * <p>
 * Exemplo para o nmero <tt>123456</tt>:
 * 
 * <pre>
 * +---+---+---+---+---+---+
 * | 1 | 2 | 3 | 4 | 5 | 6 |
 * +---+---+---+---+---+---+
 *   |   |   |   |   |   |
 *  x1  x2  x1  x2  x1  x2
 *   |   |   |   |   |   |
 *  =1  =4  =3  =8  =5  =[ 3 &lt;= ( 1 + 2 &lt;==12 ) ] = 24
 *   +---+---+---+---+---+-&gt; = (24 / 10) = 3, resto 3; Ento o mdulo  igual a 3.
 * </pre>
 * 
 * </p>
 * 
 * <p>
 * Geralmente os limites para o mdulo 10 so mnimo 1 e mximo 2 apenas.
 * </p>
 * 
 * @param numero
 * @param limiteMin
 * @param limiteMax
 * @return soma sequencial usada no clculo do mdulo
 * @throws IllegalArgumentException
 * 
 * @since 0.2
 */
public static int calculeSomaSequencialMod10(String numero, int limiteMin, int limiteMax)
        throws IllegalArgumentException {

    int produto = 0;
    int peso = 0;
    int soma = 0;

    if (StringUtils.isNotBlank(numero) && StringUtils.isNumeric(numero)) {

        StringBuilder sb = new StringBuilder(numero);
        sb.reverse();

        peso = limiteMax;

        for (char c : sb.toString().toCharArray()) {

            produto = peso * Character.getNumericValue(c);

            if (produto > 9) {

                soma += produto / 10;
                soma += produto % 10;
            } else
                soma += produto;

            peso = (peso == limiteMax) ? limiteMin : limiteMax;
        }

    } else
        throw new IllegalArgumentException(O_ARGUMENTO_DEVE_CONTER_APENAS_NUMEROS);

    return soma;
}

---

From source file:com.viettel.util.StringUtils.java

public static String toExcelName(int number) {
     StringBuilder sb = new StringBuilder();
     while (number-- > 0) {
         sb.append((char) ('A' + (number % 26)));
         number /= 26;/* ww  w  .ja  v a 2 s. c  om*/
     }
     return sb.reverse().toString();
 }

---

From source file:Main.java

public static String encodeBase58(byte[] input) {
    if (input == null) {
        return null;
    }//  ww w .  j a v a2 s .c om
    StringBuilder str = new StringBuilder((input.length * 350) / 256 + 1);
    BigInteger bn = new BigInteger(1, input);
    long rem;
    while (true) {
        BigInteger[] divideAndRemainder = bn.divideAndRemainder(BASE58_CHUNK_MOD);
        bn = divideAndRemainder[0];
        rem = divideAndRemainder[1].longValue();
        if (bn.compareTo(BigInteger.ZERO) == 0) {
            break;
        }
        for (int i = 0; i < BASE58_CHUNK_DIGITS; i++) {
            str.append(BASE58[(int) (rem % 58)]);
            rem /= 58;
        }
    }
    while (rem != 0) {
        str.append(BASE58[(int) (rem % 58)]);
        rem /= 58;
    }
    str.reverse();
    int nLeadingZeros = 0;
    while (nLeadingZeros < input.length && input[nLeadingZeros] == 0) {
        str.insert(0, BASE58[0]);
        nLeadingZeros++;
    }
    return str.toString();
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• »