The difference between comparable and Comparator in java
Nov 27, 2019 pm 01:20 PM
Comparable comparator
Comparable is located under the java.lang package. It is essentially an internal comparator. Classes that implement Comparable can themselves Comparison, as for the comparison result, it depends on the implementation of the natural comparison method compareTo.
The return values ??of compareTo are -1, 0, 1. If the comparator is greater than the compared object, 1 is returned, 0 is returned if it is equal, and -1 is returned if it is less than the compared object.
Collections.sort and Arrays.sort can automatically sort objects that implement Comparable.
Free online learning video recommendation: java learning
The example is as follows, we construct a node object and verify the usage of Comparable through comparison between node objects.
The implementation of the node object is as follows:
public class Node implements Comparable<Object>{
private int num;
private String name;
@Override
public String toString() {
return "num=" + num + " name=" + name;
}
public Node(int num, String name) {
super();
this.num = num;
this.name = name;
}
public Node() {
super();
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int compareTo(Object o) {
Node node = (Node)o;
return this.num - node.getNum();
}
}As you can see, we have implemented the Comparable interface for Node and overridden the compareTo method.
To test it first, we create 10 Node objects and add them to the List, and then shuffle the order.
public class MyTest {
public static void main(String[] args) {
List<Node> list = new ArrayList<Node>();
for(int i = 0;i < 10;i++) {
list.add(new Node(i,"node"));
}
//打亂順序
Collections.shuffle(list);
for (Node node : list) {
System.out.println(node);
}
}
}The results are displayed as follows:
num=7 name=node num=0 name=node num=5 name=node num=9 name=node num=6 name=node num=3 name=node num=4 name=node num=8 name=node num=1 name=node num=2 name=node
Now the output is out of order, next we use Collections.sort to sort it.
public class MyTest {
public static void main(String[] args) {
List<Node> list = new ArrayList<Node>();
for(int i = 0;i < 10;i++) {
list.add(new Node(i,"node"));
}
//打亂順序
Collections.shuffle(list);
Collections.sort(list);
for (Node node : list) {
System.out.println(node);
}
}
}Collections.sort actually compares according to the definition in the compareTo method. We previously defined sorting in ascending order of num. Now the sorting results are as follows:
num=0 name=node num=1 name=node num=2 name=node num=3 name=node num=4 name=node num=5 name=node num=6 name=node num=7 name=node num=8 name=node num=9 name=node
Comparator
Comparator is located under the java.util package and is essentially an external comparator. If a class does not implement Comparable internally or implements Comparable but the comparison method is not what you want, we can consider implementing Comparator. There is a compare method in the Comparator interface, and its usage is the same as compareTo in Comparable.
We need to pass the Comparator to the sorting method in order to control the sorting order. We can check the usage of several sorting methods and find that they can pass in a Comparator parameter.
Collections.sort(List<T> list, Comparator<? super T> c); Arrays.sort(T[] a, Comparator<? super T> c);
Modify our previous Node object and no longer implement Comparable.
public class Node{
private int num;
private String name;
@Override
public String toString() {
return "num=" + num + " name=" + name;
}
public Node(int num, String name) {
super();
this.num = num;
this.name = name;
}
public Node() {
super();
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}We try to achieve descending sorting by passing in a Comparator.
public class MyTest {
public static void main(String[] args) {
List<Node> list = new ArrayList<Node>();
for(int i = 0;i < 10;i++) {
list.add(new Node(i,"node"));
}
//打亂順序
Collections.shuffle(list);
Collections.sort(list, new Comparator<Node>() {
@Override
public int compare(Node o1, Node o2) {
return o2.getNum()-o1.getNum();
}
});
for (Node node : list) {
System.out.println(node);
}
}
}The results are as follows:
num=9 name=node num=8 name=node num=7 name=node num=6 name=node num=5 name=node num=4 name=node num=3 name=node num=2 name=node num=1 name=node num=0 name=node
Comparator implements reverse order comparison.
Summary
Comparable is an internal comparator, and Comparator is an external comparator. If the class does not implement the Comparable interface but needs to be sorted, we can consider using Comparator. From another perspective, the coupling of using the Comparable interface is greater than that of Comparator, because when we need to modify the comparison algorithm, we also need to modify the implementation class of Comparable.
This article comes from the java Quick Start column. Everyone is welcome to discuss and learn together!
The above is the detailed content of The difference between comparable and Comparator in java. For more information, please follow other related articles on the PHP Chinese website!
Hot AI Tools
Undress AI Tool
Undress images for free
Undresser.AI Undress
AI-powered app for creating realistic nude photos
AI Clothes Remover
Online AI tool for removing clothes from photos.
Clothoff.io
AI clothes remover
Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!
Hot Article
Hot Tools
Notepad++7.3.1
Easy-to-use and free code editor
SublimeText3 Chinese version
Chinese version, very easy to use
Zend Studio 13.0.1
Powerful PHP integrated development environment
Dreamweaver CS6
Visual web development tools
SublimeText3 Mac version
God-level code editing software (SublimeText3)
Hot Topics
How Java ClassLoaders Work Internally
Jul 06, 2025 am 02:53 AM
Java's class loading mechanism is implemented through ClassLoader, and its core workflow is divided into three stages: loading, linking and initialization. During the loading phase, ClassLoader dynamically reads the bytecode of the class and creates Class objects; links include verifying the correctness of the class, allocating memory to static variables, and parsing symbol references; initialization performs static code blocks and static variable assignments. Class loading adopts the parent delegation model, and prioritizes the parent class loader to find classes, and try Bootstrap, Extension, and ApplicationClassLoader in turn to ensure that the core class library is safe and avoids duplicate loading. Developers can customize ClassLoader, such as URLClassL
Asynchronous Programming Techniques in Modern Java
Jul 07, 2025 am 02:24 AM
Java supports asynchronous programming including the use of CompletableFuture, responsive streams (such as ProjectReactor), and virtual threads in Java19. 1.CompletableFuture improves code readability and maintenance through chain calls, and supports task orchestration and exception handling; 2. ProjectReactor provides Mono and Flux types to implement responsive programming, with backpressure mechanism and rich operators; 3. Virtual threads reduce concurrency costs, are suitable for I/O-intensive tasks, and are lighter and easier to expand than traditional platform threads. Each method has applicable scenarios, and appropriate tools should be selected according to your needs and mixed models should be avoided to maintain simplicity
Understanding Java NIO and Its Advantages
Jul 08, 2025 am 02:55 AM
JavaNIO is a new IOAPI introduced by Java 1.4. 1) is aimed at buffers and channels, 2) contains Buffer, Channel and Selector core components, 3) supports non-blocking mode, and 4) handles concurrent connections more efficiently than traditional IO. Its advantages are reflected in: 1) Non-blocking IO reduces thread overhead, 2) Buffer improves data transmission efficiency, 3) Selector realizes multiplexing, and 4) Memory mapping speeds up file reading and writing. Note when using: 1) The flip/clear operation of the Buffer is easy to be confused, 2) Incomplete data needs to be processed manually without blocking, 3) Selector registration must be canceled in time, 4) NIO is not suitable for all scenarios.
Best Practices for Using Enums in Java
Jul 07, 2025 am 02:35 AM
In Java, enums are suitable for representing fixed constant sets. Best practices include: 1. Use enum to represent fixed state or options to improve type safety and readability; 2. Add properties and methods to enums to enhance flexibility, such as defining fields, constructors, helper methods, etc.; 3. Use EnumMap and EnumSet to improve performance and type safety because they are more efficient based on arrays; 4. Avoid abuse of enums, such as dynamic values, frequent changes or complex logic scenarios, which should be replaced by other methods. Correct use of enum can improve code quality and reduce errors, but you need to pay attention to its applicable boundaries.
What is an anonymous inner class?
Jul 07, 2025 am 02:18 AM
Anonymous internal classes are used in Java to create subclasses or implement interfaces on the fly, and are often used to override methods to achieve specific purposes, such as event handling in GUI applications. Its syntax form is a new interface or class that directly defines the class body, and requires that the accessed local variables must be final or equivalent immutable. Although they are convenient, they should not be overused. Especially when the logic is complex, they can be replaced by Java8's Lambda expressions.
What are the types of stablecoins? What are the stablecoins in digital currency?
Jul 08, 2025 pm 11:51 PM
Stable coins maintain price stability by anchoring fiat currencies such as the US dollar, which are mainly divided into three categories: 1. Fiat currency collateralization types such as USDT and USDC; 2. Cryptocurrency collateralization types such as DAI; 3. Algorithm types have higher risks. Mainstream stablecoins include USDT with the highest market value and the best liquidity. USDC is known for its compliance and transparency. DAI relies on the decentralized mechanism. TUSD adopts on-chain real-time audit. BUSD is gradually withdrawing from the market due to supervision. USDP is known for its high compliance and security. Both are widely circulated on mainstream exchanges.
What are on-chain transactions and off-chain transactions? What's the difference?
Jul 07, 2025 pm 08:45 PM
On-chain transactions are transactions directly on the blockchain network. They are open and transparent, tamper-proof, decentralized and high security, but they are slower, have high fees and are irrevocable; off-chain transactions occur outside the blockchain, and have the advantages of fast speed, low fees and revocable, but rely on centralized institutions and lack transparency and security. 1. On-chain transactions require gas fees and wait for block confirmation, which is suitable for users who pursue security and transparency; 2. Off-chain transactions are efficient, suitable for high-frequency and small-scale transactions, but trust platforms; 3. Platforms that support on-chain transactions include decentralized platforms such as Uniswap, PancakeSwap, OpenSea, Aave; 4. Platforms that support off-chain transactions mainly include Binanc
What is a Singleton design pattern in Java?
Jul 09, 2025 am 01:32 AM
Singleton design pattern in Java ensures that a class has only one instance and provides a global access point through private constructors and static methods, which is suitable for controlling access to shared resources. Implementation methods include: 1. Lazy loading, that is, the instance is created only when the first request is requested, which is suitable for situations where resource consumption is high and not necessarily required; 2. Thread-safe processing, ensuring that only one instance is created in a multi-threaded environment through synchronization methods or double check locking, and reducing performance impact; 3. Hungry loading, which directly initializes the instance during class loading, is suitable for lightweight objects or scenarios that can be initialized in advance; 4. Enumeration implementation, using Java enumeration to naturally support serialization, thread safety and prevent reflective attacks, is a recommended concise and reliable method. Different implementation methods can be selected according to specific needs
