The range of `double` is greater than that of `long`. For example:

    double x = Long.MAX_VALUE;
    x = x * 1000;
    x = Math.ceil(x);

What would you expect the last line to do if `Math.ceil` returned `long`?

Note that at very large values (positive or negative) the numbers end up being distributed very sparsely - so the next integer greater than integer `x` won&#39;t be `x + 1` if you see what I mean.

A double can be larger than `Long.MAX_VALUE`.  If you call `Math.ceil()` on such a value you would expect to return the same value.  However if it returned a long, the value would be incorrect.

I have just started writing my first ever Java/Android application, so forgive the total n00b question.

How do you access the the standard operating system icons such as search icon/menu icon etc? They are not in the res/drawable folder where I would expect to find them. Are they available as part of the SDK or must you download them seperately?

**EDIT**

Maybe you can help me further - I am getting the following error (repeated on):

    [2011-09-08 19:59:47 - TweetTab] C:\Users\Dan\workspace\TweetTab\res\menu\options_menu.xml:4: error: Error: No resource found that matches the given name (at &#39;icon&#39; with value &#39;@drawable/ic_menu_search&#39;).

However, the icon is not empty, the xml looks like this:

    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    
    &lt;menu xmlns:android=&quot;http://schemas.android.com/apk/res/android&quot;&gt;
        &lt;item android:id=&quot;@+id/search&quot;
            android:icon=&quot;@drawable/ic_menu_search&quot;
            android:title=&quot;@string/search&quot;/&gt;
    &lt;/menu&gt;

Am I missing something?

**SOLVED**

I changed `android:icon=&quot;@drawable/ic_menu_search&quot;` to `android:icon=&quot;@android:drawable/ic_menu_search&quot;` and it could then find the icon.

Where are all the standard Android icon resources?

I would like to append an li element after another li inside a ul element using javascript, This is the code I have so far..

    var parentGuest = document.getElementById(&quot;one&quot;);
    var childGuest = document.createElement(&quot;li&quot;);
    childGuest.id = &quot;two&quot;;

I am familiar with appendChild,

    parentGuest.appendChild(childGuest);

However this appends the new element inside the other, and not after. How can I append the new element after the existing one? Thanks.

    &lt;ul&gt;
      &lt;li id=&quot;one&quot;&gt;&lt;!-- where the new li is being put --&gt;&lt;/li&gt;
      &lt;!-- where I want the new li --&gt;
    &lt;/ul&gt;

Javascript Append Child AFTER Element

When I call `Math.ceil(5.2)` the return is the `double` `6.0`. My natural inclination was to think that `Math.ceil(double a)` would return a `long`. From the documentation:

&gt; `ceil(double a)`
&gt; 
&gt; Returns the smallest (closest to negative infinity) `double` value
&gt; that is not less than the argument and is equal to a mathematical
&gt; integer.

But why return a `double` rather than a `long` when the result is an integer? I think understanding the reason behind it might help me understand Java a bit better. It also might help me figure out if I&#39;ll get myself into trouble by casting to a `long`, e.g. is

`long b = (long)Math.ceil(a);`

always what I think it should be? I fear there could be some boundary cases that are problematic.


Why does Math.ceil return a double?

When I call <code>Math.ceil(5.2)</code> the return is the <code>double</code> <code>6.0</code>. My natural inclination was to think that <code>Math.ceil(double a)</code> would return a <code>long</code>. From the documentation:
> <code>ceil(double a)</code>
>
> Returns the smallest (closest to negative infinity) <code>double</code> value
> that is not less than the argument and is equal to a mathematical
> integer.
But why return a <code>double</code> rather than a <code>long</code> when the result is an integer? I think understanding the reason behind it might help me understand Java a bit better. It also might help me figure out if I'll get myself into trouble by casting to a <code>long</code>, e.g. is
<code>long b = (long)Math.ceil(a);</code>
always what I think it should be? I fear there could be some boundary cases that are problematic.

I have two packages, `Shapes` and `Fruits`:

    com.myproject.Shapes.
        Circle
        Square
        Triangle
    com.myproject.Fruits.
        Apple
        Orange

I am writing the JavaDoc for `Apple` and need to provide an `{@link}` to `Square`.

I have tried all of the following, and none of them work:

    {@link Square}
    {@link com.myproject.Square}

I&#39;ve been able to find documentation for linking to: (a) classes within the same package, or (b) externals URLs, but not classes in another package.

Any ideas what the correct syntax should be? Thanks!

Javadoc linking to a class in another package

I have an object that contains a few unserializable fields that I want to serialize. They are from a separate API that I cannot change, so making them Serializable is not an option. The main problem is the Location class. It contains four things that can be serialized that I&#39;d need, all ints. How can I use read/writeObject to create a custom serialization method that can do something like this:

    // writeObject:
    List&lt;Integer&gt; loc = new ArrayList&lt;Integer&gt;();
    loc.add(location.x);
    loc.add(location.y);
    loc.add(location.z);
    loc.add(location.uid);
    // ... serialization code

    // readObject:
    List&lt;Integer&gt; loc = deserialize(); // Replace with real deserialization
    location = new Location(loc.get(0), loc.get(1), loc.get(2), loc.get(3));
    // ... more code

How can I do this?

Java Custom Serialization

I am trying to list time complexities of operations of common data structures like Arrays, Binary Search Tree, Heap, Linked List, etc. and especially I am referring to Java. They are very common, but I guess some of us are not 100% confident about the exact answer. Any help, especially references, is greatly appreciated.

E.g. For singly linked list: Changing an internal element is O(1). How can you do it? You *HAVE* to search the element before changing it. Also, for the Vector, adding an internal element is given as O(n). But why can&#39;t we do it in amortized constant time using the index? Please correct me if I am missing something.

I am posting my findings/guesses as the first answer. 


  [1]: http://essays.hexapodia.net/datastructures/

What are the time complexities of various data structures?

I have been doing Java SE for some years now and moving on to Java EE. However, I have some trouble understanding some aspects of Java EE.

1. Is Java EE just a specification? What I mean is: Is EJB Java EE?  

2. Are EJB/Spring different implementations of Java EE?

I am sorry to ask but I have some difficulties to understand what Java EE is.  

**Could someone explain what Java EE is? And EJB?**

What exactly is Java EE?

I want to add a &quot;Check for update&quot; button in apps so that when someone clicks it, it will display a toast message / progress dialog for checking the app&#39;s version. 

If new version is found the apps will auto download it to the phone and let user to  manually install the updated apps.

Or any others method will do as long as it can check for latest version and notify the user to update.

--------

**Update:** Now you can do this inside your app using https://developer.android.com/guide/playcore/in-app-updates


How to allow users to check for the latest app version from inside the app?

How come that in the following snippet

    int a = 7;
    int b = 3;
    double c = 0;
    c = a / b;

`c` ends up having the value 2, rather than 2.3333, as one would expect. If `a` and `b` are doubles, the answer does turn to 2.333. But surely because `c`  already is a double it should have worked with integers?

So how come `int/int=double` doesn&#39;t work?


Why does dividing two int not yield the right value when assigned to double?

For example I have the variable 3.545555555, which I would want to truncate to just 3.54. 

How can I truncate a double to only two decimal places in Java?

Maybe this is a silly question, but I cannot guess how to solve it if it&#39;s not creating a method. Maybe there&#39;s a &quot;natural way&quot; to do it, like in C for example. Here&#39;s the problem:

I have a var:

    double a;

And I want to show it only with 2 or 3 decimals. When I try to show it:

    Text.setText(&quot;Value of a: &quot; + String.valueOf(a));

It gives something like:

&gt; Value of a: 5.234966145

And i would want just

&gt; Value of a: 5.23

Without changing the real value of a so it shows the approximate number but works with the real number.

How to print a double with two decimals in Android?

&gt; **Possible Duplicate:**  
&gt; [Round a double to 2 significant figures after decimal point](https://stackoverflow.com/questions/2808535/round-a-double-to-2-significant-figures-after-decimal-point)  

&lt;!-- End of automatically inserted text --&gt;

I know that there are plenty of examples on how to round this kind numbers.
But could someone show me how to round double, to get value that I can display as a 
String and ALWAYS have 2 decimal places?



Android - Round to 2 decimal places

In the following program you can see that each value slightly less than `.5` is rounded down, except for `0.5`.

    for (int i = 10; i &gt;= 0; i--) {
        long l = Double.doubleToLongBits(i + 0.5);
        double x;
        do {
            x = Double.longBitsToDouble(l);
            System.out.println(x + &quot; rounded is &quot; + Math.round(x));
            l--;
        } while (Math.round(x) &gt; i);
    }

prints

    10.5 rounded is 11
    10.499999999999998 rounded is 10
    9.5 rounded is 10
    9.499999999999998 rounded is 9
    8.5 rounded is 9
    8.499999999999998 rounded is 8
    7.5 rounded is 8
    7.499999999999999 rounded is 7
    6.5 rounded is 7
    6.499999999999999 rounded is 6
    5.5 rounded is 6
    5.499999999999999 rounded is 5
    4.5 rounded is 5
    4.499999999999999 rounded is 4
    3.5 rounded is 4
    3.4999999999999996 rounded is 3
    2.5 rounded is 3
    2.4999999999999996 rounded is 2
    1.5 rounded is 2
    1.4999999999999998 rounded is 1
    0.5 rounded is 1
    0.49999999999999994 rounded is 1
    0.4999999999999999 rounded is 0

I am using Java 6 update 31.


Why does Math.round(0.49999999999999994) return 1?

As I&#39;ve learned recently, a `long` in C/C++ is the same length as an `int`.  To put it simply, why?  It seems almost pointless to even include the datatype in the language.  Does it have any uses specific to it that an `int` doesn&#39;t have?  I know we can declare a 64-bit `int` like so:

    long long x = 0;

But why does the language choose to do it this way, rather than just making a `long` well...longer than an `int`?  Other languages such as C# do this, so why not C/C++?

Long Vs. Int C/C++ - What&#39;s The Point?

I have list with long values (for example: 1220227200, 1220832000, 1221436800...) which I downloaded from web service. I must convert it to Dates. Unfortunately this way, for example:

    Date d = new Date(1220227200);

returns 1 Jan 1970. Anyone know another way to convert it correctly?

Converting Long to Date in Java returns 1970

I&#39;m trying to implement RC4 and DH key exchange in python. Problem is that I have no idea about how to convert the python long/int from the key exchange to the byte array I need for the RC4 implementation. Is there a simple way to convert a long to the required length byte array?

**Update**: forgot to mention that the numbers I&#39;m dealing with are 768 bit unsigned integers.

Convert python long/int to fixed size byte array

how do you convert a string into a long.

for int you

    int i = 3423;
    String str;
    str = str.valueOf(i);

so how do you go the other way but with long.

    long lg;
    String Str = &quot;1333073704000&quot;
    lg = lg.valueOf(Str);

How to convert string to long

Is it OK to compare an int and a long in Java...

    long l = 800L
    int i = 4

    if (i &lt; l) {
     // i is less than l
    }

Is it OK to compare an int and a long in Java

How can I round up a CGFloat in Swift?
I&#39;ve tried `ceil(CDouble(myCGFloat))` but that only works on iPad Air &amp; iPhone 5S.

When running on another simulated device I get an error saying `&#39;NSNumber&#39; is not a subtype of &#39;CGFloat&#39;`

Round up a CGFloat in Swift

I have a pandas series `series`.  If I want to get the element-wise floor or ceiling, is there a built in method or do I have to write the function and use apply?  I ask because the data is big so I appreciate efficiency.  Also this question has not been asked with respect to the Pandas package. 

Floor or ceiling of a pandas series in python?

How would I manage to perform `math.ceil` such that a number is assigned to the next highest power of 10?

    # 0.04  -&gt;  0.1
    # 0.7   -&gt;  1
    # 1.1   -&gt;  10  
    # 90    -&gt;  100  
    # ...


My current solution is a dictionary that checks the range of the input number, but it&#39;s hardcoded and I would prefer a one-liner solution. Maybe I am missing a simple mathematical trick or a corresponding numpy function here?

Content Type	Original Author	Original Content on Stackoverflow
Question	PengOne	View Question on Stackoverflow
Solution 1 - Java	Jon Skeet	View Answer on Stackoverflow
Solution 2 - Java	Peter Lawrey	View Answer on Stackoverflow

Why does Math.ceil return a double?

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

Javascript Append Child AFTER Element

Where are all the standard Android icon resources?

Attributions