Java Tutorial/Data Type/Long

Материал из Java эксперт
Перейти к: навигация, поиск

Add two long integers, checking for overflow.

   <source lang="java">

import java.io.File; /*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

public class Main {

 /**
  * Add two long integers, checking for overflow.
  * 
  * @param a an addend
  * @param b an addend
  * @return the sum a+b
  * @throws ArithmeticException if the result can not be represented as an
  *         long
  * @since 1.2
  */
 public static long addAndCheck(long a, long b) {
     return addAndCheck(a, b, "overflow: add");
 }
 
 /**
  * Add two long integers, checking for overflow.
  * 
  * @param a an addend
  * @param b an addend
  * @param msg the message to use for any thrown exception.
  * @return the sum a+b
  * @throws ArithmeticException if the result can not be represented as an
  *         long
  * @since 1.2
  */
 private static long addAndCheck(long a, long b, String msg) {
     long ret;
     if (a > b) {
         // use symmetry to reduce boundry cases
         ret = addAndCheck(b, a, msg);
     } else {
         // assert a <= b
         
         if (a < 0) {
             if (b < 0) {
                 // check for negative overflow
                 if (Long.MIN_VALUE - b <= a) {
                     ret = a + b;
                 } else {
                     throw new ArithmeticException(msg);
                 }
             } else {
                 // oppisite sign addition is always safe
                 ret = a + b;
             }
         } else {
             // assert a >= 0
             // assert b >= 0
             // check for positive overflow
             if (a <= Long.MAX_VALUE - b) {
                 ret = a + b;
             } else {
                 throw new ArithmeticException(msg);
             }
         }
     }
     return ret;
 }

}</source>





A utility class for converting a long into a human readable string.

   <source lang="java">

/*

* JBoss, Home of Professional Open Source.
* Copyright 2008, Red Hat Middleware LLC, and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/

import java.io.Serializable; /**

* TimeFormat is a utility class for converting a long into a human readable
* string.
* 
* 
* 
* Example usage:
* 
*  System.out.println("You have been online for:
* "+TimeFormat.valueOf(milliseconds)); 
* 
* FIXME: expanded features need documentation. JGH
* 
* @author 
* @date $Date: 2008-11-14 07:45:28 -0500 (Fri, 14 Nov 2008) $
* @version $Revision: 81022 $
*/

public final class TimeFormat implements Serializable {

 public static final boolean DEBUG = false;
 public static final long ONE_MILLISECOND = (1);
 public static final long ONE_SECOND = (ONE_MILLISECOND * 1000);
 public static final long ONE_MINUTE = (ONE_SECOND * 60);
 public static final long ONE_HOUR = (ONE_MINUTE * 60);
 public static final long ONE_DAY = (ONE_HOUR * 24);
 public static final int ROUND_TO_MILLISECOND = 5;
 public static final int ROUND_TO_SECOND = 4;
 public static final int ROUND_TO_MINUTE = 3;
 public static final int ROUND_TO_HOUR = 2;
 public static final int ROUND_TO_DAY = 1;
 private long original = 0;
 private long time = 0;
 private long remainder = 0;
 private long days = 0;
 private long hours = 0;
 private long minutes = 0;
 private long seconds = 0;
 private long milliseconds = 0;
 private boolean micro = false;
 private int rounding = ROUND_TO_SECOND;
 /**
  * construct a time format
  * 
  * 
  * @param milliseconds
  */
 private TimeFormat(long milliseconds, int round) {
   this.rounding = round;
   this.original = milliseconds;
   if (milliseconds >= ONE_SECOND) {
     this.remainder = milliseconds;
     getTime();
   } else {
     micro = true;
     // if less than second, we"ll just
     // display
     time = milliseconds;
   }
 }
 /**
  * construct a time format
  * 
  * 
  * @param milliseconds
  */
 private TimeFormat(long milliseconds) {
   this(milliseconds, TimeFormat.ROUND_TO_MILLISECOND);
 }
 /**
  * get days
  * 
  * @return days
  */
 public long getDays() {
   return days;
 }
 /**
  * get minutes
  * 
  * @return minutes
  */
 public long getMinutes() {
   return minutes;
 }
 /**
  * get hours
  * 
  * @return hours
  */
 public long getHours() {
   return hours;
 }
 /**
  * get seconds
  * 
  * @return seconds
  */
 public long getSeconds() {
   return seconds;
 }
 /**
  * add a timeformat
  * 
  * 
  * @param t
  */
 public void add(TimeFormat t) {
   days += t.days;
   hours += t.hours;
   minutes += t.minutes;
   seconds += t.seconds;
 }
 /**
  * get days from a time format
  * 
  * 
  * @param t
  */
 public void getDays(TimeFormat t) {
   if (t.remainder >= ONE_DAY) {
     t.days = (t.remainder / ONE_DAY);
     t.remainder -= (t.days * ONE_DAY);
   }
 }
 /**
  * get hours from a time format
  * 
  * 
  * @param t
  */
 public void getHours(TimeFormat t) {
   if (t.remainder >= ONE_HOUR && t.remainder < ONE_DAY) {
     t.hours = (t.remainder / ONE_HOUR);
     t.remainder -= (t.hours * ONE_HOUR);
   }
 }
 /**
  * get minutes from a time format
  * 
  * 
  * @param t
  */
 public void getMinutes(TimeFormat t) {
   if (t.remainder >= ONE_MINUTE && t.remainder < ONE_HOUR) {
     t.minutes = (t.remainder / ONE_MINUTE);
     t.remainder -= (t.minutes * ONE_MINUTE);
   }
 }
 /**
  * get seconds from a time format
  * 
  * 
  * @param t
  */
 public void getSeconds(TimeFormat t) {
   if (t.remainder >= ONE_SECOND && t.remainder < ONE_MINUTE) {
     t.seconds = (t.remainder / ONE_SECOND);
     t.milliseconds = t.remainder -= (t.seconds * ONE_SECOND);
   } else {
     t.seconds = 0;
     t.milliseconds = t.remainder;
   }
 }
 /**
  * update time
  * 
  * 
  * @param t
  */
 public void getTime(TimeFormat t) {
   t.getTime();
 }
 /**
  * update
  * 
  */
 private void getTime() {
   getDays(this);
   getHours(this);
   getMinutes(this);
   getSeconds(this);
 }
 /**
  * get the milliseconds
  */
 public long getMilliseconds() {
   return (micro ? time : milliseconds);
 }
 /**
  * print out the time format in a string representation
  */
 public String toString() {
   return format(rounding);
 }
 /**
  * set rounding - one of ROUND_TO_MILLISECONDS, etc.
  */
 public void setRounding(int r) {
   rounding = r;
 }
 /**
  * return the rounding
  */
 public int getRouding() {
   return rounding;
 }
 /**
  * format string based on rouding
  */
 public String format(int round) {
   if (DEBUG) {
     System.err.println("-->time: " + time + ", round: " + round + ", micro: " + micro
         + ",remainder:" + remainder);
     System.err.println("-->days: " + days);
     System.err.println("-->hours: " + hours);
     System.err.println("-->minutes: " + minutes);
     System.err.println("-->hours: " + hours);
     System.err.println("-->seconds: " + seconds);
     System.err.println("-->milliseconds: " + milliseconds);
     System.err.flush();
   }
   switch (round) {
   case ROUND_TO_DAY: {
     return formatDays(false);
   }
   case ROUND_TO_HOUR: {
     return formatDays(true) + formatHours(false);
   }
   case ROUND_TO_MINUTE: {
     return formatDays(true) + formatHours(true) + formatMinutes(false);
   }
   case ROUND_TO_SECOND: {
     return formatDays(true) + formatHours(true) + formatMinutes(true) + formatSeconds(false);
   }
   case ROUND_TO_MILLISECOND: {
     return formatDays(true) + formatHours(true) + formatMinutes(true) + formatSeconds(true)
         + (micro ? time : milliseconds) + " ms";
   }
   }
   return original + " ms";
 }
 /**
  * FIXME: Missing Method declaration
  * 
  * 
  * @param empty
  * @return
  */
 private String formatDays(boolean empty) {
   if (days <= 0) {
     return empty ? "" : "0 days";
   }
   return format("day", "days", days);
 }
 /**
  * FIXME: Missing Method declaration
  * 
  * 
  * @param empty
  * @return
  */
 private String formatHours(boolean empty) {
   if (hours <= 0) {
     return empty ? "" : "0 hours";
   }
   return format("hour", "hours", hours);
 }
 /**
  * FIXME: Missing Method declaration
  * 
  * 
  * @param empty
  * @return
  */
 private String formatMinutes(boolean empty) {
   if (minutes <= 0) {
     return empty ? "" : "0 minutes";
   }
   return format("minute", "minutes", minutes);
 }
 /**
  * FIXME: Missing Method declaration
  * 
  * 
  * @param empty
  * @return
  */
 private String formatSeconds(boolean empty) {
   if (seconds <= 0) {
     return empty ? "" : "0 seconds";
   }
   return format("second", "seconds", seconds);
 }
 /**
  * handle amt formatting
  */
 private String format(String single, String plural, long amt) {
   if (amt > 0) {
     return amt + " " + (amt > 1 ? plural : single) + " ";
   }
   return "";
 }
 /**
  * return a string formatted version of time t rounding to
  * round
  * 
  * @param t
  * @param round
  * @return String value
  */
 public static String valueOf(long t, int round) {
   TimeFormat f = new TimeFormat(t, round);
   return f.toString();
 }
 /**
  * return a string formatted version of time t rounding to
  * round
  * 
  * @param t
  * @param round
  * @return String value
  */
 public static String valueOf(long t) {
   return valueOf(t, TimeFormat.ROUND_TO_MILLISECOND);
 }
 /**
  * format with a date time
  */
 public static String format(String format, long time) {
   TimeFormat f = new TimeFormat(time);
   return f.parse(format, f.getDays(), f.getHours(), f.getMinutes(), f.getSeconds(), f
       .getMilliseconds());
 }
 /**
  * parse
  */
 private String parse(String format, long day, long hour, long minute, long second, long millis) {
   String s = "";
   int start = 0;
   int len = format.length();
   for (int c = 0; c < len; c++) {
     char tc = format.charAt(c);
     int sc = c;
     int l = 0;
     switch (tc) {
     case " ": {
       s += " ";
       break;
     }
     case "\"": {
       while (++c < len && format.charAt(c) != "\"")
         ;
       s += format.substring(sc + 1, c);
       break;
     }
     case "D": // days
     case "d":
       while (++c < len && (format.charAt(c) == "d" || format.charAt(c) == "D"))
         ;
       l = c - sc;
       s += sc <= 0 || start < 0 ? "" : format.substring(start, sc);
       s += zeroPad(day, l - 1);
       --c;
       break;
     case "h": // hours
     case "H":
       while (++c < len && (format.charAt(c) == "h" || format.charAt(c) == "H"))
         ;
       l = c - sc;
       s += sc <= 0 || start < 0 ? "" : format.substring(start, sc);
       s += zeroPad(hour, l - 1);
       --c;
       break;
     case "m": // minutes
     case "M":
       while (++c < len && (format.charAt(c) == "m" || format.charAt(c) == "M"))
         ;
       l = c - sc;
       s += sc <= 0 || start < 0 ? "" : format.substring(start, sc);
       s += zeroPad(minute, l - 1);
       --c;
       break;
     case "s": // seconds
     case "S":
       while (++c < len && (format.charAt(c) == "s" || format.charAt(c) == "S"))
         ;
       l = c - sc;
       s += sc <= 0 || start < 0 ? "" : format.substring(start, sc);
       s += zeroPad(second, l - 1);
       --c;
       break;
     case "z": // milliseconds
     case "Z":
       while (++c < len && (format.charAt(c) == "z" || format.charAt(c) == "Z"))
         ;
       l = c - sc;
       s += sc <= 0 || start < 0 ? "" : format.substring(start, sc);
       s += zeroPad(millis, l - 1);
       --c;
       break;
     }
     start = c + 1;
   }
   return s;
 }
 /**
  * zero pad a number to len
  */
 private String zeroPad(long value, int len) {
   String s = String.valueOf(value);
   int l = s.length();
   String r = "";
   for (int c = l; c <= len; c++) {
     r += "0";
   }
   return r + s;
 }
 /**
  * test
  * 
  * 
  * @param args
  */
 public static void main(String args[]) {
   String FORMAT = "D "days," HH "hours," mm "minutes and " ss "seconds, "zz "milliseconds"";
   System.out.println(TimeFormat.format(FORMAT, 1000));
   System.out.println("ONE SECOND: " + TimeFormat.ONE_SECOND);
   System.out.println("ONE MINUTE: " + TimeFormat.ONE_MINUTE);
   System.out.println("ONE HOUR:   " + TimeFormat.ONE_HOUR);
   System.out.println("ONE DAY:    " + TimeFormat.ONE_DAY);
   for (int c = 0; c <= 5; c++) {
     System.out.println("Round to: " + c);
     System.out.println("Time: " + TimeFormat.valueOf(Long.MAX_VALUE, c));
     System.out.println("Time: " + TimeFormat.valueOf(1236371400, c));
     System.out.println("Time: " + TimeFormat.format(FORMAT, 1236371400));
     System.out.println("Time: " + TimeFormat.valueOf(123613700, c));
     System.out.println("Time: " + TimeFormat.valueOf(700, c));
     System.out.println("Time: " + TimeFormat.valueOf(2001, c));
     System.out.println("Time: " + TimeFormat.valueOf(2101, c));
     System.out.println("Time: " + TimeFormat.valueOf(15, c));
     System.out.println("Time: " + TimeFormat.valueOf(999, c));
     System.out.println("Time: " + TimeFormat.valueOf(10000, c));
     System.out.println("Time: " + TimeFormat.valueOf(ONE_MINUTE * 10, c));
     System.out.println("Time: " + TimeFormat.valueOf(ONE_DAY * 10 + 101, c));
     System.out.println("Time: " + TimeFormat.valueOf(ONE_HOUR * 10, c));
     System.out.println("Time: " + TimeFormat.valueOf(ONE_HOUR + ONE_DAY + (ONE_MINUTE * 2), c));
     System.out.println("Time: "
         + TimeFormat.format(FORMAT, ONE_HOUR + ONE_DAY + (ONE_MINUTE * 2)));
   }
 }

} /**

* $Log: 1 Head - DO NOT USE1.0 12/3/01 2:51:16 PM jhaynie $ Revision 1.2
* 2001/08/31 22:04:24 jhaynie added parsing and formatting features
* 
* Revision 1.1 2001/08/29 19:47:53 jhaynie initial checkin
* 
*/</source>
   
  
 
  



Compare Two Java long Arrays Example

   <source lang="java">

import java.util.Arrays; public class Main {

 public static void main(String[] args) {
   long[] a1 = new long[] { 2, 8, 3 };
   long[] a2 = new long[] { 2, 8, 3 };
   System.out.println(Arrays.equals(a1, a2));
 }

}</source>





Compute distance light travels using long variables

   <source lang="java">

public class MainClass {

 public static void main(String args[]) {
   int lightspeed;
   long days;
   long seconds;
   long distance;
   // approximate speed of light in miles per second
   lightspeed = 186000;
   days = 1000; // specify number of days here
   seconds = days * 24 * 60 * 60; // convert to seconds
   distance = lightspeed * seconds; // compute distance
   System.out.print("In " + days);
   System.out.print(" days light will travel about ");
   System.out.println(distance + " miles.");
 }

}</source>



In 1000 days light will travel about 16070400000000 miles


Convert from long to String

   <source lang="java">

public class Main {

 public static void main(String[] args) throws Exception {
   String str = Long.toString(2L);
 }

}</source>





Convert from String to long

   <source lang="java">

public class Main {

 public static void main(String[] args) throws Exception {
   String str = "0.5";
   long l = Long.valueOf(str).longValue();
   // or
   Long L = Long.parseLong(str);
 }

}</source>





Convert Java String to Long example

   <source lang="java">

public class Main {

 public static void main(String[] args) {
   Long lObj1 = new Long("100");
   System.out.println(lObj1);
   String str = "100";
   Long lObj2 = Long.valueOf(str);
   System.out.println(lObj2);
 }

}</source>





Convert long primitive to Long object Example

   <source lang="java">

public class Main {

 public static void main(String[] args) {
   long i = 10;
   Long lObj = new Long(i);
   System.out.println(lObj);
 }

}</source>





Convert Long to numeric primitive data types example

   <source lang="java">

public class Main {

 public static void main(String[] args) {
   Long lObj = new Long("10");
   byte b = lObj.byteValue();
   System.out.println(b);
   short s = lObj.shortValue();
   System.out.println(s);
   int i = lObj.intValue();
   System.out.println(i);
   float f = lObj.floatValue();
   System.out.println(f);
   double d = lObj.doubleValue();
   System.out.println(d);
 }

}</source>





Create a Long object

   <source lang="java">

public class Main {

 public static void main(String[] args) {
   long l = 10;
   Long longObj1 = new Long(l);
   Long longObj2 = new Long("5");
   System.out.println(longObj1);
   System.out.println(longObj2);
 }

}</source>





Format long with System.out.format

   <source lang="java">

/*

* Copyright (c) 1995 - 2008 Sun Microsystems, Inc.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
*   - Redistributions of source code must retain the above copyright
*     notice, this list of conditions and the following disclaimer.
*
*   - Redistributions in binary form must reproduce the above copyright
*     notice, this list of conditions and the following disclaimer in the
*     documentation and/or other materials provided with the distribution.
*
*   - Neither the name of Sun Microsystems nor the names of its
*     contributors may be used to endorse or promote products derived
*     from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

import java.util.Calendar; import java.util.Locale; public class TestFormat {

 public static void main(String[] args) {
   long n = 461012;
   System.out.format("%d%n", n);
   System.out.format("%08d%n", n);
   System.out.format("%+8d%n", n);
   System.out.format("%,8d%n", n);
   System.out.format("%+,8d%n%n", n);
   double pi = Math.PI;
   System.out.format("%f%n", pi);
   System.out.format("%.3f%n", pi);
   System.out.format("%10.3f%n", pi);
   System.out.format("%-10.3f%n", pi);
   System.out.format(Locale.FRANCE, "%-10.4f%n%n", pi);
   Calendar c = Calendar.getInstance();
   System.out.format("%tB %te, %tY%n", c, c, c);
   System.out.format("%tl:%tM %tp%n", c, c, c);
   System.out.format("%tD%n", c);
 }

}</source>





Gets the maximum of three long values.

   <source lang="java">

import java.math.BigDecimal; import java.math.BigInteger; /**

* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**

* Provides extra functionality for Java Number classes.
*
* @author 
* @author Eric Pugh
* @author Phil Steitz
* @since 1.0
* @version $Id: NumberUtils.java 488819 2006-12-19 21:50:04Z bayard $
* 
*/

public class Main {

 /**
  * Gets the maximum of three long values.
  * 
  * @param a  value 1
  * @param b  value 2
  * @param c  value 3
  * @return  the largest of the values
  */
 public static long maximum(long a, long b, long c) {
     if (b > a) {
         a = b;
     }
     if (c > a) {
         a = c;
     }
     return a;
 }

}</source>





Gets the minimum of three long values.

   <source lang="java">

import java.math.BigDecimal; import java.math.BigInteger; /**

* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

/**

* Provides extra functionality for Java Number classes.
*
* @author 
* @author Eric Pugh
* @author Phil Steitz
* @since 1.0
* @version $Id: NumberUtils.java 488819 2006-12-19 21:50:04Z bayard $
* 
*/

public class Main {

 //--------------------------------------------------------------------
 
 /**
  * Gets the minimum of three long values.
  * 
  * @param a  value 1
  * @param b  value 2
  * @param c  value 3
  * @return  the smallest of the values
  */
 public static long minimum(long a, long b, long c) {
     if (b < a) {
         a = b;
     }
     if (c < a) {
         a = c;
     }
     return a;
 }

}</source>





Java long Example: long is 64 bit signed type

   <source lang="java">

import java.util.Date; public class Main {

 public static void main(String[] args) {
   long timeInMilliseconds = new Date().getTime();
   System.out.println("Time in milliseconds is : " + timeInMilliseconds);
 }

} //Time in milliseconds is : 1235149879683</source>





Java Sort long Array Example

   <source lang="java">

import java.util.Arrays; public class Main {

 public static void main(String[] args) {
   long[] l1 = new long[] { 3L, 2L, 5L, 4L, 1L };
   for (long l: l1){
     System.out.print(" " + l);
   }
   Arrays.sort(l1);
   for (long l: l1){
     System.out.print(" " + l);
   }
   long[] l2 = new long[] { 5, 2, 3, 1, 4 };
   Arrays.sort(l2, 1, 4);
   for (long l: l2){
     System.out.print(" " + l);
   }
 }

}</source>





Long Integer Literal

Append an L to the value to define an integer of type long.



   <source lang="java">

public class MainClass {

 public static void main(String[] a){
    long longValue = 123456789L;
    System.out.println(longValue);
 }

}</source>



123456789


Min and Max values of datatype long

   <source lang="java">

public class Main {

   public static void main(String[] args) {
       System.out.println(Long.MIN_VALUE);
       System.out.println(Long.MAX_VALUE);
   }

} /* -9223372036854775808 9223372036854775807

  • /</source>





Multiply two long integers, checking for overflow.

   <source lang="java">

import java.io.File; /*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

public class Main {

 /**
  * Multiply two long integers, checking for overflow.
  * 
  * @param a first value
  * @param b second value
  * @return the product a * b
  * @throws ArithmeticException if the result can not be represented as an
  *         long
  * @since 1.2
  */
 public static long mulAndCheck(long a, long b) {
     long ret;
     String msg = "overflow: multiply";
     if (a > b) {
         // use symmetry to reduce boundry cases
         ret = mulAndCheck(b, a);
     } else {
         if (a < 0) {
             if (b < 0) {
                 // check for positive overflow with negative a, negative b
                 if (a >= Long.MAX_VALUE / b) {
                     ret = a * b;
                 } else {
                     throw new ArithmeticException(msg);
                 }
             } else if (b > 0) {
                 // check for negative overflow with negative a, positive b
                 if (Long.MIN_VALUE / b <= a) {
                     ret = a * b;
                 } else {
                     throw new ArithmeticException(msg);
                     
                 }
             } else {
                 // assert b == 0
                 ret = 0;
             }
         } else if (a > 0) {
             // assert a > 0
             // assert b > 0
             
             // check for positive overflow with positive a, positive b
             if (a <= Long.MAX_VALUE / b) {
                 ret = a * b;
             } else {
                 throw new ArithmeticException(msg);
             }
         } else {
             // assert a == 0
             ret = 0;
         }
     }
     return ret;
 }

}</source>





Subtract two long integers, checking for overflow.

   <source lang="java">

import java.math.BigDecimal; /*

* Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You under the Apache License, Version 2.0
*  (the "License"); you may not use this file except in compliance with
*  the License.  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*
*/

public class Main {

 /**
  * Subtract two long integers, checking for overflow.
  * 
  * @param a first value
  * @param b second value
  * @return the difference a-b
  * @throws ArithmeticException if the result can not be represented as an
  *         long
  * @since 1.2
  */
 public static long subAndCheck(long a, long b) {
     long ret;
     String msg = "overflow: subtract";
     if (b == Long.MIN_VALUE) {
         if (a < 0) {
             ret = a - b;
         } else {
             throw new ArithmeticException(msg);
         }
     } else {
         // use additive inverse
         ret = addAndCheck(a, -b, msg);
     }
     return ret;
 }
 /**
  * Add two long integers, checking for overflow.
  * 
  * @param a an addend
  * @param b an addend
  * @param msg the message to use for any thrown exception.
  * @return the sum a+b
  * @throws ArithmeticException if the result can not be represented as an
  *         long
  * @since 1.2
  */
 private static long addAndCheck(long a, long b, String msg) {
     long ret;
     if (a > b) {
         // use symmetry to reduce boundry cases
         ret = addAndCheck(b, a, msg);
     } else {
         // assert a <= b
         
         if (a < 0) {
             if (b < 0) {
                 // check for negative overflow
                 if (Long.MIN_VALUE - b <= a) {
                     ret = a + b;
                 } else {
                     throw new ArithmeticException(msg);
                 }
             } else {
                 // oppisite sign addition is always safe
                 ret = a + b;
             }
         } else {
             // assert a >= 0
             // assert b >= 0
             // check for positive overflow
             if (a <= Long.MAX_VALUE - b) {
                 ret = a + b;
             } else {
                 throw new ArithmeticException(msg);
             }
         }
     }
     return ret;
 }

}</source>





Use toString method of Long class to convert Long into String.

   <source lang="java">

public class Main {

 public static void main(String[] args) {
   Long lObj = new Long(10);
   String str = lObj.toString();
   System.out.println("Long converted to String as " + str);
 }

}</source>