No, you appear to have a legit bug. The bug presents in JDK7 but fixed in JDK8. Your values are correctly representable as `BigDecimal`s, and should behave correctly, but don&#39;t.

Tracing through [the source code of `BigDecimal`](http://www.docjar.com/html/api/java/math/BigDecimal.java.html#2571), on line 2585, `this.precision()` is 1, and `this.scale` is `-2147483647`.  `this.precision() - this.scale` therefore overflows, and the following overflow is not handled correctly.

This bug [has been fixed](http://hg.openjdk.java.net/jdk8/jdk8/jdk/rev/216a4b93cee8) in JDK8 by [doing the subtraction in `long` arithmetic](http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/8-b132/java/math/BigDecimal.java#BigDecimal.compareMagnitude%28java.math.BigDecimal%29).

when I load my application it shows a warning message that 

&gt; &quot;Could not load the &quot;&quot; image referenced from a nib in the bundle with
&gt; identifier &quot;

 I searched and confirmed all my images. But it still shows that warning.

Could not load the &quot;&quot; image referenced from a nib in the bundle with identifier

I know its possible to create a struct via `%User{ email: &#39;blah@blah.com&#39; }`. But if I had a variable `params = %{email: &#39;blah@blah.com&#39;}` is there a way to create that struct using that variable for eg, `%User{ params }`.

This gives an error, just wondering if you can explode it or some other way?


In Elixir how do you initialize a struct with a map variable

I was testing boundary conditions on some code involving a `BigDecimal`, and I noticed that when a `BigDecimal` is initialized with the String `&quot;1e2147483647&quot;` it behaves unexpectedly. It seems to have a value between `0` and `1e-2147483647`. When I try calling `intValue()`, I get a `NegativeArraySizeException`. I should note that `2147483647` is the max value of an integer on my system. Am I doing something wrong, or is this a problem with `BigDecimal`?

    BigDecimal test = new BigDecimal(&quot;1e2147483647&quot;);
    
    test.compareTo(new BigDecimal(0));  //Returns 1
    test.compareTo(new BigDecimal(&quot;1e-2147483647&quot;));  //Returns -1
    test.intValue();  //Throws NegativeArraySizeException

Java BigDecimal Possible Overflow Bug

I was testing boundary conditions on some code involving a <code>BigDecimal</code>, and I noticed that when a <code>BigDecimal</code> is initialized with the String <code>"1e2147483647"</code> it behaves unexpectedly. It seems to have a value between <code>0</code> and <code>1e-2147483647</code>. When I try calling <code>intValue()</code>, I get a <code>NegativeArraySizeException</code>. I should note that <code>2147483647</code> is the max value of an integer on my system. Am I doing something wrong, or is this a problem with <code>BigDecimal</code>?
<pre><code class="hljs language-java">BigDecimal test = new BigDecimal("1e2147483647");

test.compareTo(new BigDecimal(0)); //Returns 1
test.compareTo(new BigDecimal("1e-2147483647")); //Returns -1
test.intValue(); //Throws NegativeArraySizeException
</code></pre>

It has generally been the case the Java source code has been forward compatible.  Until Java 8, as far as I know, both compiled classes *and* source have been forward compatible with later JDK/JVM releases.  [Update: this is not correct, see comments re &#39;enum&#39;, etc, below.]  However, with the addition of default methods in Java 8 this appears to no longer be the case.

For example, a library I have been using has an implementation of `java.util.List` which includes a `List&lt;V&gt; sort()`.  This method returns a copy of the contents of the list sorted. This library, deployed as a jar file dependency, worked fine in a project being built using JDK 1.8.

However, later I had occasion to recompile the library itself using JDK 1.8 and
I found the library no longer compiles: the `List`-implementing class with its own `sort()` method now conflicts with the Java 8 `java.util.List.sort()` default method.  The Java 8 `sort()` default method sorts the list in place (returns `void`); my library&#39;s `sort()` method - since it returns a new sorted list - has an incompatible signature.

So my basic question is:

- Doesn&#39;t JDK 1.8 introduce a forward incompatibility for Java source code due to default methods?

Also:

- Is this the first such forward incompatible change?
- Was this considered or discussed when default methods where designed and implemented?  Is it documented anywhere?
- Was the (admittedly small) inconvenience discounted versus the benefits?

The following is an example of some code that compiles and runs under 1.7 and
runs under 1.8 - but does not compile under 1.8:

    import java.util.*;
    
    public final class Sort8 {
	
        public static void main(String[] args) {
            SortableList&lt;String&gt; l = new SortableList&lt;String&gt;(Arrays.asList(args));
            System.out.println(&quot;unsorted: &quot;+l);
            SortableList&lt;String&gt; s = l.sort(Collections.reverseOrder());
            System.out.println(&quot;sorted  : &quot;+s);
        }

        public static class SortableList&lt;V&gt; extends ArrayList&lt;V&gt; {
		
            public SortableList() { super(); }
            public SortableList(Collection&lt;? extends V&gt; col) { super(col); }
		
            public SortableList&lt;V&gt; sort(Comparator&lt;? super V&gt; cmp) {
                SortableList&lt;V&gt; l = new SortableList&lt;V&gt;();
                l.addAll(this);
                Collections.sort(l, cmp);
                return l;
            }

        }

    }

The following shows this code being compiled (or failing to) and being run.


    &gt; c:\tools\jdk1.7.0_10\bin\javac Sort8.java
    
    &gt; c:\tools\jdk1.7.0_10\bin\java Sort8 this is a test
    unsorted: [this, is, a, test]
    sorted  : [this, test, is, a]
    
    &gt; c:\tools\jdk1.8.0_05\bin\java Sort8 this is a test
    unsorted: [this, is, a, test]
    sorted  : [this, test, is, a]
    
    &gt; del Sort8*.class
    
    &gt; c:\tools\jdk1.8.0_05\bin\javac Sort8.java
    Sort8.java:46: error: sort(Comparator&lt;? super V&gt;) in SortableList cannot implement sort(Comparator&lt;? super E&gt;) in List
                    public SortableList&lt;V&gt; sort(Comparator&lt;? super V&gt; cmp) {
                                           ^
      return type SortableList&lt;V&gt; is not compatible with void
      where V,E are type-variables:
        V extends Object declared in class SortableList
        E extends Object declared in interface List
    1 error

Do Java 8 default methods break source compatibility?

Why was the `Thread` class implemented as a regular class and not an **abstract** class with `run()` method being abstract.

Will it possibly introduce any problems? Or does it have any use in being this way?

Also, the `Thread.start()` method is supposed to be a very specific method **whose functionality cannot be implemented by any other class** (If I am not wrong). And hence I guess the `final` keyword would be apt for this more than any other method.

But I am able to override this method and use it as I like,

    public class Test extends Thread {
    	public static void main (String... args) {
    		Thread test = new Test();
    		test.start();
    	}
    	
    	@Override
    	public void run() {
    		System.out.println(&quot;New thread started...&quot;);
    	}
    	
    	@Override
    	public void start() {
    		System.out.println(&quot;Did anyone tell you I will spawn a new thread??&quot;);
    	}
    }

It obviously only printed,

&gt; Did anyone tell you I will spawn a new thread??

Is there any use in overriding other than confusing the engineer replacing you?

If not, why was the method not declared final in Thread class?

Why is Thread not an abstract class and start() not final?

To take advantage of the wide range of query methods included in `java.util.stream` of Jdk 8 I am attempted to design domain models where getters of relationship with `*` multiplicity (with zero or more instances ) return a `Stream&lt;T&gt;`, instead of an `Iterable&lt;T&gt;` or `Iterator&lt;T&gt;`.

My doubt is if there is any additional overhead incurred by the `Stream&lt;T&gt;` in comparison to the `Iterator&lt;T&gt;`?

So, is there any disadvantage of compromising my domain model with a `Stream&lt;T&gt;`?

Or instead, should I always return an `Iterator&lt;T&gt;` or `Iterable&lt;T&gt;`, and leave to the end-user the decision of choosing whether to use a stream, or not, by converting that iterator with the `StreamUtils`?

**Note** that returning a `Collection` is not a valid option because in this case most of the relationships are lazy and with unknown size.

Iterator versus Stream of Java 8

In Eclipse, while coding in Java and press &lt;kbd&gt;Ctrl&lt;/kbd&gt; + &lt;kbd&gt;Shift&lt;/kbd&gt; + &lt;kbd&gt;O&lt;/kbd&gt; auto import all the Classes automatically.  
In NetBeans, this is done with &lt;kbd&gt;Ctrl&lt;/kbd&gt; + &lt;kbd&gt;Shift&lt;/kbd&gt; + &lt;kbd&gt;I&lt;/kbd&gt;.

Is any way to do this in IntelliJ IDEA?

I searched an equivalent shortcut in google, StackOverflow, IntelliJ IDEA configuration and in the official IntelliJ website [Keyboard Shortcuts You Cannot Miss][1] 


  [1]: https://www.jetbrains.com/idea/help/keyboard-shortcuts-you-cannot-miss.html



Any way (or shortcut) to auto import the classes in IntelliJ IDEA like in Eclipse?

Intellij Idea 14.1.4
Mac OS X Yosemite 10.10.3 and later.
 
From the IDE:

    Import Project -&gt;
    (Chosen directory to import) -&gt;
    Import project from external model, Gradle -&gt;
    Gradle Home: /usr/local/Cellar/gradle/2.4/libexec
    Gradle JVM: Use JAVA_HOME (not defined yet)
 
From shell:

    echo $JAVA_HOME
 
    /Library/Java/JavaVirtualMachines/jdk1.8.0_45.jdk/Contents/Home
(defined in .profile: export JAVA_HOME=&quot;$(/usr/libexec/java_home -v 1.8)&quot;
 
What am I missing. I have checked other discussions in SO, for example, https://stackoverflow.com/questions/30960103/intellij-java-home-variable, but don&#39;t have Project SDK prompt. 

![][1]



  [1]: http://i.stack.imgur.com/Dt6zH.png

Intellij Idea: Importing Gradle project - getting JAVA_HOME not defined yet

I have a domain class with unitPrice set as BigDecimal data type. Now I am trying to create a method to compare price but it seems like I can&#39;t have comparison operators in BigDecimal data type. Do I have to change data type or is there other way around?

How to use comparison operators like &gt;, =, &lt; on BigDecimal

I&#39;m using BigDecimal for my numbers in my application, for example, with JPA. I did a bit of researching about the terms &#39;precision&#39; and &#39;scale&#39; but I don&#39;t understand what are they exactly.

Can anyone explain me the meaning of &#39;precision&#39; and &#39;scale&#39; for a BigDecimal value?

    @Column(precision = 11, scale = 2)

Thanks!

BigDecimal, precision and scale

I want to use assert between 2 two decimal, I use this:

    BigDecimal bd1 = new BigDecimal (1000);
    BigDecimal bd2 = new BigDecimal (1000);
    org.junit.Assert.assertSame (bd1,bd2);

but the JUnit log shows:

    expected &lt;1000&gt; was not: &lt;1000&gt;

JUnit Assert with BigDecimal

I have custom `DecimalFormat` in Edittext&#39;s addTextChangedListener method, everything is  working perfectly but when I change language (locale) my addTextChangedListener is not working.

    double answer = inputDouble * counterToDouble;
    DecimalFormat df = new DecimalFormat(&quot;##.########&quot;);
    // df=(DecimalFormat)numberFormat;

    df.setRoundingMode(RoundingMode.DOWN);
    answer = Double.parseDouble(df.format(answer));

    unicoinsAmmount.setText(String.valueOf(df.format(answer)));

I searched about my problem and found a `NumberFormat` solution:

    NumberFormat numberFormat = NumberFormat.getNumberInstance(Locale.US);

but I don&#39;t know how I can use this code.

Content Type	Original Author	Original Content on Stackoverflow
Question	DJMatch3000	View Question on Stackoverflow
Solution 1 - Java	Louis Wasserman	View Answer on Stackoverflow

Java BigDecimal Possible Overflow Bug

Java Problem Overview

Java Solutions

Solution 1 - Java

In Elixir how do you initialize a struct with a map variable

Could not load the "" image referenced from a nib in the bundle with identifier

Attributions