num == Integer.parseInt(str) is going to faster than str.equals("" + num)

str.equals("" + num) will first convert num to string which is O(n) where n being the number of digits in the number. Then it will do a string concatenation again O(n) and then finally do the string comparison. String comparison in this case will be another O(n) - n being the number of digits in the number. So in all ~3*O(n)

num == Integer.parseInt(str) will convert the string to integer which is O(n) again where n being the number of digits in the number. And then integer comparison is O(1). So just ~1*O(n)

To summarize both are O(n) - but str.equals("" + num) has a higher constant and so is slower.

To convert to an integer, use Integer.valueOf(String):

if (Integer.valueOf(buf) == 1) {

A better option is to use the method from JOptionPane that asks for input with given selections. This way you would force the user to input 1, 2 or 3, and at the same there would be no need to convert to an integer.

Integer result = (Integer) JOptionPane.showInputDialog(null, "1, 2 or 3", "title", JOptionPane.QUESTION_MESSAGE, null, new Integer[]{1,2,3}, 1);

if (result == 1) {
  ... 
} else if (result == 2) {
  ...
} else if (result == 3) {
  ...
}

/**
 * Similar to compareTo method But compareTo doesn't return correct result for string+integer strings something like `A11` and `A9`
  */

private int newCompareTo(String comp1, String comp2) {
    // If any value has 0 length it means other value is bigger
    if (comp1.length() == 0) {
        if (comp2.length() == 0) {
            return 0;
        }
        return -1;
    } else if (comp2.length() == 0) {
        return 1;
    }
    // Check if first string is digit
    if (TextUtils.isDigitsOnly(comp1)) {
        int val1 = Integer.parseInt(comp1);
        // Check if second string is digit
        if (TextUtils.isDigitsOnly(comp2)) { // If both strings are digits then we only need to use Integer compare method
            int val2 = Integer.parseInt(comp2);
            return Integer.compare(val1, val2);
        } else { // If only first string is digit we only need to use String compareTo method
            return comp1.compareTo(comp2);
        }

    } else { // If both strings are not digits

        int minVal = Math.min(comp1.length(), comp2.length()), sameCount = 0;

        // Loop through two strings and check how many strings are same
        for (int i = 0;i < minVal;i++) {
            char leftVal = comp1.charAt(i), rightVal = comp2.charAt(i);
            if (leftVal == rightVal) {
                sameCount++;
            } else {
                break;
            }
        }
        if (sameCount == 0) {
            // If there's no same letter, then use String compareTo method
            return comp1.compareTo(comp2);
        } else {
            // slice same string from both strings
            String newStr1 = comp1.substring(sameCount), newStr2 = comp2.substring(sameCount);
            if (TextUtils.isDigitsOnly(newStr1) && TextUtils.isDigitsOnly(newStr2)) { // If both sliced strings are digits then use Integer compare method
                return Integer.compare(Integer.parseInt(newStr1), Integer.parseInt(newStr2));
            } else { // If not, use String compareTo method
                return comp1.compareTo(comp2);
            }
        }
    }
}

== tests for reference equality (whether they are the same object).

.equals() tests for value equality (whether they contain the same data).

Objects.equals() checks for null before calling .equals() so you don't have to (available as of JDK7, also available in Guava).

Consequently, if you want to test whether two strings have the same value you will probably want to use Objects.equals().

// These two have the same value
new String("test").equals("test") // --> true 

// ... but they are not the same object
new String("test") == "test" // --> false 

// ... neither are these
new String("test") == new String("test") // --> false 

// ... but these are because literals are interned by 
// the compiler and thus refer to the same object
"test" == "test" // --> true 

// ... string literals are concatenated by the compiler
// and the results are interned.
"test" == "te" + "st" // --> true

// ... but you should really just call Objects.equals()
Objects.equals("test", new String("test")) // --> true
Objects.equals(null, "test") // --> false
Objects.equals(null, null) // --> true

From the Java Language Specification JLS 15.21.3. Reference Equality Operators == and !=:

While == may be used to compare references of type String, such an equality test determines whether or not the two operands refer to the same String object. The result is false if the operands are distinct String objects, even if they contain the same sequence of characters (§3.10.5, §3.10.6). The contents of two strings s and t can be tested for equality by the method invocation s.equals(t).

You almost always want to use Objects.equals(). In the rare situation where you know you're dealing with interned strings, you can use ==.

From JLS 3.10.5. String Literals:

Moreover, a string literal always refers to the same instance of class String. This is because string literals - or, more generally, strings that are the values of constant expressions (§15.28) - are "interned" so as to share unique instances, using the method String.intern.

Similar examples can also be found in JLS 3.10.5-1.

Other Methods To Consider

String.equalsIgnoreCase() value equality that ignores case. Beware, however, that this method can have unexpected results in various locale-related cases, see this question.

String.contentEquals() compares the content of the String with the content of any CharSequence (available since Java 1.5). Saves you from having to turn your StringBuffer, etc into a String before doing the equality comparison, but leaves the null checking to you.

An Integer will never be equal to a String.

Both classes have very strict equals() definitions that only accept objects of their respective types.

• Integer.equals():

  The result is true if and only if the argument is not null and is an Integer object that contains the same int value as this object.

• String.equals():

  The result is true if and only if the argument is not null and is a String object that represents the same sequence of characters as this object.

That's actually a quite common way to implement equals(): only objects of the same class (and occasionally subclasses) can be equal. Other implementations are possible, but are the exception.

One common exception are the collections such as List: every List implementation that follows the convention will return true when compared to any other implementation, if it has the same content in the same order.

Integer.parseInt("4") == Integer.parseInt("04")

That is it. You can convert a numeric string into integer using Integer.parseInt(String) method, which returns an int type. And then comparison is same as 4 == 4.

pls try this

 Collections.sort(data, new Comparator<TXCartData>() {
        @Override
        public int compare(TXCartData lhs, TXCartData rhs) {
            int n1=Integer.parseInt(lhs.rowId);
            int n2=Integer.parseInt(rhs.rowId);
            if (n1>=n2){
                return 1;
            }
            return -1;
        }
    });