2544             T midVal = a[mid];
2545             int cmp = c.compare(midVal, key);
2546             if (cmp < 0)
2547                 low = mid + 1;
2548             else if (cmp > 0)
2549                 high = mid - 1;
2550             else
2551                 return mid; // key found
2552         }
2553         return -(low + 1);  // key not found.
2554     }
2555 
2556     // Equality Testing
2557 
2558     /**
2559      * Returns <tt>true</tt> if the two specified arrays of longs are
2560      * <i>equal</i> to one another.  Two arrays are considered equal if both
2561      * arrays contain the same number of elements, and all corresponding pairs
2562      * of elements in the two arrays are equal.  In other words, two arrays
2563      * are equal if they contain the same elements in the same order.  Also,
2564      * two array references are considered equal if both are <tt>null</tt>.<p>
2565      *
2566      * @param a one array to be tested for equality
2567      * @param a2 the other array to be tested for equality
2568      * @return <tt>true</tt> if the two arrays are equal
2569      */
2570     public static boolean equals(long[] a, long[] a2) {
2571         if (a==a2)
2572             return true;
2573         if (a==null || a2==null)
2574             return false;
2575 
2576         int length = a.length;
2577         if (a2.length != length)
2578             return false;
2579 
2580         for (int i=0; i<length; i++)
2581             if (a[i] != a2[i])
2582                 return false;
2583 
2584         return true;
2585     }
2586 
2587     /**
2588      * Returns <tt>true</tt> if the two specified arrays of ints are
2589      * <i>equal</i> to one another.  Two arrays are considered equal if both
2590      * arrays contain the same number of elements, and all corresponding pairs
2591      * of elements in the two arrays are equal.  In other words, two arrays
2592      * are equal if they contain the same elements in the same order.  Also,
2593      * two array references are considered equal if both are <tt>null</tt>.<p>
2594      *
2595      * @param a one array to be tested for equality
2596      * @param a2 the other array to be tested for equality
2597      * @return <tt>true</tt> if the two arrays are equal
2598      */
2599     public static boolean equals(int[] a, int[] a2) {
2600         if (a==a2)
2601             return true;
2602         if (a==null || a2==null)
2603             return false;
2604 
2605         int length = a.length;
2606         if (a2.length != length)
2607             return false;
2608 
2609         for (int i=0; i<length; i++)
2610             if (a[i] != a2[i])
2611                 return false;
2612 
2613         return true;
2614     }
2615 
2616     /**
2617      * Returns <tt>true</tt> if the two specified arrays of shorts are
2618      * <i>equal</i> to one another.  Two arrays are considered equal if both
2619      * arrays contain the same number of elements, and all corresponding pairs
2620      * of elements in the two arrays are equal.  In other words, two arrays
2621      * are equal if they contain the same elements in the same order.  Also,
2622      * two array references are considered equal if both are <tt>null</tt>.<p>
2623      *
2624      * @param a one array to be tested for equality
2625      * @param a2 the other array to be tested for equality
2626      * @return <tt>true</tt> if the two arrays are equal
2627      */
2628     public static boolean equals(short[] a, short a2[]) {
2629         if (a==a2)
2630             return true;
2631         if (a==null || a2==null)
2632             return false;
2633 
2634         int length = a.length;
2635         if (a2.length != length)
2636             return false;
2637 
2638         for (int i=0; i<length; i++)
2639             if (a[i] != a2[i])
2640                 return false;
2641 
2642         return true;
2643     }
2644 
2645     /**
2646      * Returns <tt>true</tt> if the two specified arrays of chars are
2647      * <i>equal</i> to one another.  Two arrays are considered equal if both
2648      * arrays contain the same number of elements, and all corresponding pairs
2649      * of elements in the two arrays are equal.  In other words, two arrays
2650      * are equal if they contain the same elements in the same order.  Also,
2651      * two array references are considered equal if both are <tt>null</tt>.<p>
2652      *
2653      * @param a one array to be tested for equality
2654      * @param a2 the other array to be tested for equality
2655      * @return <tt>true</tt> if the two arrays are equal
2656      */
2657     public static boolean equals(char[] a, char[] a2) {
2658         if (a==a2)
2659             return true;
2660         if (a==null || a2==null)
2661             return false;
2662 
2663         int length = a.length;
2664         if (a2.length != length)
2665             return false;
2666 
2667         for (int i=0; i<length; i++)
2668             if (a[i] != a2[i])
2669                 return false;
2670 
2671         return true;
2672     }
2673 
2674     /**
2675      * Returns <tt>true</tt> if the two specified arrays of bytes are
2676      * <i>equal</i> to one another.  Two arrays are considered equal if both
2677      * arrays contain the same number of elements, and all corresponding pairs
2678      * of elements in the two arrays are equal.  In other words, two arrays
2679      * are equal if they contain the same elements in the same order.  Also,
2680      * two array references are considered equal if both are <tt>null</tt>.<p>
2681      *
2682      * @param a one array to be tested for equality
2683      * @param a2 the other array to be tested for equality
2684      * @return <tt>true</tt> if the two arrays are equal
2685      */
2686     public static boolean equals(byte[] a, byte[] a2) {
2687         if (a==a2)
2688             return true;
2689         if (a==null || a2==null)
2690             return false;
2691 
2692         int length = a.length;
2693         if (a2.length != length)
2694             return false;
2695 
2696         for (int i=0; i<length; i++)
2697             if (a[i] != a2[i])
2698                 return false;
2699 
2700         return true;
2701     }
2702 
2703     /**
2704      * Returns <tt>true</tt> if the two specified arrays of booleans are
2705      * <i>equal</i> to one another.  Two arrays are considered equal if both
2706      * arrays contain the same number of elements, and all corresponding pairs
2707      * of elements in the two arrays are equal.  In other words, two arrays
2708      * are equal if they contain the same elements in the same order.  Also,
2709      * two array references are considered equal if both are <tt>null</tt>.<p>
2710      *
2711      * @param a one array to be tested for equality
2712      * @param a2 the other array to be tested for equality
2713      * @return <tt>true</tt> if the two arrays are equal
2714      */
2715     public static boolean equals(boolean[] a, boolean[] a2) {
2716         if (a==a2)
2717             return true;
2718         if (a==null || a2==null)
2719             return false;
2720 
2721         int length = a.length;
2722         if (a2.length != length)
2723             return false;
2724 
2725         for (int i=0; i<length; i++)
2726             if (a[i] != a2[i])
2727                 return false;
2728 
2729         return true;
2730     }
2731 
2732     /**
2733      * Returns <tt>true</tt> if the two specified arrays of doubles are
2734      * <i>equal</i> to one another.  Two arrays are considered equal if both
2735      * arrays contain the same number of elements, and all corresponding pairs
2736      * of elements in the two arrays are equal.  In other words, two arrays
2737      * are equal if they contain the same elements in the same order.  Also,
2738      * two array references are considered equal if both are <tt>null</tt>.<p>
2739      *
2740      * Two doubles <tt>d1</tt> and <tt>d2</tt> are considered equal if:
2741      * <pre>    <tt>new Double(d1).equals(new Double(d2))</tt></pre>
2742      * (Unlike the <tt>==</tt> operator, this method considers
2743      * <tt>NaN</tt> equals to itself, and 0.0d unequal to -0.0d.)
2744      *
2745      * @param a one array to be tested for equality
2746      * @param a2 the other array to be tested for equality
2747      * @return <tt>true</tt> if the two arrays are equal
2748      * @see Double#equals(Object)
2749      */
2750     public static boolean equals(double[] a, double[] a2) {
2751         if (a==a2)
2752             return true;
2753         if (a==null || a2==null)
2754             return false;
2755 
2756         int length = a.length;
2757         if (a2.length != length)
2758             return false;
2759 
2760         for (int i=0; i<length; i++)
2761             if (Double.doubleToLongBits(a[i])!=Double.doubleToLongBits(a2[i]))
2762                 return false;
2763 
2764         return true;
2765     }
2766 
2767     /**
2768      * Returns <tt>true</tt> if the two specified arrays of floats are
2769      * <i>equal</i> to one another.  Two arrays are considered equal if both
2770      * arrays contain the same number of elements, and all corresponding pairs
2771      * of elements in the two arrays are equal.  In other words, two arrays
2772      * are equal if they contain the same elements in the same order.  Also,
2773      * two array references are considered equal if both are <tt>null</tt>.<p>
2774      *
2775      * Two floats <tt>f1</tt> and <tt>f2</tt> are considered equal if:
2776      * <pre>    <tt>new Float(f1).equals(new Float(f2))</tt></pre>
2777      * (Unlike the <tt>==</tt> operator, this method considers
2778      * <tt>NaN</tt> equals to itself, and 0.0f unequal to -0.0f.)
2779      *
2780      * @param a one array to be tested for equality
2781      * @param a2 the other array to be tested for equality
2782      * @return <tt>true</tt> if the two arrays are equal
2783      * @see Float#equals(Object)
2784      */
2785     public static boolean equals(float[] a, float[] a2) {
2786         if (a==a2)
2787             return true;
2788         if (a==null || a2==null)
2789             return false;
2790 
2791         int length = a.length;
2792         if (a2.length != length)
2793             return false;
2794 
2795         for (int i=0; i<length; i++)
2796             if (Float.floatToIntBits(a[i])!=Float.floatToIntBits(a2[i]))
2797                 return false;
2798 
2799         return true;
2800     }
2801 
2802     /**
2803      * Returns <tt>true</tt> if the two specified arrays of Objects are
2804      * <i>equal</i> to one another.  The two arrays are considered equal if
2805      * both arrays contain the same number of elements, and all corresponding
2806      * pairs of elements in the two arrays are equal.  Two objects <tt>e1</tt>
2807      * and <tt>e2</tt> are considered <i>equal</i> if <tt>(e1==null ? e2==null
2808      * : e1.equals(e2))</tt>.  In other words, the two arrays are equal if
2809      * they contain the same elements in the same order.  Also, two array
2810      * references are considered equal if both are <tt>null</tt>.<p>
2811      *
2812      * @param a one array to be tested for equality
2813      * @param a2 the other array to be tested for equality
2814      * @return <tt>true</tt> if the two arrays are equal
2815      */
2816     public static boolean equals(Object[] a, Object[] a2) {
2817         if (a==a2)
2818             return true;
2819         if (a==null || a2==null)
2820             return false;
2821 
2822         int length = a.length;
2823         if (a2.length != length)
2824             return false;
2825 
2826         for (int i=0; i<length; i++) {
2827             Object o1 = a[i];
2828             Object o2 = a2[i];
2829             if (!(o1==null ? o2==null : o1.equals(o2)))
2830                 return false;

2544             T midVal = a[mid];
2545             int cmp = c.compare(midVal, key);
2546             if (cmp < 0)
2547                 low = mid + 1;
2548             else if (cmp > 0)
2549                 high = mid - 1;
2550             else
2551                 return mid; // key found
2552         }
2553         return -(low + 1);  // key not found.
2554     }
2555 
2556     // Equality Testing
2557 
2558     /**
2559      * Returns <tt>true</tt> if the two specified arrays of longs are
2560      * <i>equal</i> to one another.  Two arrays are considered equal if both
2561      * arrays contain the same number of elements, and all corresponding pairs
2562      * of elements in the two arrays are equal.  In other words, two arrays
2563      * are equal if they contain the same elements in the same order.  Also,
2564      * two array references are considered equal if both are <tt>null</tt>.
2565      *
2566      * @param a one array to be tested for equality
2567      * @param a2 the other array to be tested for equality
2568      * @return <tt>true</tt> if the two arrays are equal
2569      */
2570     public static boolean equals(long[] a, long[] a2) {
2571         if (a==a2)
2572             return true;
2573         if (a==null || a2==null)
2574             return false;
2575 
2576         int length = a.length;
2577         if (a2.length != length)
2578             return false;
2579 
2580         for (int i=0; i<length; i++)
2581             if (a[i] != a2[i])
2582                 return false;
2583 
2584         return true;
2585     }
2586 
2587     /**
2588      * Returns <tt>true</tt> if the two specified arrays of ints are
2589      * <i>equal</i> to one another.  Two arrays are considered equal if both
2590      * arrays contain the same number of elements, and all corresponding pairs
2591      * of elements in the two arrays are equal.  In other words, two arrays
2592      * are equal if they contain the same elements in the same order.  Also,
2593      * two array references are considered equal if both are <tt>null</tt>.
2594      *
2595      * @param a one array to be tested for equality
2596      * @param a2 the other array to be tested for equality
2597      * @return <tt>true</tt> if the two arrays are equal
2598      */
2599     public static boolean equals(int[] a, int[] a2) {
2600         if (a==a2)
2601             return true;
2602         if (a==null || a2==null)
2603             return false;
2604 
2605         int length = a.length;
2606         if (a2.length != length)
2607             return false;
2608 
2609         for (int i=0; i<length; i++)
2610             if (a[i] != a2[i])
2611                 return false;
2612 
2613         return true;
2614     }
2615 
2616     /**
2617      * Returns <tt>true</tt> if the two specified arrays of shorts are
2618      * <i>equal</i> to one another.  Two arrays are considered equal if both
2619      * arrays contain the same number of elements, and all corresponding pairs
2620      * of elements in the two arrays are equal.  In other words, two arrays
2621      * are equal if they contain the same elements in the same order.  Also,
2622      * two array references are considered equal if both are <tt>null</tt>.
2623      *
2624      * @param a one array to be tested for equality
2625      * @param a2 the other array to be tested for equality
2626      * @return <tt>true</tt> if the two arrays are equal
2627      */
2628     public static boolean equals(short[] a, short a2[]) {
2629         if (a==a2)
2630             return true;
2631         if (a==null || a2==null)
2632             return false;
2633 
2634         int length = a.length;
2635         if (a2.length != length)
2636             return false;
2637 
2638         for (int i=0; i<length; i++)
2639             if (a[i] != a2[i])
2640                 return false;
2641 
2642         return true;
2643     }
2644 
2645     /**
2646      * Returns <tt>true</tt> if the two specified arrays of chars are
2647      * <i>equal</i> to one another.  Two arrays are considered equal if both
2648      * arrays contain the same number of elements, and all corresponding pairs
2649      * of elements in the two arrays are equal.  In other words, two arrays
2650      * are equal if they contain the same elements in the same order.  Also,
2651      * two array references are considered equal if both are <tt>null</tt>.
2652      *
2653      * @param a one array to be tested for equality
2654      * @param a2 the other array to be tested for equality
2655      * @return <tt>true</tt> if the two arrays are equal
2656      */
2657     public static boolean equals(char[] a, char[] a2) {
2658         if (a==a2)
2659             return true;
2660         if (a==null || a2==null)
2661             return false;
2662 
2663         int length = a.length;
2664         if (a2.length != length)
2665             return false;
2666 
2667         for (int i=0; i<length; i++)
2668             if (a[i] != a2[i])
2669                 return false;
2670 
2671         return true;
2672     }
2673 
2674     /**
2675      * Returns <tt>true</tt> if the two specified arrays of bytes are
2676      * <i>equal</i> to one another.  Two arrays are considered equal if both
2677      * arrays contain the same number of elements, and all corresponding pairs
2678      * of elements in the two arrays are equal.  In other words, two arrays
2679      * are equal if they contain the same elements in the same order.  Also,
2680      * two array references are considered equal if both are <tt>null</tt>.
2681      *
2682      * @param a one array to be tested for equality
2683      * @param a2 the other array to be tested for equality
2684      * @return <tt>true</tt> if the two arrays are equal
2685      */
2686     public static boolean equals(byte[] a, byte[] a2) {
2687         if (a==a2)
2688             return true;
2689         if (a==null || a2==null)
2690             return false;
2691 
2692         int length = a.length;
2693         if (a2.length != length)
2694             return false;
2695 
2696         for (int i=0; i<length; i++)
2697             if (a[i] != a2[i])
2698                 return false;
2699 
2700         return true;
2701     }
2702 
2703     /**
2704      * Returns <tt>true</tt> if the two specified arrays of booleans are
2705      * <i>equal</i> to one another.  Two arrays are considered equal if both
2706      * arrays contain the same number of elements, and all corresponding pairs
2707      * of elements in the two arrays are equal.  In other words, two arrays
2708      * are equal if they contain the same elements in the same order.  Also,
2709      * two array references are considered equal if both are <tt>null</tt>.
2710      *
2711      * @param a one array to be tested for equality
2712      * @param a2 the other array to be tested for equality
2713      * @return <tt>true</tt> if the two arrays are equal
2714      */
2715     public static boolean equals(boolean[] a, boolean[] a2) {
2716         if (a==a2)
2717             return true;
2718         if (a==null || a2==null)
2719             return false;
2720 
2721         int length = a.length;
2722         if (a2.length != length)
2723             return false;
2724 
2725         for (int i=0; i<length; i++)
2726             if (a[i] != a2[i])
2727                 return false;
2728 
2729         return true;
2730     }
2731 
2732     /**
2733      * Returns <tt>true</tt> if the two specified arrays of doubles are
2734      * <i>equal</i> to one another.  Two arrays are considered equal if both
2735      * arrays contain the same number of elements, and all corresponding pairs
2736      * of elements in the two arrays are equal.  In other words, two arrays
2737      * are equal if they contain the same elements in the same order.  Also,
2738      * two array references are considered equal if both are <tt>null</tt>.
2739      *
2740      * Two doubles <tt>d1</tt> and <tt>d2</tt> are considered equal if:
2741      * <pre>    <tt>new Double(d1).equals(new Double(d2))</tt></pre>
2742      * (Unlike the <tt>==</tt> operator, this method considers
2743      * <tt>NaN</tt> equals to itself, and 0.0d unequal to -0.0d.)
2744      *
2745      * @param a one array to be tested for equality
2746      * @param a2 the other array to be tested for equality
2747      * @return <tt>true</tt> if the two arrays are equal
2748      * @see Double#equals(Object)
2749      */
2750     public static boolean equals(double[] a, double[] a2) {
2751         if (a==a2)
2752             return true;
2753         if (a==null || a2==null)
2754             return false;
2755 
2756         int length = a.length;
2757         if (a2.length != length)
2758             return false;
2759 
2760         for (int i=0; i<length; i++)
2761             if (Double.doubleToLongBits(a[i])!=Double.doubleToLongBits(a2[i]))
2762                 return false;
2763 
2764         return true;
2765     }
2766 
2767     /**
2768      * Returns <tt>true</tt> if the two specified arrays of floats are
2769      * <i>equal</i> to one another.  Two arrays are considered equal if both
2770      * arrays contain the same number of elements, and all corresponding pairs
2771      * of elements in the two arrays are equal.  In other words, two arrays
2772      * are equal if they contain the same elements in the same order.  Also,
2773      * two array references are considered equal if both are <tt>null</tt>.
2774      *
2775      * Two floats <tt>f1</tt> and <tt>f2</tt> are considered equal if:
2776      * <pre>    <tt>new Float(f1).equals(new Float(f2))</tt></pre>
2777      * (Unlike the <tt>==</tt> operator, this method considers
2778      * <tt>NaN</tt> equals to itself, and 0.0f unequal to -0.0f.)
2779      *
2780      * @param a one array to be tested for equality
2781      * @param a2 the other array to be tested for equality
2782      * @return <tt>true</tt> if the two arrays are equal
2783      * @see Float#equals(Object)
2784      */
2785     public static boolean equals(float[] a, float[] a2) {
2786         if (a==a2)
2787             return true;
2788         if (a==null || a2==null)
2789             return false;
2790 
2791         int length = a.length;
2792         if (a2.length != length)
2793             return false;
2794 
2795         for (int i=0; i<length; i++)
2796             if (Float.floatToIntBits(a[i])!=Float.floatToIntBits(a2[i]))
2797                 return false;
2798 
2799         return true;
2800     }
2801 
2802     /**
2803      * Returns <tt>true</tt> if the two specified arrays of Objects are
2804      * <i>equal</i> to one another.  The two arrays are considered equal if
2805      * both arrays contain the same number of elements, and all corresponding
2806      * pairs of elements in the two arrays are equal.  Two objects <tt>e1</tt>
2807      * and <tt>e2</tt> are considered <i>equal</i> if <tt>(e1==null ? e2==null
2808      * : e1.equals(e2))</tt>.  In other words, the two arrays are equal if
2809      * they contain the same elements in the same order.  Also, two array
2810      * references are considered equal if both are <tt>null</tt>.
2811      *
2812      * @param a one array to be tested for equality
2813      * @param a2 the other array to be tested for equality
2814      * @return <tt>true</tt> if the two arrays are equal
2815      */
2816     public static boolean equals(Object[] a, Object[] a2) {
2817         if (a==a2)
2818             return true;
2819         if (a==null || a2==null)
2820             return false;
2821 
2822         int length = a.length;
2823         if (a2.length != length)
2824             return false;
2825 
2826         for (int i=0; i<length; i++) {
2827             Object o1 = a[i];
2828             Object o2 = a2[i];
2829             if (!(o1==null ? o2==null : o1.equals(o2)))
2830                 return false;