不说废话之java对象的比较

out
.
println
(
c1

c2
);

boolean
b1

true
;

boolean
b2

false
;

System
.
out
.
println
(
b1

b2
);

System
.
out
.
println
(
b1
!=
b2
);

}

}

2 对象的比较

class
Card
{

public
int
rank
;
//
数值

public
String
suit
;
//
花色

public
Card
(
int
rank
,
String
suit
) {

this
.
rank

rank
;

this
.
suit

suit
;

}

}

public class
TestPriorityQueue
{

public static
void
main
(
String
[]
args
) {

Card c1

new
Card
(
1
,
“♠”
);

Card c2

new
Card
(
2
,
“♠”
);

Card c3

c1
;

//System.out.println(c1 > c2); //
编译报错

System
.
out
.
println
(
c1

c2
);
//
编译成功
---->
打印
false
，因为
c1
和
c2
指向的是不同对象

//System.out.println(c1 < c2); //
编译报错

System
.
out
.
println
(
c1

c3
);
//
编译成功
---->
打印
true
，因为
c1
和
c3
指向的是同一个对象

}

}

c1
、
c2
和
c3
分别是
Card
类型的引用变量，上述代码在比较编译时：

c1 > c2
编译失败

c1== c2
编译成功

c1 < c2
编译失败

从编译结果可以看出，
Java
中引用类型的变量不能直接按照
>
或者
<
方式进行比较
。 那为什么

可以比较？

因为：
对于用户实现自定义类型，都默认继承自
Object
类，而
Object
类中提供了
equal
方法，而
==
默认情况下调

用的就是
equal
方法
，但是该方法的比较规则是：
没有比较引用变量引用对象的内容，而是直接比较引用变量的地

址
，但有些情况下该种比较就不符合题意。

三：对象的比较

有些情况下，需要比较的是对象中的内容，比如：向优先级队列中插入某个对象时，需要对按照对象中内容来调整

堆，那该如何处理呢？

1 覆写基类的equal

public class
Card
{

public
int
rank
;
//
数值

public
String
suit
;
//
花色

public
Card
(
int
rank
,
String
suit
) {

this
.
rank

rank
;

this
.
suit

suit
;

}

@Override

public
boolean
equals
(
Object
o
) {

//
自己和自己比较

if
(
this

o
) {

return
true
;

}

// o
如果是
null
对象，或者
o
不是
Card
的子类

if
(
o

null
|| !
(
o
instanceof
Card
)) {

return
false
;

}

//
注意基本类型可以直接比较，但引用类型最好调用其
equal
方法

Card c

(
Card
)
o
;

return
rank

c
.
rank

&&
suit
.
equals
(
c
.
suit
);

}

}

注意：
一般覆写
equals
的套路就是上面演示的

如果指向同一个对象，返回
true

如果传入的为
null
，返回
false

如果传入的对象类型不是
Card
，返回
false

按照类的实现目标完成比较，例如这里只要花色和数值一样，就认为是相同的牌

注意下调用其他引用类型的比较也需要
equals
，例如这里的
suit
的比较

覆写基类
equal
的方式虽然可以比较，但缺陷是：
equal
只能按照相等进行比较，不能按照大于、小于的方式进行

比较
。

2 基于comparable接口类的比较

Comparble
是
JDK
提供的泛型的比较接口类，源码实现具体如下：

public interface
Comparable
<
E

{

//
返回值
:

// < 0:
表示
this
指向的对象小于
o
指向的对象

// == 0:
表示
this
指向的对象等于
o
指向的对象

// > 0:
表示
this
指向的对象等于
o
指向的对象

int
compareTo
(
E o
);

}

对用用户自定义类型，如果要想按照大小与方式进行比较时：
在定义类时，实现
Comparble
接口即可，然后在类

中重写
compareTo
方法。

public class
Card
implements
Comparable
<
Card

{

public
int
rank
;
//
数值

public
String
suit
;
//
花色

public
Card
(
int
rank
,
String
suit
) {

this
.
rank

rank
;

this
.
suit

suit
;

}

//
根据数值比较，不管花色

//
这里我们认为
null
是最小的

@Override

public
int
compareTo
(
Card o
) {

if
(
o

null
) {

return
1
;

}

return
rank

o
.
rank
;

}

public static
void
main
(
String
[]
args
){

Card p

new
Card
(
1
,
“♠”
);

Card q

new
Card
(
2
,
“♠”
);

Card o

new
Card
(
1
,
“♠”
);

System
.
out
.
println
(
p
.
compareTo
(
o
));
// == 0
，表示牌相等

System
.
out
.
println
(
p
.
compareTo
(
q
));
// < 0
，表示
p
比较小

System
.
out
.
println
(
q
.
compareTo
(
p
));
// > 0
，表示
q
比较大

}

}

Compareble是java.lang中的接口类，可以直接使用。

3 基于比较器的比较

按照比较器方式进行比较，具体步骤如下：

用户自定义比较器类，实现
Comparator接口

public interface
Comparator
<
T

{

//
返回值
:

// < 0:
表示
o1
指向的对象小于
o2
指向的对象

// == 0:
表示
o1
指向的对象等于
o2
指向的对象

// > 0:
表示
o1
指向的对象等于
o2
指向的对象

int
compare
(
T o1
,
T o2
);

}

注意：
区分
Comparable
和
Comparator
。

覆写
Comparator
中的
compare
方法

import
java
.
util
.
Comparator
;

class
Card
{

public
int
rank
;
//
数值

public
String
suit
;
//
花色

public
Card
(
int
rank
,
String
suit
) {

this
.
rank

rank
;

this
.
suit

suit
;

}

}

class
CardComparator
implements
Comparator
<
Card

{

//
根据数值比较，不管花色

//
这里我们认为
null
是最小的

@Override

public
int
compare
(
Card o1
,
Card o2
) {

if
(
o1

o2
) {

return
0
;

}

if
(
o1

null
) {

return

1
;

}

if
(
o2

null
) {

return
1
;

}

return
o1
.
rank

o2
.
rank
;

}

public static
void
main
(
String
[]
args
){

Card p

new
Card
(
1
,
“♠”
);

Card q

总目录展示

该笔记共八个节点（由浅入深），分为三大模块。

高性能。 秒杀涉及大量的并发读和并发写，因此支持高并发访问这点非常关键。该笔记将从设计数据的动静分离方案、热点的发现与隔离、请求的削峰与分层过滤、服务端的极致优化这4个方面重点介绍。

一致性。 秒杀中商品减库存的实现方式同样关键。可想而知，有限数量的商品在同一时刻被很多倍的请求同时来减库存，减库存又分为“拍下减库存”“付款减库存”以及预扣等几种，在大并发更新的过程中都要保证数据的准确性，其难度可想而知。因此，将用一个节点来专门讲解如何设计秒杀减库存方案。

高可用。 虽然介绍了很多极致的优化思路，但现实中总难免出现一些我们考虑不到的情况，所以要保证系统的高可用和正确性，还要设计一个PlanB来兜底，以便在最坏情况发生时仍然能够从容应对。笔记的最后，将带你思考可以从哪些环节来设计兜底方案。

---

篇幅有限，无法一个模块一个模块详细的展示（这些要点都收集在了这份《高并发秒杀顶级教程》里），麻烦各位转发一下（可以帮助更多的人看到哟！）

由于内容太多，这里只截取部分的内容。

return
0
;

}

if
(
o1

null
) {

return

1
;

}

if
(
o2

null
) {

return
1
;

}

return
o1
.
rank

o2
.
rank
;

}

public static
void
main
(
String
[]
args
){

Card p

new
Card
(
1
,
“♠”
);

Card q

总目录展示

该笔记共八个节点（由浅入深），分为三大模块。

高性能。 秒杀涉及大量的并发读和并发写，因此支持高并发访问这点非常关键。该笔记将从设计数据的动静分离方案、热点的发现与隔离、请求的削峰与分层过滤、服务端的极致优化这4个方面重点介绍。

一致性。 秒杀中商品减库存的实现方式同样关键。可想而知，有限数量的商品在同一时刻被很多倍的请求同时来减库存，减库存又分为“拍下减库存”“付款减库存”以及预扣等几种，在大并发更新的过程中都要保证数据的准确性，其难度可想而知。因此，将用一个节点来专门讲解如何设计秒杀减库存方案。

高可用。 虽然介绍了很多极致的优化思路，但现实中总难免出现一些我们考虑不到的情况，所以要保证系统的高可用和正确性，还要设计一个PlanB来兜底，以便在最坏情况发生时仍然能够从容应对。笔记的最后，将带你思考可以从哪些环节来设计兜底方案。

---

篇幅有限，无法一个模块一个模块详细的展示（这些要点都收集在了这份《高并发秒杀顶级教程》里），麻烦各位转发一下（可以帮助更多的人看到哟！）

[外链图片转存中…(img-1WpI7LW9-1721168605227)]

[外链图片转存中…(img-Q9V7UIo4-1721168605228)]

由于内容太多，这里只截取部分的内容。