精华内容
下载资源
问答
  • 在本文中,优锐课将带你学习如何比较字符串以及使用等于(=)运算符比较字符串时发生的问题。...”在身份验证,排序,引用匹配等过程中,比较字符串非常有帮助。我列出了三种比较Java中字符串的方法。1. ...

    在本文中,优锐课将带你学习如何比较字符串以及使用等于(=)运算符比较字符串时发生的问题。

    介绍

    字符串是Java中的特殊类。我们在Java程序中定期使用String,因此比较两个字符串是Java中的一种常见做法。在本文中,我试图回答有关字符串的最常见问题,例如:“如何比较Java中的字符串?”

    在身份验证,排序,引用匹配等过程中,比较字符串非常有帮助。

    我列出了三种比较Java中字符串的方法。

    1. 使用equals()方法(比较内容)

    2. 使用==运算符(比较对象引用)

    3. 使用compareTo()方法(按字典顺序比较字符串)

    1.使用Equals()方法比较字符串

    这样,我正在使用String类的.equals()实例方法。最初.equals()方法是Object类方法,String类覆盖了它。

    equals()方法比较两个字符串的值相等性,无论它们在逻辑上是否相等。

    String类中的equals()方法将另一个字符串作为参数,并将其与指定的字符串进行比较。当且仅当参数字符串不为null且包含与指定字符串相同的字符时,它返回true。

    1

    public boolean equals(Object anObject)

    2

    3

    It compare this string with the argument strings and return true if the argument is not null and contains the same character as the specified string.

    4

    5

    param -

    6

    another string

    7

    8

    returns -

    9

    10

    true - if argument is not null and it contains same characters as the specified string

    11

    false - if the argument is null or it does not contain same characters as the specified string

    12

    13

    ex. firstString.equals(secondString)

    14

    // returns true if and only if the secondString is not null and contains the same characters as firstString.

    我已经要求程序使用下面的equals()方法比较字符串:

    1

    /**

    2

    * A Java program to compare two strings using equsls()

    3

    * and equalsIgnoreCase() method of the String.

    4

    *

    5

    * @author Gaurav Kukade at coderolls.com

    6

    */

    7

    8

    public class CompareUsingEquals {

    9

    10

    public static void main(String[] args) {

    11

    String firstString = "coderolls";

    12

    String secondString = "javablog";

    13

    String thirdString = "coderolls";

    14

    String fourthString = "CodeRolls";

    15

    16

    System.out.println("Comparing strings using equals() and equalsIgnoreCase() method

    ");

    17

    18

    // Using equals() method

    19

    System.out.print("firstString.equals(secondString) : ");

    20

    System.out.println(firstString.equals(secondString));

    21

    22

    System.out.print("firstString.equals(thirdString) : ");

    23

    System.out.println(firstString.equals(thirdString));

    24

    25

    /*

    26

    * Using equalsIgnoreCase() method to ignore

    27

    * case consideration (i.e. Capital or small) of both the strings.

    28

    */

    29

    System.out.print("firstString.equalsIgnoreCase(fourthString) : ");

    30

    System.out.println(firstString.equalsIgnoreCase(fourthString));

    31

    }

    32

    33

    }

    Output:

    1

    Comparing strings using equals() and equalsIgnoreCase() method

    2

    3

    firstString.equals(secondString) : false

    4

    firstString.equals(thirdString) : true

    5

    firstString.equalsIgnoreCase(fourthString) : true

    2.使用==运算符比较字符串

    在String中,==运算符用于比较给定字符串的引用,具体取决于它们是否引用相同的对象。

    当使用==运算符比较两个字符串时,如果字符串变量指向同一个Java对象,它将返回true。否则,它将返回false。

    我给了一个Java程序,可以在下面使用==运算符进行比较:

    1

    /**

    2

    * A Java program to compare strings using == operator.

    3

    *

    4

    * == operator ckecks whether both the strings referring

    5

    * to the same String Object.

    6

    *

    7

    * @author Gaurav Kukade at coderolls.com

    8

    */

    9

    10

    public class CompareUsingEqualsToOperator {

    11

    12

    public static void main(String[] args) {

    13

    14

    String firstString = "coderolls";

    15

    String secondString = "javablog";

    16

    String thirdString = "coderolls";

    17

    18

    // creating new String object with the same value as firstString or thirdString

    19

    String fourthString =  new String("coderolls");

    20

    21

    System.out.println("Comparing strings using == operator

    ");

    22

    23

    System.out.print("firstString == secondString : ");

    24

    System.out.println(firstString == secondString);

    25

    26

    /*

    27

    * Here firstString and thirdString is referring to the same String object

    28

    * hence it will print 'true'.

    29

    */

    30

    System.out.print("firstString == thirdString : ");

    31

    System.out.println(firstString == thirdString);

    32

    33

    /*

    34

    * Here firstString and fourthString have same value

    35

    * but they are referring to the different String object.

    36

    *

    37

    * hence it will print 'false'

    38

    */

    39

    System.out.print("firstString == fourthString : ");

    40

    System.out.println(firstString == fourthString);

    41

    }

    42

    43

    }

    Output:

    1

    Comparing strings using == operator

    2

    3

    firstString == secondString : false

    4

    firstString == thirdString : true

    5

    firstString == fourthString : false

    使用==运算符进行字符串比较时出现问题

    大多数初学者Java开发人员通过使用== operator比较两个字符串来犯此错误。

    从逻辑上讲,他们必须检查两个字符串是否包含相同的字符序列。

    在Java字符串中,==运算符用于检查两个字符串对象的引用,而equals()方法用于检查两个字符串的值相等。

    == –检查引用是否相等

    equals()–检查值是否相等

    当我们为字符串变量分配字符串值时,JVM将检查字符串池中是否已经存在具有相等值的字符串。 如果它在字符串池中不存在,它将被添加到常量池中,并返回对该字符串对象的引用。

    如果它存在于字符串池中,则返回对该字符串对象的内存地址的引用。

    下图显示了相同的图片说明。

    cb9d0c1eb2c8c6bdaf4443829b60c4c9.png

    上面,我们有“firstString”指向字符串池中的“coderolls”字符串。

    如果我们将相等的值分配给另一个字符串变量,则JVM将检查具有该值的字符串是否存在于字符串常量池中。

    由于具有该值的字符串对象已在上一步中创建,因此另一个字符串变量开始引用先前创建的字符串对象实例。

    下图显示了指向字符串池中“ coderolls”字符串的“ firstString”和“ secondString”的图形说明。

    9f6e109a8fc3d65f67c67c1ad3d71ac3.png

    当我们使用new运算符创建字符串时,将创建一个新的字符串对象并将其存储在Java堆空间中。

    24fb500be03436925dc09daba3322f9a.png

    在上方,我们可以看到“ firstString”和“ secondString”指向字符串池中的“ coderolls”字符串,而“ thirdString”指向Java堆空间中的“ coderolls”。

    如果参数字符串在字典上大于指定的字符串,即参数字符串在指定的字符串之后,则返回负整数。(参数String>指定的String)

    如果参数字符串在字典上小于指定的字符串,即参数字符串在指定的字符串之前,则返回正整数。(参数String

    如果两个字符串在字典上都相等,则返回零。(参数String =指定的String)

    如果要忽略两个字符串的大小写,请使用compareToIgnoreCase()方法。

    我提供了一个使用compareTo()方法比较字符串的程序。它还包括一个用compareToIgnoreCase()方法忽略大小写的大小写。

    1

    /**

    2

    * A Java program to compare strings using compareTo()

    3

    * and compareToIgnoreCase() method.

    4

    *

    5

    * compareTo() compare strings lexicograpgically.

    6

    *

    7

    * @author Gaurav Kukade at coderolls.com

    8

    */

    9

    10

    public class CompareUsingCompareTo {

    11

    12

    public static void main(String[] args) {

    13

    14

    String firstString = "java";

    15

    String secondString = "coderolls";

    16

    String thirdString = "sql";

    17

    String fourthString = "CodeRolls";

    18

    19

    System.out.println("Comparing strings using compareTo() and compareToIgnoreCase() method

    ");

    20

    21

    // Using compareTo() method

    22

    System.out.print("firstString.compareTo(secondString) : ");

    23

    System.out.println(firstString.compareTo(secondString));

    24

    25

    System.out.print("firstString.compareTo(thirdString) : ");

    26

    System.out.println(firstString.compareTo(thirdString));

    27

    28

    /*

    29

    * Using compareToIgnoreCase() method to ignore

    30

    * case consideration (i.e. Capital or small) of both the strings.

    31

    */

    32

    System.out.print("secondString.compareToIgnoreCase(fourthString) : ");

    33

    System.out.println(secondString.compareToIgnoreCase(fourthString));

    34

    }

    35

    36

    }

    Output:

    1

    Comparing strings using compareTo() and compareToIgnoreCase() method

    2

    3

    firstString.compareTo(secondString) : 7

    4

    firstString.compareTo(thirdString) : -9

    5

    secondString.compareToIgnoreCase(fourthString) : 0

    结论

    我们可以使用以下给出的方法比较字符串:

    1. 使用equals()方法:用于检查字符串值是否相等的字符串中的equals()方法是否包含相同的字符序列。

    2. 使用==运算符:==运算符用于检查两个字符串的引用相等性,即它们是否指向同一字符串对象。

    3. 使用compareTo()方法:compareTo()方法用于按字典顺序(即按字母顺序)检查字符串。查看有关如何按字典顺序比较字符串的详细文章。

    大多数初学者Java开发人员在比较字符串时都会出错。他们想检查字符串的内容,但是他们使用==运算符检查它。

    始终建议使用equals()方法根据字符串的内容比较字符串。

    如果你对上面给出的代码块有任何疑问,请在下面的注释部分写下来。另外,在注释部分中,让我知道你是否还有其他方法可以比较Java中的两个字符串。

    感谢阅读!

    另外近期整理了一套完整的java架构思维导图,分享给同样正在认真学习的每位朋友~

    7600eaef28efd99e7065c05f85f165d6.png

    展开全文
  • 介绍字符串是Java中的一个...”在验证、排序、引用匹配等过程中,比较字符串非常有用。我列出了在Java比较字符串的三种不同方法。使用equals()方法(比较内容)使用==操作符(比较对象引用)使用compareTo()方法(按字...

    介绍

    字符串是Java中的一个特殊类。我们在Java程序中经常使用字符串,所以比较两个字符串是Java中的一种常见做法。在本文中,我尝试回答关于字符串的最常见问题,比如:“如何在Java中比较字符串?”

    在验证、排序、引用匹配等过程中,比较字符串非常有用。

    我列出了在Java中比较字符串的三种不同方法。

    使用equals()方法(比较内容)

    使用==操作符(比较对象引用)

    使用compareTo()方法(按字母顺序比较字符串)

    f27efa02cd95127f993ab292fea03b31.png

    1.使用Equals() 方法比较字符串

    这样,我正在使用 .equals() String类的实例方法。.equals() 方法原本 是 Object 类方法,而String类会覆盖它。

    equals() 方法比较两个字符串的值相等性,无论它们在逻辑上是否相等。

    equals() String类中的方法将另一个字符串作为参数,并将其与指定的字符串进行比较。true 当且仅当参数字符串不为null且包含与指定字符串相同的字符时,它返回 。

    public boolean equals(Object anObject)It compare this string with the argument strings and return true if the argument is not null and contains the same character as the specified string.param -another stringreturns -true - if argument is not null and it contains same characters as the specified string13ex. firstString.equals(secondString)14// returns true if and only if the secondString is not null and contains the same characters as firstString.

    已要求程序使用以下equals() 方法比较字符串 :

    /**2 * A Java program to compare two strings using equsls()3 * and equalsIgnoreCase() method of the String.4 * 5 * @author Gaurav Kukade at coderolls.com6 */78public class CompareUsingEquals {910  public static void main(String[] args) {11    String firstString = "coderolls";12    String secondString = "javablog";13    String thirdString = "coderolls";14    String fourthString = "CodeRolls";1516    System.out.println("Comparing strings using equals() and equalsIgnoreCase() method");1718    // Using equals() method19    System.out.println(firstString.equals(secondString));    System.out.print("firstString.equals(thirdString) : ");    System.out.println(firstString.equals(thirdString));    /*     * Using equalsIgnoreCase() method to ignore     * case consideration (i.e. Capital or small) of both the strings.     */    System.out.print("firstString.equalsIgnoreCase(fourthString) : ");    System.out.println(firstString.equalsIgnoreCase(fourthString));  }}

    输出:

    Comparing strings using equals() and equalsIgnoreCase() methodfirstString.equals(secondString) : falsefirstString.equals(thirdString) : truefirstString.equalsIgnoreCase(fourthString) : true

    2. 使用==操作符比较字符串

    在String中,==操作符用于比较给定字符串的引用,这取决于它们是否引用相同的对象。

    当使用==操作符比较两个字符串时,如果字符串变量指向相同的java对象,则返回true。否则,它将返回false。

    我已经给出了一个Java程序来比较使用==操作符如下:

    / ** *一个Java程序,用于使用==运算符比较字符串。 *  * ==运算符会终止是否两个字符串都引用 *到相同的String对象。 * /public class CompareUsingEqualsToOperator {  public static void main(String[] args) {    String firstString = "coderolls";    String secondString = "javablog";    String thirdString = "coderolls";    //建具有与firstString或thirdString相同值的新String对象    String fourthString =  new String("coderolls");    System.out.println("Comparing strings using == operator ");    System.out.print("firstString == secondString : ");    System.out.println(firstString == secondString);   / *     *这里firstString和thirdString指的是相同的String对象     * /    System.out.print("firstString == thirdString : ");    System.out.println(firstString == thirdString);    /*     * Here firstString and fourthString have same value     * but they are referring to the different String object.     *      * hence it will print 'false'     */    System.out.print("firstString == fourthString : ");    System.out.println(firstString == fourthString);  }}

    输出:

    Comparing strings using == operator firstString == secondString : falsefirstString == thirdString : truefirstString == fourthString : false

    使用==操作符进行字符串比较的问题

    大多数初学Java的开发人员都会犯这个错误,他们使用==操作符比较两个字符串。

    逻辑上,它们必须检查两个字符串是否包含相同的字符序列。

    在Java字符串中,==操作符用于检查字符串对象和equals()方法的引用,equals()方法用于检查两个字符串的值是否相等。

    == -检查引用是否相等

    equals()——检查值是否相等

    当我们将字符串值赋给字符串变量时,JVM将检查字符串池中是否已经存在具有相等值的字符串。如果它不在字符串池中,它将被添加到常量池中,并返回对该字符串对象的引用。

    如果它存在于字符串池中,则返回对该字符串对象的内存地址的引用。

    下面的图像显示了同样的图形解释。

    724bd1f2a0d1c4cb9f17e0b3bbfd4cb6.png

    在上方,我们firstString指向字符串池中的“ coderolls”字符串。

    如果我们将相等的值分配给另一个字符串变量,JVM将检查具有该值的字符串是否出现在字符串常量池中。

    由于在前面的步骤中已经创建了具有该值的string对象,所以另一个string变量开始引用前面创建的string对象实例。

    下面的图像显示了“firstString”和“secondString”的图形说明,它们指向字符串池中的“coderolls”字符串。

    83597aea5e6e13d9b69f980c407e54dc.png

    当我们使用new 运算符创建字符串时,将创建一个 新的字符串对象并将其存储在Java堆空间中。

    ef896fd4d4d4db3800ae790ac609272c.png

    在上方,我们可以看到' firstString'和' secondString'指向coderolls字符串池中的“ ”字符串,而' thirdString'指向coderollsJava堆空间中的“ ”。

    如果参数字符串在词法上大于指定字符串,也就是说,如果参数字符串在指定字符串之后,那么它返回一个负整数。(参数字符串>指定字符串)

    如果参数字符串在字典上比指定字符串小,也就是说,如果参数字符串在指定字符串之前,则返回正整数。(参数字符串

    如果两个字符串都是lexicographic equals,则返回0。(参数字符串=指定字符串)

    如果想忽略两个字符串的情况,请使用compareToIgnoreCase()方法。

    我已经给出了一个使用compareTo()方法比较字符串的程序。它还包含一个用compareToIgnoreCase()方法忽略案例的案例。

    /**2 * A Java program to compare strings using compareTo()3 * and compareToIgnoreCase() method.4 * 5 * compareTo() compare strings lexicograpgically.6 * 7 * @author Gaurav Kukade at coderolls.com8 */910public class CompareUsingCompareTo {1112  public static void main(String[] args) {13    14    String firstString = "java";15    String secondString = "coderolls";16    String thirdString = "sql";17    String fourthString = "CodeRolls";18    19    System.out.println("Comparing strings using compareTo() and compareToIgnoreCase() method");20    21    // Using compareTo() method22    System.out.println(firstString.compareTo(secondString));    System.out.print("firstString.compareTo(thirdString) : ");    System.out.println(firstString.compareTo(thirdString));    /*29     * Using compareToIgnoreCase() method to ignore30     * case consideration (i.e. Capital or small) of both the strings.31     */    System.out.print("secondString.compareToIgnoreCase(fourthString) : ");    System.out.println(secondString.compareToIgnoreCase(fourthString));  }}

    输出:

    Comparing strings using compareTo() and compareToIgnoreCase() methodfirstString.compareTo(secondString) : 7firstString.compareTo(thirdString) : -9secondString.compareToIgnoreCase(fourthString) : 0

    结论

    我们可以用下面的方法来比较字符串:

    在字符串中使用equals()方法:equals()方法用于检查字符串值是否包含相同的字符序列。

    使用==操作符:==操作符检查两个字符串的引用是否相等,是否指向同一个字符串对象。

    使用compareTo()方法:compareTo()方法用于按字母顺序检查字符串。查看关于如何按字典顺序比较字符串的详细文章。

    大多数初学Java的开发人员在比较字符串时都会出错。他们想要检查字符串的内容,但是他们使用==操作符来检查它。

    总是建议使用equals()方法根据字符串的内容比较字符串。

    展开全文
  • 您可以将字符串放在TreeSet中,也可以使用Collections或Arrays进行排序。但是,在您的情况下,您不希望“自然排序”,您真的需要一个自定义比较器,然后您可以在Collections.sort方法或带有比较器的Arrays.sort...

    String实现了Comparable,这就是Java中的自然顺序(使用类似的接口进行比较)。您可以将字符串放在TreeSet中,也可以使用Collections或Arrays类进行排序。

    但是,在您的情况下,您不希望“自然排序”,您真的需要一个自定义比较器,然后您可以在Collections.sort方法或带有比较器的Arrays.sort方法中使用它。

    就你想要在比较器中实现的特定逻辑而言(由点分隔的数字)我不知道任何现有的标准实现,但正如你所说,这不是一个难题。

    编辑:在你的评论中,你的链接让你在这里,如果你不介意它是区分大小写的事实,这是一个体面的工作。这是修改后的代码,允许您传入String.CASE_INSENSITIVE_ORDER:/*

    * The Alphanum Algorithm is an improved sorting algorithm for strings

    * containing numbers.  Instead of sorting numbers in ASCII order like

    * a standard sort, this algorithm sorts numbers in numeric order.

    *

    * The Alphanum Algorithm is discussed at http://www.DaveKoelle.com

    *

    *

    * This library is free software; you can redistribute it and/or

    * modify it under the terms of the GNU Lesser General Public

    * License as published by the Free Software Foundation; either

    * version 2.1 of the License, or any later version.

    *

    * This library is distributed in the hope that it will be useful,

    * but WITHOUT ANY WARRANTY; without even the implied warranty of

    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    * Lesser General Public License for more details.

    *

    * You should have received a copy of the GNU Lesser General Public

    * License along with this library; if not, write to the Free Software

    * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

    *

    */

    import java.util.Comparator;

    /**

    * This is an updated version with enhancements made by Daniel Migowski,

    * Andre Bogus, and David Koelle

    *

    * To convert to use Templates (Java 1.5+):

    *   - Change "implements Comparator" to "implements Comparator"

    *   - Change "compare(Object o1, Object o2)" to "compare(String s1, String s2)"

    *   - Remove the type checking and casting in compare().

    *

    * To use this class:

    *   Use the static "sort" method from the java.util.Collections class:

    *   Collections.sort(your list, new AlphanumComparator());

    */

    public class AlphanumComparator implements Comparator

    {

    private Comparator comparator = new NaturalComparator();

    public AlphanumComparator(Comparator comparator) {

    this.comparator = comparator;

    }

    public AlphanumComparator() {

    }

    private final boolean isDigit(char ch)

    {

    return ch >= 48 && ch <= 57;

    }

    /** Length of string is passed in for improved efficiency (only need to calculate it once) **/

    private final String getChunk(String s, int slength, int marker)

    {

    StringBuilder chunk = new StringBuilder();

    char c = s.charAt(marker);

    chunk.append(c);

    marker++;

    if (isDigit(c))

    {

    while (marker 

    {

    c = s.charAt(marker);

    if (!isDigit(c))

    break;

    chunk.append(c);

    marker++;

    }

    } else

    {

    while (marker 

    {

    c = s.charAt(marker);

    if (isDigit(c))

    break;

    chunk.append(c);

    marker++;

    }

    }

    return chunk.toString();

    }

    public int compare(String s1, String s2)

    {

    int thisMarker = 0;

    int thatMarker = 0;

    int s1Length = s1.length();

    int s2Length = s2.length();

    while (thisMarker 

    {

    String thisChunk = getChunk(s1, s1Length, thisMarker);

    thisMarker += thisChunk.length();

    String thatChunk = getChunk(s2, s2Length, thatMarker);

    thatMarker += thatChunk.length();

    // If both chunks contain numeric characters, sort them numerically

    int result = 0;

    if (isDigit(thisChunk.charAt(0)) && isDigit(thatChunk.charAt(0)))

    {

    // Simple chunk comparison by length.

    int thisChunkLength = thisChunk.length();

    result = thisChunkLength - thatChunk.length();

    // If equal, the first different number counts

    if (result == 0)

    {

    for (int i = 0; i 

    {

    result = thisChunk.charAt(i) - thatChunk.charAt(i);

    if (result != 0)

    {

    return result;

    }

    }

    }

    } else

    {

    result = comparator.compare(thisChunk, thatChunk);

    }

    if (result != 0)

    return result;

    }

    return s1Length - s2Length;

    }

    private static class NaturalComparator implements Comparator {

    public int compare(String o1, String o2) {

    return o1.compareTo(o2);

    }

    }

    }

    展开全文
  • ,但是在实际的开发中,我们需要对多个对象进行排序,就是需要比较对象的大小Java实现对象排序的方式有两种:自然排序java.lang.Comparable定制排序java.util.Comparator1. Comparable 自然排序像String、包装...

    正文

    Java中的对象正常情况下只能进行比较 == 或者 != 不能使用 > < ,但是在实际的开发中,我们需要对多个对象进行排序,就是需要比较对象的大小

    Java实现对象排序的方式有两种:

    自然排序:java.lang.Comparable

    定制排序:java.util.Comparator

    1. Comparable 自然排序

    像String、包装类等实现了Comparable接口,重写了compareTo(obj)方法,给出了比较两个对象大小的方式。

    像String、包装类重写compareTo()方法以后,进行了从小到大的排列

    重写compareTo(obj)的规则:

    如果当前对象this大于形参对象obj,则返回正整数

    如果当前对象this小于形参对象obj,则返回负整数

    如果当前对象this等于形参对象obj,则返回零

    对于自定义类来说,如果需要排序,我们可以让自定义类实现Comparable接口,重写compareTo(obj)方法。在compareTo(obj)方法中指明如何排序,默认也是从小到大

    public void test1(){

    String[] arr = new String[]{"AA","BB","DD","WW","MM","PP","CC"};

    Arrays.sort(arr);

    System.out.println(Arrays.toString(arr));//[AA, BB, CC, DD, MM, PP, WW]

    }

    自定义类需要重写

    package com.atguigu.java1;

    /**

    * @author MD

    * @create 2020-07-13 15:52

    */

    public class Goods implements Comparable{

    private String name;

    private double price;

    public Goods() {

    }

    public Goods(String name, double price) {

    this.name = name;

    this.price = price;

    }

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    public double getPrice() {

    return price;

    }

    public void setPrice(double price) {

    this.price = price;

    }

    @Override

    public String toString() {

    return "Goods{" +

    "name='" + name + '\'' +

    ", price=" + price +

    '}';

    }

    // 指明商品比较大小的方式:按照价格的方式从小到大,再按照商品名从低到高

    @Override

    public int compareTo(Object o) {

    if(o instanceof Goods){

    Goods goods = (Goods)o;

    // 方式一

    if (this.price > goods.price){

    return 1;

    }else if(this.price < goods.price){

    return -1;

    }else{

    //return 0;

    return this.name.compareTo(goods.name);

    }

    // 方式二:

    //return Double.compare(this.price , goods.price);

    }

    throw new RuntimeException("传入的参数不合法");

    }

    }

    // 测试

    public void test2(){

    Goods[] arr = new Goods[4];

    arr[0] = new Goods("lx",123.12);

    arr[1] = new Goods("xm",23.12);

    arr[2] = new Goods("hw",67);

    arr[3] = new Goods("de",99);

    Arrays.sort(arr);

    System.out.println(Arrays.toString(arr));

    //[Goods{name='xm', price=23.12}, Goods{name='hw', price=67.0}, Goods{name='de', price=99.0}, Goods{name='lx', price=123.12}]

    }

    2. Comparator 定制排序

    当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码, 或者实现了java.lang.Comparable接口的排序规则不适合当前的操作,那 么可以考虑使用 Comparator 的对象来排序

    重写compare(Object o1,Object o2)方法,比较o1和o2的大小:如果方法返 回正整数,则表示o1大于o2;如果返回0,表示相等;返回负整数,表示 o1小于o2。

    可以将 Comparator 传递给 sort 方法(如 Collections.sort 或 Arrays.sort), 从而允许在排序顺序上实现精确控制。

    还可以使用 Comparator 来控制某些数据结构(如有序 set或有序映射)的 顺序,或者为那些没有自然顺序的对象 collection 提供排序。

    // 这里没有使用泛型,String已经重写了compareTo(obj)方法直接调

    public void test3(){

    String[] arr = new String[]{"AA","BB","DD","WW","MM","PP","CC"};

    // 这里使用匿名

    Arrays.sort(arr, new Comparator() {

    // 安装字符串从大到小

    @Override

    public int compare(Object o1, Object o2) {

    if (o1 instanceof String && o2 instanceof String){

    String s1 = (String)o1;

    String s2 = (String)o2;

    return -s1.compareTo(s2);

    }

    throw new RuntimeException("输入不合法");

    }

    });

    System.out.println(Arrays.toString(arr));//[WW, PP, MM, DD, CC, BB, AA]

    }

    默认从小到大,可以直接再前面加符号就是从高到低

    String、包装类已经实现了compare()直接调用即可

    public void test4(){

    Goods[] arr = new Goods[4];

    arr[0] = new Goods("lx",123.1);

    arr[1] = new Goods("lx",23.12);

    arr[2] = new Goods("hw",67);

    arr[3] = new Goods("de",99);

    // 指明商品比较大小的方式,安装产品的名称从低到高排序,若名称一样,再安装价格从高到底排序

    Arrays.sort(arr, new Comparator() {

    @Override

    public int compare(Goods o1, Goods o2) {

    if (o1.getName().equals(o2.getName())){

    return -Double.compare(o1.getPrice(),o2.getPrice());

    }else{

    return o1.getName().compareTo(o2.getName());

    }

    }

    });

    System.out.println(Arrays.toString(arr));

    //[Goods{name='de', price=99.0}, Goods{name='hw', price=67.0}, Goods{name='lx', price=123.1}, Goods{name='lx', price=23.12}]

    }

    Comparable接口与Comparator的使用的对比:

    Comparable接口的方式一旦一定,保证Comparable接口实现类的对象在任何位置都可以比较大小。

    Comparator接口属于临时性的比较。

    以上就是详解Java比较器的详细内容,更多关于Java比较器的资料请关注脚本之家其它相关文章!

    展开全文
  • 一、Java比较汉字// Collator 是用来执行区分语言环境的 String 比较的,这里选择使用CHINAComparator cmp = Collator.getInstance(java.util.Locale.CHINA);TreeMap tree=new TreeMap(cmp);String[] arr = {"张三...
  • Java环境下,对字符串数组或者对字符串排序都是一件很容易的事情,只要调用java.util包下的Arrays的sort方法即可对其排序。有没有想过,我们自己也可以利用排序* 一趟快速排序是:*1,随机产生一数列,选取第一...
  • 介绍字符串是Java中的一个...”在验证、排序、引用匹配等过程中,比较字符串非常有用。我列出了在Java比较字符串的三种不同方法。使用equals()方法(比较内容)使用==操作符(比较对象引用)使用compareTo()方法(按字...
  • 在学TreeSet中,因为TreeSet底层使二叉树,所以使用其排序时,得使用恰当,否则运行时会发生错误,还有的就是得学会用比较排序。需要实现Comparable接口,并重写comparaTo方法,写出要排序的规则,比如说按...
  • 我试图通过声明我自己的匿名比较器使用Collections.sort对我的自定义数组列表进行排序.但这种方式并没有按预期运作.我的代码是Collections.sort(arrlstContacts, new Comparator() {public int compare(Contacts ...
  • 我需要编写一个比较比较字符串Java比较器,但是只有一个扭曲。如果要比较的两个字符串在字符串的开头和结尾处是相同的,而不同的中间部分是整数,则根据这些整数的数值进行比较。例如,我希望以下字符串按显示...
  • // Collator 是用来执行区分语言环境的 String 比较的,这里选择使用CHINA  Comparator cmp = Collator.getInstance(java.util.Locale.CHINA);  TreeMap tree=new TreeMap(cmp);   String[] arr = {"张三...
  • Java之数字字符串排序

    2020-06-03 17:44:24
    A:案例:我有如下一个字符串:”91 27 46 38 50”,请写代码实现最终输出结果是:”27 38 46 50 91” 分析: ...注意:字符串也可排序,但是按第一位数字比较,故排序前应将String数组转换成int数组
  • Java中一涉及中文处理就会冒出很多问题来,其中排序也是一个让人头疼的课题,我们来看下面的...我们知道Arrays工具的默认排序是通过数组元素的compareTo方法来进行比较的,那我们来看String的compareTo的主...
  • 遇到了一个对包含中文的字符串进行排序的问题。要求按unicode编码对...按unicode排序的期望结果应该是这样的:1-编辑, 1-测试, 1-营销, 1-qt, 1结束, 2-测试先按java.lang.String提供的默认比较方案进行实现,大...
  • 不会空的话,求长度 ,相邻2个字符比较第一轮i=0:第一次:第一位和第二位比较 如果第一位>第二位,交换,否则不交换第二次: 第二位和第三位交换 如果第二位>第三位,交换,否则不交换依次推 直到最后 ...
  • 不会空的话,求长度 ,相邻2个字符比较第一轮i=0: 第一次:第一位和第二位比较 如果第一位>第二位,交换,否则不交换 第二次: 第二位和第三位交换 如果第二位>第三位,交换,否则不交换 依次推 直到...
  • 对一个字符串中的数值进行从小到大的排序例子:"20 78 9 -7 88 36 29"返回一个字符串。基本思路:1,排序,我很熟。可是我只熟int。2,如何获取到这个字符串中的这些需要排序的数值?发现这个字符串中其实都是空格来...
  • List<String> list=Lists.newArrayList("北京","天津","上海"); Comparator cmp = Collator....Collator 执行区分语言环境的 String 比较。使用此类可为自然语言文本构建搜索和排序例程。 Collator 是
  • Java字符串排序

    千次阅读 2008-09-15 20:37:00
    我们知道,Java的String有两个方法可以进行字符串比较:compareTo(String)和compareToIngoreCase(String)。如果只是对英文字符串进行排序,这完全没有问题。但如果需要对其他语言进行排序,那么,String的这两个...
  • 关于的声明与创建;掌握的继承和多态。
  • 由于您希望收集您的收藏,我建议您使用列表和Collections.sort....让辅助Score实现可比较< Score>这是一个例子,后一种方法是ideone demo:import java.util.*;class Score implements Comparable {i...
  • Java 字符串列表拼音排序功能

    千次阅读 2009-01-13 08:22:00
    对于List列表接口的排序通常用的是Collections.sort(List list, Comparator c) 方法,因此比较器部分Comparator需要自己去写。以下是一个按拼音正、反排序的功能。import java.text.Collator;import java.util....
  • Array.sort 如何根据字符串长度排序? 这里的知识点包括: Array,sort() 函数。其第一个参数是要排序的数组,第二个参数是比较方法。 lambda 表达式。其形式为 (参数) -> 逻辑表达式。 Integer.compare() 函数。...
  • 如果不能仅将日期存储为Date对象,则需要定义一个自定义比较器(最终会将字符串隐式转换为Date对象,因此您也可以将它们存储为日期)。 您可以将这两个都定义为中的字段:private final static String dateFormat = ...
  • /** 1,给定一个字符串数组。按照字典顺序进行从小到大的排序。...* 3,问题:以前排的是整数,比较用的比较运算符,可是现在是字符串对象。* 字符串对象怎么比较呢?爽了,对象中提供了用于字符串对象比较的功能...
  • import java.util.*; import java.text.*; public class SortByChinese { ... public static void main(String[] args) {... // Collator 是用来执行区分语言环境的 String 比较的,这里选择使用CHINA Com...
  • 数组的简单排序有三种方式:1.冒泡排序依次比较两个相邻的元素,如果他们的顺序(如从大到小、首字母从A到Z)错误...话不多说,代码实现(java开发环境:jdk8idea):①创建数组实例和测试方法public ②排序方法实现p...
  • 题目:根据字符串内字符的ASCII码值对字符串数组进行排序。分析:字符串用ASCII码比较大小,规则是:1、比较首字母的ASCII码大小2、若是前面的字母相同,则比较之后的字母的ASCII码值3、若是一个字符串从首字母开始...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 441
精华内容 176
关键字:

java类排序比较字符串

java 订阅