FilesExpand file tree

 master

/

Comparators.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

98 lines (88 loc) · 2.38 KB

 master

/

Comparators.java

Copy path

Top

File metadata and controls

• Code
• Blame

98 lines (88 loc) · 2.38 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

/*

* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.

* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*/

package java.util;

import java.io.Serializable;

import java.util.function.BinaryOperator;

import java.util.function.Function;

import java.util.function.ToDoubleFunction;

import java.util.function.ToIntFunction;

import java.util.function.ToLongFunction;

/**

* Package private supporting class for {@link Comparator}.

*/

class Comparators {

private Comparators() {

throw new AssertionError("no instances");

}

/**

* Compares {@link Comparable} objects in natural order.

*

* @see Comparable

*/

enum NaturalOrderComparator implements Comparator<Comparable<Object>> {

INSTANCE;

@Override

public int compare(Comparable<Object> c1, Comparable<Object> c2) {

return c1.compareTo(c2);

}

@Override

public Comparator<Comparable<Object>> reversed() {

return Comparator.reverseOrder();

}

}

/**

* Null-friendly comparators

*/

final static class NullComparator<T> implements Comparator<T>, Serializable {

private static final long serialVersionUID = -7569533591570686392L;

private final boolean nullFirst;

// if null, non-null Ts are considered equal

private final Comparator<T> real;

@SuppressWarnings("unchecked")

NullComparator(boolean nullFirst, Comparator<? super T> real) {

this.nullFirst = nullFirst;

this.real = (Comparator<T>) real;

}

@Override

public int compare(T a, T b) {

if (a == null) {

return (b == null) ? 0 : (nullFirst ? -1 : 1);

} else if (b == null) {

return nullFirst ? 1: -1;

} else {

return (real == null) ? 0 : real.compare(a, b);

}

}

@Override

public Comparator<T> thenComparing(Comparator<? super T> other) {

Objects.requireNonNull(other);

return new NullComparator<>(nullFirst, real == null ? other : real.thenComparing(other));

}

@Override

public Comparator<T> reversed() {

return new NullComparator<>(!nullFirst, real == null ? null : real.reversed());

}

}

}