Find Usages Diff Raw Download HTML Widget Stack Overflow Q&A
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
1. Examples of GoF Design Patterns
I am learning GoF Java Design Patterns and I want to see some real life examples of them. Can you guys point to some good usage of these Design Patterns.(preferably in Java's core libraries). Thank you
2. How do I display the binary representation of a float or double?
I'd like to display the binary (or hexadecimal) representation of a floating point number. I know how to convert by hand (using the method here), but I'm interested in seeing code samples that do the same. Although I'm particularly interested in the C++ and Java solutions, I wonder if any languages make it particularly easy so I'm making this language agnostic. I'd love to see some solutions...
3. Why does int num = Integer.getInteger("123") throw NullPointerException?
the following code throws NPE for me: int num = Integer.getInteger("123"); is my compiler invoking getInteger on null since it's static? that doesn't make any sense! can someone explain what's happening? thanks.
4. Parsing integer strings in Java
Possible Duplicate: How to convert a hexadecimal string to long in java? I know that Java can't handle this: Integer.parseInt("0x64") Instead you have to do this: Integer.parseInt("64", 16) Is there something built into Java that can automatically parse integer strings for me using the standard prefixes for hex, octal, and lack of prefix for decimal (so that I don't have to str...
5. Project Euler, Problem 10 java solution not working
I'm trying to find the sum of the prime numbers < 2,000,000. This is my solution in java but I can't seem get the correct answer. Please give some input on what could be wrong and general advice on the code is appreciated. Printing 'sum' gives: 1308111344, which is incorrect. edit: Thanks for all the help. Changed int to long and < to <= and it worked flawlessly, except for being an...
6. Why is Java "String" type written in capital letter while "int" is not?
I am curious. Why do I have to type String myStr with a capital letter whereas I type int aNumba with a lower-case letter?
7. Can an integer always be parsed as a long?
I have a list of strings in Java which are being written to a text file. These strings are each tagged with a type -- in this case, I'll I'm interested are strings containing longs and ints. I'd like to convert these strings back to a numeric type before writing them, but I'd like to minimize code duplication. I plan on parsing every string tagged as an integer or long integer using Long.parseL...
8. Java: Long result = -1: cannot convert from int to long
I'm using eclipse java ee to perform java programming. I had the following line of code in one of my functions: Long result = -1; I got the following error: Type mismatch: cannot convert from int to Long I can't quite understand why when i add a number to the variable it provides this error. How can this issue be resolved and why did it happen in the first place?
9. Java Mappings and Primitives
I want to create a mapping that takes a string as the key and a primitive as the value. I was looking at the Java docs and did not see that Primitive was a class type or that they shared some kind of wrapping supper class. How can I constrain the value to be a primitive? Map< String, Primitive> map = new HashMap< String, Primitive >()
10. Java Integer.parseInt failed to parse a string
I'm parsing a string of 15 digits like this: String str = "100004159312045"; int i = Integer.parseInt(str); I'm getting an exception when doing so. Why? What are the limitations for Integer.parseInt? What other options do I have for converting such long string to a number?
11. What string should I pass to java.lang.Long.parseLong() to return a NaN?
I unfortunately cant use expressions like Long.Nan as the string is actually a return value from a different C module. Is there a string I can pass to parseLong() to return an NaN ?
12. Is there any justifiable reason to use new and a constructor on a number class in Java?
Is there any justifiable reason to in Java something like Long l = new Long(SOME_CONSTANT) This creates an extra object and is tagged by FindBugs, and is obviously a bad practice. My question is whether there is ever a good reason to do so? I previously asked this about String constructors and got a good answer, but that answer doesn't seem to apply to numbers.
13. .NET equivalent of Java's Integer.bitCount?
Is there a method similar to Java's Integer.bitCount(int) or Long.bitCount(long) anywhere in the .NET Framework? (For those unfamiliar with these Java methods) this is also known as: Hamming Weight Population Count (often called POPCNT when implemented in hardware.) Although there are plenty of implementations to be found on the web, I was wondering if there was a standard library implemen...
14. Is there any difference between these two statements?
float ff = 1.2f; Float fo = new Float(1.2f); double fg = 3.2d; Double fh = new Double(2.1d); Can I use '=' between the (1) and (3) or between the (2) and (4)??
15. Convert Long into Integer
How to convert Long value into Integer value in Java?
16. What is the maximum file size 32 bit java can access?
What is the maximum file size 32 bit java can access? Is this architecture dependent?
17. Why does trying to parse this value result in a NumberFormatException?
Code: String myVar = "1255763710960"; int myTempVar=0; try { myTempVar = Integer.valueOf(myVar); } catch (NumberFormatException nfe) { System.out.println(nfe.toString()); } Output: java.lang.NumberFormatException: For input string: "1255763710960" I have absolutely no idea why this is.
18. Wrapped Longs to this list
queryParms.add(new Long(empRec)); I am using JDK 1.5 and using wrapped longs to a list. My Boss was yelling at me seeing this. Is it a good approach? Does it impact in terms of performance. What should be alternative?
19. How to set log4j with unlimited max file size?
I didn't get a definitive answer to this question by Google'ing, so I pose it to the groupthink masterminds and to ensure that a quality answer can be Google-able in the future. Using log4j RollingFileAppender, I can set the maximum size I want the file to reach before rolling over on itself, like so: RollingFileAppender rfa = new RollingFileAppender(); rfa.setMaximumFileSize(500000000); // S...
20. In Java, do primitive types and arrays have a containing package?
In Java, do primitive types and arrays have a containing package? Probably not, but just want to be certain.
21. Converting String to long in Java
I got a simple question in Java: How can I convert a String that was obtained by Long.toString() to long ? 
1
   /*
2
    * Copyright 1994-2006 Sun Microsystems, Inc.  All Rights Reserved.
3
    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
    *
5
    * This code is free software; you can redistribute it and/or modify it
6
    * under the terms of the GNU General Public License version 2 only, as
7
    * published by the Free Software Foundation.  Sun designates this
8
    * particular file as subject to the "Classpath" exception as provided
9
    * by Sun in the LICENSE file that accompanied this code.
10
   *
11
   * This code is distributed in the hope that it will be useful, but WITHOUT
12
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
   * version 2 for more details (a copy is included in the LICENSE file that
15
   * accompanied this code).
16
   *
17
   * You should have received a copy of the GNU General Public License version
18
   * 2 along with this work; if not, write to the Free Software Foundation,
19
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
   *
21
   * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
   * CA 95054 USA or visit www.sun.com if you need additional information or
23
   * have any questions.
24
   */
25
  
26
  package java.lang;

The Long class wraps a value of the primitive type long in an object. An object of type Long contains a single field whose type is long.

In addition, this class provides several methods for converting a long to a String and a String to a long, as well as other constants and methods useful when dealing with a long.

Implementation note: The implementations of the "bit twiddling" methods (such as highestOneBit and numberOfTrailingZeros) are based on material from Henry S. Warren, Jr.'s Hacker's Delight, (Addison Wesley, 2002).

Author(s):
Lee Boynton
Arthur van Hoff
Josh Bloch
Joseph D. Darcy
Since:
JDK1.0
49
  
50
  public final class Long extends Number implements Comparable<Long> {
    
A constant holding the minimum value a long can have, -263. 
54
  
55
      public static final long MIN_VALUE = 0x8000000000000000L;

    
A constant holding the maximum value a long can have, 263-1. 
60
  
61
      public static final long MAX_VALUE = 0x7fffffffffffffffL;

    
The Class instance representing the primitive type long.

Since:
JDK1.1
68
  
69
      public static final Class<Long>     TYPE = (Class<Long>) Class.getPrimitiveClass("long");

    
Returns a string representation of the first argument in the radix specified by the second argument.

If the radix is smaller than Character.MIN_RADIX or larger than Character.MAX_RADIX, then the radix 10 is used instead.

If the first argument is negative, the first element of the result is the ASCII minus sign '-' ('\u002d'). If the first argument is not negative, no sign character appears in the result.

The remaining characters of the result represent the magnitude of the first argument. If the magnitude is zero, it is represented by a single zero character '0' ('\u0030'); otherwise, the first character of the representation of the magnitude will not be the zero character. The following ASCII characters are used as digits:

0123456789abcdefghijklmnopqrstuvwxyz
These are '\u0030' through '\u0039' and '\u0061' through '\u007a'. If radix is N, then the first N of these characters are used as radix-N digits in the order shown. Thus, the digits for hexadecimal (radix 16) are 0123456789abcdef. If uppercase letters are desired, the String.toUpperCase() method may be called on the result:
Long.toString(n, 16).toUpperCase()

Parameters:
i a long to be converted to a string.
radix the radix to use in the string representation.
Returns:
a string representation of the argument in the specified radix.
See also:
Character.MAX_RADIX
Character.MIN_RADIX
114
 
115
     public static String toString(long i, int radix) {
116
         if (radix < . || radix > .)
117
             radix = 10;
118
         if (radix == 10)
119
             return toString(i);
120
         char[] buf = new char[65];
121
         int charPos = 64;
122
         boolean negative = (i < 0);
123
 
124
         if (!negative) {
125
             i = -i;
126
         }
127
 
128
         while (i <= -radix) {
129
             buf[charPos--] = .[(int)(-(i % radix))];
130
             i = i / radix;
131
         }
132
         buf[charPos] = .[(int)(-i)];
133
 
134
         if (negative) {
135
             buf[--charPos] = '-';
136
         }
137
 
138
         return new String(buf, charPos, (65 - charPos));
139
     }

    
Returns a string representation of the long argument as an unsigned integer in base 16.

The unsigned long value is the argument plus 264 if the argument is negative; otherwise, it is equal to the argument. This value is converted to a string of ASCII digits in hexadecimal (base 16) with no extra leading 0s. If the unsigned magnitude is zero, it is represented by a single zero character '0' ('\u0030'); otherwise, the first character of the representation of the unsigned magnitude will not be the zero character. The following characters are used as hexadecimal digits:

0123456789abcdef
These are the characters '\u0030' through '\u0039' and '\u0061' through '\u0066'. If uppercase letters are desired, the String.toUpperCase() method may be called on the result:
Long.toHexString(n).toUpperCase()

Parameters:
i a long to be converted to a string.
Returns:
the string representation of the unsigned long value represented by the argument in hexadecimal (base 16).
Since:
JDK 1.0.2
175
 
176
     public static String toHexString(long i) {
177
         return toUnsignedString(i, 4);
178
     }

    
Returns a string representation of the long argument as an unsigned integer in base 8.

The unsigned long value is the argument plus 264 if the argument is negative; otherwise, it is equal to the argument. This value is converted to a string of ASCII digits in octal (base 8) with no extra leading 0s.

If the unsigned magnitude is zero, it is represented by a single zero character '0' ('\u0030'); otherwise, the first character of the representation of the unsigned magnitude will not be the zero character. The following characters are used as octal digits:

01234567
These are the characters '\u0030' through '\u0037'.

Parameters:
i a long to be converted to a string.
Returns:
the string representation of the unsigned long value represented by the argument in octal (base 8).
Since:
JDK 1.0.2
208
 
209
     public static String toOctalString(long i) {
210
         return toUnsignedString(i, 3);
211
     }

    
Returns a string representation of the long argument as an unsigned integer in base 2.

The unsigned long value is the argument plus 264 if the argument is negative; otherwise, it is equal to the argument. This value is converted to a string of ASCII digits in binary (base 2) with no extra leading 0s. If the unsigned magnitude is zero, it is represented by a single zero character '0' ('\u0030'); otherwise, the first character of the representation of the unsigned magnitude will not be the zero character. The characters '0' ('\u0030') and '1' ('\u0031') are used as binary digits.

Parameters:
i a long to be converted to a string.
Returns:
the string representation of the unsigned long value represented by the argument in binary (base 2).
Since:
JDK 1.0.2
233
 
234
     public static String toBinaryString(long i) {
235
         return toUnsignedString(i, 1);
236
     }

    
Convert the integer to an unsigned number. 
240
 
241
     private static String toUnsignedString(long i, int shift) {
242
         char[] buf = new char[64];
243
         int charPos = 64;
244
         int radix = 1 << shift;
245
         long mask = radix - 1;
246
         do {
247
             buf[--charPos] = .[(int)(i & mask)];
248
             i >>>= shift;
249
         } while (i != 0);
250
         return new String(buf, charPos, (64 - charPos));
251
     }

    
Returns a String object representing the specified long. The argument is converted to signed decimal representation and returned as a string, exactly as if the argument and the radix 10 were given as arguments to the toString(long,int) method.

Parameters:
i a long to be converted.
Returns:
a string representation of the argument in base 10.
262
 
263
     public static String toString(long i) {
264
         if (i == .)
265
             return "-9223372036854775808";
266
         int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
267
         char[] buf = new char[size];
268
         getChars(i, size, buf);
269
         return new String(0, size, buf);
270
     }

    
Places characters representing the integer i into the character array buf. The characters are placed into the buffer backwards starting with the least significant digit at the specified index (exclusive), and working backwards from there. Will fail if i == Long.MIN_VALUE 
280
 
281
     static void getChars(long i, int index, char[] buf) {
282
         long q;
283
         int r;
284
         int charPos = index;
285
         char sign = 0;
286
 
287
         if (i < 0) {
288
             sign = '-';
289
             i = -i;
290
         }
291
 
292
         // Get 2 digits/iteration using longs until quotient fits into an int
293
         while (i > .) {
294
             q = i / 100;
295
             // really: r = i - (q * 100);
296
             r = (int)(i - ((q << 6) + (q << 5) + (q << 2)));
297
             i = q;
298
             buf[--charPos] = .[r];
299
             buf[--charPos] = .[r];
300
         }
301
 
302
         // Get 2 digits/iteration using ints
303
         int q2;
304
         int i2 = (int)i;
305
         while (i2 >= 65536) {
306
             q2 = i2 / 100;
307
             // really: r = i2 - (q * 100);
308
             r = i2 - ((q2 << 6) + (q2 << 5) + (q2 << 2));
309
             i2 = q2;
310
             buf[--charPos] = .[r];
311
             buf[--charPos] = .[r];
312
         }
313
 
314
         // Fall thru to fast mode for smaller numbers
315
         // assert(i2 <= 65536, i2);
316
         for (;;) {
317
             q2 = (i2 * 52429) >>> (16+3);
318
             r = i2 - ((q2 << 3) + (q2 << 1));  // r = i2-(q2*10) ...
319
             buf[--charPos] = .[r];
320
             i2 = q2;
321
             if (i2 == 0) break;
322
         }
323
         if (sign != 0) {
324
             buf[--charPos] = sign;
325
         }
326
     }
327
 
328
     // Requires positive x
329
     static int stringSize(long x) {
330
         long p = 10;
331
         for (int i=1; i<19; i++) {
332
             if (x < p)
333
                 return i;
334
             p = 10*p;
335
         }
336
         return 19;
337
     }

    
Parses the string argument as a signed long in the radix specified by the second argument. The characters in the string must all be digits of the specified radix (as determined by whether Character.digit(char,int) returns a nonnegative value), except that the first character may be an ASCII minus sign '-' ('\u002D') to indicate a negative value. The resulting long value is returned.

Note that neither the character L ('\u004C') nor l ('\u006C') is permitted to appear at the end of the string as a type indicator, as would be permitted in Java programming language source code - except that either L or l may appear as a digit for a radix greater than 22.

An exception of type NumberFormatException is thrown if any of the following situations occurs:

  • The first argument is null or is a string of length zero.
  • The radix is either smaller than Character.MIN_RADIX or larger than Character.MAX_RADIX.
  • Any character of the string is not a digit of the specified radix, except that the first character may be a minus sign '-' ('\u002d') provided that the string is longer than length 1.
  • The value represented by the string is not a value of type long.

Examples: 

 parseLong("0", 10) returns 0L
 parseLong("473", 10) returns 473L
 parseLong("-0", 10) returns 0L
 parseLong("-FF", 16) returns -255L
 parseLong("1100110", 2) returns 102L
 parseLong("99", 8) throws a NumberFormatException
 parseLong("Hazelnut", 10) throws a NumberFormatException
 parseLong("Hazelnut", 36) returns 1356099454469L

Parameters:
s the String containing the long representation to be parsed.
radix the radix to be used while parsing s.
Returns:
the long represented by the string argument in the specified radix.
Throws:
NumberFormatException if the string does not contain a parsable long.
396
 
397
     public static long parseLong(String s, int radix)
398
               throws NumberFormatException
399
     {
400
         if (s == null) {
401
             throw new NumberFormatException("null");
402
         }
403
 
404
         if (radix < .) {
405
             throw new NumberFormatException("radix " + radix +
406
                                             " less than Character.MIN_RADIX");
407
         }
408
         if (radix > .) {
409
             throw new NumberFormatException("radix " + radix +
410
                                             " greater than Character.MAX_RADIX");
411
         }
412
 
413
         long result = 0;
414
         boolean negative = false;
415
         int i = 0, len = s.length();
416
         long limit = -.;
417
         long multmin;
418
         int digit;
419
 
420
         if (len > 0) {
421
             char firstChar = s.charAt(0);
422
             if (firstChar < '0') { // Possible leading "-"
423
                 if (firstChar == '-') {
424
                     negative = true;
425
                     limit = .;
426
                 } else
427
                     throw NumberFormatException.forInputString(s);
428
 
429
                 if (len == 1) // Cannot have lone "-"
430
                     throw NumberFormatException.forInputString(s);
431
                 i++;
432
             }
433
             multmin = limit / radix;
434
             while (i < len) {
435
                 // Accumulating negatively avoids surprises near MAX_VALUE
436
                 digit = Character.digit(s.charAt(i++),radix);
437
                 if (digit < 0) {
438
                     throw NumberFormatException.forInputString(s);
439
                 }
440
                 if (result < multmin) {
441
                     throw NumberFormatException.forInputString(s);
442
                 }
443
                 result *= radix;
444
                 if (result < limit + digit) {
445
                     throw NumberFormatException.forInputString(s);
446
                 }
447
                 result -= digit;
448
             }
449
         } else {
450
             throw NumberFormatException.forInputString(s);
451
         }
452
         return negative ? result : -result;
453
     }

    
Parses the string argument as a signed decimal long. The characters in the string must all be decimal digits, except that the first character may be an ASCII minus sign '-' (\u002D') to indicate a negative value. The resulting long value is returned, exactly as if the argument and the radix 10 were given as arguments to the parseLong(java.lang.String,int) method.

Note that neither the character L ('\u004C') nor l ('\u006C') is permitted to appear at the end of the string as a type indicator, as would be permitted in Java programming language source code.

Parameters:
s a String containing the long representation to be parsed
Returns:
the long represented by the argument in decimal.
Throws:
NumberFormatException if the string does not contain a parsable long.
476
 
477
     public static long parseLong(String s) throws NumberFormatException {
478
         return parseLong(s, 10);
479
     }

    
Returns a Long object holding the value extracted from the specified String when parsed with the radix given by the second argument. The first argument is interpreted as representing a signed long in the radix specified by the second argument, exactly as if the arguments were given to the parseLong(java.lang.String,int) method. The result is a Long object that represents the long value specified by the string.

In other words, this method returns a Long object equal to the value of:

new Long(Long.parseLong(s, radix))

Parameters:
s the string to be parsed
radix the radix to be used in interpreting s
Returns:
a Long object holding the value represented by the string argument in the specified radix.
Throws:
NumberFormatException If the String does not contain a parsable long.
506
 
507
     public static Long valueOf(String s, int radix) throws NumberFormatException {
508
         return new Long(parseLong(s, radix));
509
     }

    
Returns a Long object holding the value of the specified String. The argument is interpreted as representing a signed decimal long, exactly as if the argument were given to the parseLong(java.lang.String) method. The result is a Long object that represents the integer value specified by the string.

In other words, this method returns a Long object equal to the value of:

new Long(Long.parseLong(s))

Parameters:
s the string to be parsed.
Returns:
a Long object holding the value represented by the string argument.
Throws:
NumberFormatException If the string cannot be parsed as a long.
532
 
533
     public static Long valueOf(String s) throws NumberFormatException
534
     {
535
         return new Long(parseLong(s, 10));
536
     }
537
 
538
     private static class LongCache {
539
         private LongCache(){}
540
 
541
         static final Long cache[] = new Long[-(-128) + 127 + 1];
542
 
543
         static {
544
             for(int i = 0; i < .; i++)
545
                 [i] = new Long(i - 128);
546
         }
547
     }

    
Returns a Long instance representing the specified long value. If a new Long instance is not required, this method should generally be used in preference to the constructor Long(long), as this method is likely to yield significantly better space and time performance by caching frequently requested values.

Parameters:
l a long value.
Returns:
a Long instance representing l.
Since:
1.5
561
 
562
     public static Long valueOf(long l) {
563
         final int offset = 128;
564
         if (l >= -128 && l <= 127) { // will cache
565
             return .[(int)l + offset];
566
         }
567
         return new Long(l);
568
     }

    
Decodes a String into a Long. Accepts decimal, hexadecimal, and octal numbers given by the following grammar:
DecodableString:
Signopt DecimalNumeral
Signopt 0x HexDigits
Signopt 0X HexDigits
Signopt # HexDigits
Signopt 0 OctalDigits

Sign:
-

DecimalNumeral, HexDigits, and OctalDigits are defined in §3.10.1 of the Java Language Specification.

The sequence of characters following an (optional) negative sign and/or radix specifier ("0x", "0X", "#", or leading zero) is parsed as by the Long.parseLong method with the indicated radix (10, 16, or 8). This sequence of characters must represent a positive value or a NumberFormatException will be thrown. The result is negated if first character of the specified String is the minus sign. No whitespace characters are permitted in the String.

Parameters:
nm the String to decode.
Returns:
a Long object holding the long value represented by nm
Throws:
NumberFormatException if the String does not contain a parsable long.
Since:
1.2
See also:
parseLong(java.lang.String,int)
611
 
612
     public static Long decode(String nm) throws NumberFormatException {
613
         int radix = 10;
614
         int index = 0;
615
         boolean negative = false;
616
         Long result;
617
 
618
         if (nm.length() == 0)
619
             throw new NumberFormatException("Zero length string");
620
         char firstChar = nm.charAt(0);
621
         // Handle sign, if present
622
         if (firstChar == '-') {
623
             negative = true;
624
             index++;
625
         }
626
 
627
         // Handle radix specifier, if present
628
         if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {
629
             index += 2;
630
             radix = 16;
631
         }
632
         else if (nm.startsWith("#", index)) {
633
             index ++;
634
             radix = 16;
635
         }
636
         else if (nm.startsWith("0", index) && nm.length() > 1 + index) {
637
             index ++;
638
             radix = 8;
639
         }
640
 
641
         if (nm.startsWith("-", index))
642
             throw new NumberFormatException("Sign character in wrong position");
643
 
644
         try {
645
             result = Long.valueOf(nm.substring(index), radix);
646
             result = negative ? new Long((long)-result.longValue()) : result;
647
         } catch (NumberFormatException e) {
648
             // If number is Long.MIN_VALUE, we'll end up here. The next line
649
             // handles this case, and causes any genuine format error to be
650
             // rethrown.
651
             String constant = negative ? ("-" + nm.substring(index))
652
                                        : nm.substring(index);
653
             result = Long.valueOf(constant, radix);
654
         }
655
         return result;
656
     }

    
The value of the Long.

Serial:
662
 
663
     private final long value;

    
Constructs a newly allocated Long object that represents the specified long argument.

Parameters:
value the value to be represented by the Long object.
671
 
672
     public Long(long value) {
673
         this. = value;
674
     }

    
Constructs a newly allocated Long object that represents the long value indicated by the String parameter. The string is converted to a long value in exactly the manner used by the parseLong method for radix 10.

Parameters:
s the String to be converted to a Long.
Throws:
NumberFormatException if the String does not contain a parsable long.
See also:
parseLong(java.lang.String,int)
688
 
689
     public Long(String s) throws NumberFormatException {
690
         this. = parseLong(s, 10);
691
     }

    
Returns the value of this Long as a byte. 
696
 
697
     public byte byteValue() {
698
         return (byte);
699
     }

    
Returns the value of this Long as a short. 
704
 
705
     public short shortValue() {
706
         return (short);
707
     }

    
Returns the value of this Long as an int. 
712
 
713
     public int intValue() {
714
         return (int);
715
     }

    
Returns the value of this Long as a long value. 
720
 
721
     public long longValue() {
722
         return (long);
723
     }

    
Returns the value of this Long as a float. 
728
 
729
     public float floatValue() {
730
         return (float);
731
     }

    
Returns the value of this Long as a double. 
736
 
737
     public double doubleValue() {
738
         return (double);
739
     }

    
Returns a String object representing this Long's value. The value is converted to signed decimal representation and returned as a string, exactly as if the long value were given as an argument to the toString(long) method.

Returns:
a string representation of the value of this object in base 10.
750
 
751
     public String toString() {
752
         return String.valueOf();
753
     }

    
Returns a hash code for this Long. The result is the exclusive OR of the two halves of the primitive long value held by this Long object. That is, the hashcode is the value of the expression:
(int)(this.longValue()^(this.longValue()>>>32))

Returns:
a hash code value for this object.
766
 
767
     public int hashCode() {
768
         return (int)( ^ ( >>> 32));
769
     }

    
Compares this object to the specified object. The result is true if and only if the argument is not null and is a Long object that contains the same long value as this object.

Parameters:
obj the object to compare with.
Returns:
true if the objects are the same; false otherwise.
780
 
781
     public boolean equals(Object obj) {
782
         if (obj instanceof Long) {
783
             return  == ((Long)obj).longValue();
784
         }
785
         return false;
786
     }

    
Determines the long value of the system property with the specified name.

The first argument is treated as the name of a system property. System properties are accessible through the System.getProperty(java.lang.String) method. The string value of this property is then interpreted as a long value and a Long object representing this value is returned. Details of possible numeric formats can be found with the definition of getProperty.

If there is no property with the specified name, if the specified name is empty or null, or if the property does not have the correct numeric format, then null is returned.

In other words, this method returns a Long object equal to the value of:

getLong(nm, null)

Parameters:
nm property name.
Returns:
the Long value of the property.
See also:
System.getProperty(java.lang.String)
System.getProperty(java.lang.String,java.lang.String)
817
 
818
     public static Long getLong(String nm) {
819
         return getLong(nm, null);
820
     }

    
Determines the long value of the system property with the specified name.

The first argument is treated as the name of a system property. System properties are accessible through the System.getProperty(java.lang.String) method. The string value of this property is then interpreted as a long value and a Long object representing this value is returned. Details of possible numeric formats can be found with the definition of getProperty.

The second argument is the default value. A Long object that represents the value of the second argument is returned if there is no property of the specified name, if the property does not have the correct numeric format, or if the specified name is empty or null.

In other words, this method returns a Long object equal to the value of:

getLong(nm, new Long(val))
but in practice it may be implemented in a manner such as: 
 Long result = getLong(nm, null);
 return (result == null) ? new Long(val) : result;
to avoid the unnecessary allocation of a Long object when the default value is not needed.

Parameters:
nm property name.
val default value.
Returns:
the Long value of the property.
See also:
System.getProperty(java.lang.String)
System.getProperty(java.lang.String,java.lang.String)
862
 
863
     public static Long getLong(String nm, long val) {
864
         Long result = Long.getLong(nm, null);
865
         return (result == null) ? new Long(val) : result;
866
     }

    
Returns the long value of the system property with the specified name. The first argument is treated as the name of a system property. System properties are accessible through the System.getProperty(java.lang.String) method. The string value of this property is then interpreted as a long value, as per the Long.decode method, and a Long object representing this value is returned.
  • If the property value begins with the two ASCII characters 0x or the ASCII character #, not followed by a minus sign, then the rest of it is parsed as a hexadecimal integer exactly as for the method valueOf(java.lang.String,int) with radix 16.
  • If the property value begins with the ASCII character 0 followed by another character, it is parsed as an octal integer exactly as by the method valueOf(java.lang.String,int) with radix 8.
  • Otherwise the property value is parsed as a decimal integer exactly as by the method valueOf(java.lang.String,int) with radix 10.

Note that, in every case, neither L ('\u004C') nor l ('\u006C') is permitted to appear at the end of the property value as a type indicator, as would be permitted in Java programming language source code.

The second argument is the default value. The default value is returned if there is no property of the specified name, if the property does not have the correct numeric format, or if the specified name is empty or null.

Parameters:
nm property name.
val default value.
Returns:
the Long value of the property.
See also:
System.getProperty(java.lang.String)
System.getProperty(java.lang.String,java.lang.String)
decode(java.lang.String)
910
 
911
     public static Long getLong(String nm, Long val) {
912
         String v = null;
913
         try {
914
             v = System.getProperty(nm);
915
         } catch (IllegalArgumentException e) {
916
         } catch (NullPointerException e) {
917
         }
918
         if (v != null) {
919
             try {
920
                 return Long.decode(v);
921
             } catch (NumberFormatException e) {
922
             }
923
         }
924
         return val;
925
     }

    
Compares two Long objects numerically.

Parameters:
anotherLong the Long to be compared.
Returns:
the value 0 if this Long is equal to the argument Long; a value less than 0 if this Long is numerically less than the argument Long; and a value greater than 0 if this Long is numerically greater than the argument Long (signed comparison).
Since:
1.2
939
 
940
     public int compareTo(Long anotherLong) {
941
         long thisVal = this.;
942
         long anotherVal = anotherLong.value;
943
         return (thisVal<anotherVal ? -1 : (thisVal==anotherVal ? 0 : 1));
944
     }
945
 
946
 
947
     // Bit Twiddling
948
 
    
The number of bits used to represent a long value in two's complement binary form.

Since:
1.5
954
 
955
     public static final int SIZE = 64;

    
Returns a long value with at most a single one-bit, in the position of the highest-order ("leftmost") one-bit in the specified long value. Returns zero if the specified value has no one-bits in its two's complement binary representation, that is, if it is equal to zero.

Returns:
a long value with a single one-bit, in the position of the highest-order one-bit in the specified value, or zero if the specified value is itself equal to zero.
Since:
1.5
968
 
969
     public static long highestOneBit(long i) {
970
         // HD, Figure 3-1
971
         i |= (i >>  1);
972
         i |= (i >>  2);
973
         i |= (i >>  4);
974
         i |= (i >>  8);
975
         i |= (i >> 16);
976
         i |= (i >> 32);
977
         return i - (i >>> 1);
978
     }

    
Returns a long value with at most a single one-bit, in the position of the lowest-order ("rightmost") one-bit in the specified long value. Returns zero if the specified value has no one-bits in its two's complement binary representation, that is, if it is equal to zero.

Returns:
a long value with a single one-bit, in the position of the lowest-order one-bit in the specified value, or zero if the specified value is itself equal to zero.
Since:
1.5
991
 
992
     public static long lowestOneBit(long i) {
993
         // HD, Section 2-1
994
         return i & -i;
995
     }

    
Returns the number of zero bits preceding the highest-order ("leftmost") one-bit in the two's complement binary representation of the specified long value. Returns 64 if the specified value has no one-bits in its two's complement representation, in other words if it is equal to zero.

Note that this method is closely related to the logarithm base 2. For all positive long values x:

  • floor(log2(x)) = 63 - numberOfLeadingZeros(x)
  • ceil(log2(x)) = 64 - numberOfLeadingZeros(x - 1)

Returns:
the number of zero bits preceding the highest-order ("leftmost") one-bit in the two's complement binary representation of the specified long value, or 64 if the value is equal to zero.
Since:
1.5
1017
    public static int numberOfLeadingZeros(long i) {
1018
        // HD, Figure 5-6
1019
         if (i == 0)
1020
            return 64;
1021
        int n = 1;
1022
        int x = (int)(i >>> 32);
1023
        if (x == 0) { n += 32; x = (int)i; }
1024
        if (x >>> 16 == 0) { n += 16; x <<= 16; }
1025
        if (x >>> 24 == 0) { n +=  8; x <<=  8; }
1026
        if (x >>> 28 == 0) { n +=  4; x <<=  4; }
1027
        if (x >>> 30 == 0) { n +=  2; x <<=  2; }
1028
        n -= x >>> 31;
1029
        return n;
1030
    }

    
Returns the number of zero bits following the lowest-order ("rightmost") one-bit in the two's complement binary representation of the specified long value. Returns 64 if the specified value has no one-bits in its two's complement representation, in other words if it is equal to zero.

Returns:
the number of zero bits following the lowest-order ("rightmost") one-bit in the two's complement binary representation of the specified long value, or 64 if the value is equal to zero.
Since:
1.5
1045
    public static int numberOfTrailingZeros(long i) {
1046
        // HD, Figure 5-14
1047
        int x, y;
1048
        if (i == 0) return 64;
1049
        int n = 63;
1050
        y = (int)i; if (y != 0) { n = n -32; x = y; } else x = (int)(i>>>32);
1051
        y = x <<16; if (y != 0) { n = n -16; x = y; }
1052
        y = x << 8; if (y != 0) { n = n - 8; x = y; }
1053
        y = x << 4; if (y != 0) { n = n - 4; x = y; }
1054
        y = x << 2; if (y != 0) { n = n - 2; x = y; }
1055
        return n - ((x << 1) >>> 31);
1056
    }

    
Returns the number of one-bits in the two's complement binary representation of the specified long value. This function is sometimes referred to as the population count.

Returns:
the number of one-bits in the two's complement binary representation of the specified long value.
Since:
1.5
1067
     public static int bitCount(long i) {
1068
        // HD, Figure 5-14
1069
        i = i - ((i >>> 1) & 0x5555555555555555L);
1070
        i = (i & 0x3333333333333333L) + ((i >>> 2) & 0x3333333333333333L);
1071
        i = (i + (i >>> 4)) & 0x0f0f0f0f0f0f0f0fL;
1072
        i = i + (i >>> 8);
1073
        i = i + (i >>> 16);
1074
        i = i + (i >>> 32);
1075
        return (int)i & 0x7f;
1076
     }

    
Returns the value obtained by rotating the two's complement binary representation of the specified long value left by the specified number of bits. (Bits shifted out of the left hand, or high-order, side reenter on the right, or low-order.)

Note that left rotation with a negative distance is equivalent to right rotation: rotateLeft(val, -distance) == rotateRight(val, distance). Note also that rotation by any multiple of 64 is a no-op, so all but the last six bits of the rotation distance can be ignored, even if the distance is negative: rotateLeft(val, distance) == rotateLeft(val, distance & 0x3F).

Returns:
the value obtained by rotating the two's complement binary representation of the specified long value left by the specified number of bits.
Since:
1.5
1096
    public static long rotateLeft(long i, int distance) {
1097
        return (i << distance) | (i >>> -distance);
1098
    }

    
Returns the value obtained by rotating the two's complement binary representation of the specified long value right by the specified number of bits. (Bits shifted out of the right hand, or low-order, side reenter on the left, or high-order.)

Note that right rotation with a negative distance is equivalent to left rotation: rotateRight(val, -distance) == rotateLeft(val, distance). Note also that rotation by any multiple of 64 is a no-op, so all but the last six bits of the rotation distance can be ignored, even if the distance is negative: rotateRight(val, distance) == rotateRight(val, distance & 0x3F).

Returns:
the value obtained by rotating the two's complement binary representation of the specified long value right by the specified number of bits.
Since:
1.5
1118
    public static long rotateRight(long i, int distance) {
1119
        return (i >>> distance) | (i << -distance);
1120
    }

    
Returns the value obtained by reversing the order of the bits in the two's complement binary representation of the specified long value.

Returns:
the value obtained by reversing order of the bits in the specified long value.
Since:
1.5
1131
    public static long reverse(long i) {
1132
        // HD, Figure 7-1
1133
        i = (i & 0x5555555555555555L) << 1 | (i >>> 1) & 0x5555555555555555L;
1134
        i = (i & 0x3333333333333333L) << 2 | (i >>> 2) & 0x3333333333333333L;
1135
        i = (i & 0x0f0f0f0f0f0f0f0fL) << 4 | (i >>> 4) & 0x0f0f0f0f0f0f0f0fL;
1136
        i = (i & 0x00ff00ff00ff00ffL) << 8 | (i >>> 8) & 0x00ff00ff00ff00ffL;
1137
        i = (i << 48) | ((i & 0xffff0000L) << 16) |
1138
            ((i >>> 16) & 0xffff0000L) | (i >>> 48);
1139
        return i;
1140
    }

    
Returns the signum function of the specified long value. (The return value is -1 if the specified value is negative; 0 if the specified value is zero; and 1 if the specified value is positive.)

Returns:
the signum function of the specified long value.
Since:
1.5
1150
    public static int signum(long i) {
1151
        // HD, Section 2-7
1152
        return (int) ((i >> 63) | (-i >>> 63));
1153
    }

    
Returns the value obtained by reversing the order of the bytes in the two's complement representation of the specified long value.

Returns:
the value obtained by reversing the bytes in the specified long value.
Since:
1.5
1163
    public static long reverseBytes(long i) {
1164
        i = (i & 0x00ff00ff00ff00ffL) << 8 | (i >>> 8) & 0x00ff00ff00ff00ffL;
1165
        return (i << 48) | ((i & 0xffff0000L) << 16) |
1166
            ((i >>> 16) & 0xffff0000L) | (i >>> 48);
1167
    }

    
use serialVersionUID from JDK 1.0.2 for interoperability
1170
    private static final long serialVersionUID = 4290774380558885855L;
New to GrepCode? Check out our FAQ X