They are indeed quite close.
One thing that differs (and it&#39;s maybe not that clear in the javadoc actually, more visible in sourcecode) is that in doOnEach, you also get `Notification` wrappers for errors and completion event.

You can then check `isOnNext`, `isOnCompleted` or `isOnError` to check the actual kind of event you got a notification for.

So one `Action.call` to rule them all, instead of a fully fledged `Observer`

Using PostgreSQL 9.3, I want to convert the calculated values to data type `float`.

My first attempt:

    SELECT float(SUM(Seconds))/-1323 AS Averag;

Gives me this error:

&gt;     syntax error at or near &quot;SUM&quot;

My second attempt:

    SELECT to_float(SUM(Seconds))/-1323 AS Averag;

Gives me this error:

&gt;      function to_float(bigint) does not exist


Cast syntax to convert a sum to float

How do you use Webpack and AngularJS together, and how about template loading and on demand fetching of resources?

An example of a well written `webpack.config.js` file for this purpose would be very much appreciated.

All code snippets displayed here can be accessed at [this github repo][1]. Code has been generously adapted from [this packetloop git repo][2].

**webpack.config.json**



&lt;!-- language: lang-js --&gt;

    var path = require(&#39;path&#39;);
    var ResolverPlugin = require(&quot;webpack/lib/ResolverPlugin&quot;);

    var config = {
      context: __dirname,
      entry: [&#39;webpack/hot/dev-server&#39;, &#39;./app/app.js&#39;],
      output: {
        path: &#39;./build&#39;,
        filename: &#39;bundle.js&#39;
      },
      module: {
        loaders: [{
          test: /\.css$/,
          loader: &quot;style!css-loader&quot;
        }, {
          test: /\.scss$/,
          loader: &quot;style!css!sass?outputStyle=expanded&quot;
        }, {
          test: /\.jpe?g$|\.gif$|\.png$|\.svg$|\.woff$|\.ttf$/,
          loader: &quot;file&quot;
        }, {
          test: /\.html$/,
          loader: &quot;ngtemplate?relativeTo=&quot; + path.join(__dirname, &#39;app/&#39;) + &quot;!raw&quot;
        }]
      },
      // Let webpack know where the module folders are for bower and node_modules
      // This lets you write things like - require(&#39;bower/&lt;plugin&gt;&#39;) anywhere in your code base
      resolve: {
        modulesDirectories: [&#39;node_modules&#39;, &#39;lib/bower_components&#39;],
        alias: {
          &#39;npm&#39;: __dirname + &#39;/node_modules&#39;,
          &#39;vendor&#39;: __dirname + &#39;/app/vendor/&#39;,
          &#39;bower&#39;: __dirname + &#39;/lib/bower_components&#39;
        }
      },
      plugins: [
        // This is to help webpack know that it has to load the js file in bower.json#main
        new ResolverPlugin(
          new ResolverPlugin.DirectoryDescriptionFilePlugin(&quot;bower.json&quot;, [&quot;main&quot;])
        )
      ]
    };

    module.exports = config;



To import AngularJS into the main `app.js` you do the following:

**app/vendor/angular.js**



&lt;!-- language: lang-js --&gt;

    &#39;use strict&#39;;

    if (!global.window.angular) {
      require(&#39;bower/angular/angular&#39;);
    }
    var angular = global.window.angular;
    module.exports = angular;



And then use it in `app.js` like so,

**app.js**



&lt;!-- language: lang-js --&gt;


    ...
    var angular = require(&#39;vendor/angular&#39;);

    // Declare app level module
    var app = angular.module(&#39;myApp&#39;, []);

    ...



Is the following correct? Is there an easier way to do this? I&#39;ve seen a few (not a lot by any standards) posts which listed another method.

From [this reddit post comment][4]

    // Add to webpack.config.js#module#loaders array
        {
          test: /[\/]angular\.js$/,
          loader: &quot;exports?angular&quot;
        }



  There is also another plugin which is in development right now, at [stackfull/angular-seed][5]. It seems to be in the right direction, but is really really hard to use right now.

Webpack is way awesome, but the lack of documentation and samples are killing it.


  [1]: https://github.com/jibiabraham/faber-seed
  [2]: https://github.com/packetloop/angular-webpack
  [3]: https://material.angularjs.org/#/
  [4]: http://www.reddit.com/r/angularjs/comments/252z6x/what_are_best_practices_for_bundling_angularjs/chdidgy
  [5]: https://github.com/stackfull/angular-seed

What is the best practice for importing angularjs using webpack?

In which cases I should use doOnNext, and in which cases
doOnEach?

     .doOnEach(new Action1&lt;Notification&lt;? super MessageProfile&gt;&gt;() {
                    @Override
                    public void call(Notification&lt;? super MessageProfile&gt; notification) {

                    }
                })
     .doOnNext(new Action1&lt;MessageProfile&gt;() {
                    @Override
                    public void call(MessageProfile profile) {
                        messageProfileDao.save(profile);
                    }
                })

This looks like the both operators have the same effect.

RxJava: difference between doOnNext and doOnEach

In which cases I should use doOnNext, and in which cases
doOnEach?
<pre><code class="hljs language-typescript"> .doOnEach(new Action1&#x3C;Notification&#x3C;? super MessageProfile>>() {
 @Override
 public void call(Notification&#x3C;? super MessageProfile> notification) {

 }
 })
 .doOnNext(new Action1&#x3C;MessageProfile>() {
 @Override
 public void call(MessageProfile profile) {
 messageProfileDao.save(profile);
 }
 })
</code></pre>
This looks like the both operators have the same effect.

Edit: Well, apparently it was too opinion based, so let me try to reword it more precisely - 

Are there any clear caveats or drawbacks of using LocalDate, LocalTime etc. in a Java code that does not need any backwards compatibility, and if so - what are they?

I&#39;m looking for things like &quot;Current EE libraries X and Y don&#39;t work correctly with LocalDate&quot; or &quot;This very useful pattern is broken with LocalTime&quot; et cetera.


----------
(here is the original question for reference)

With Java 8, a new time API is introduced, namely the java.time.LocalDate etc., but java.util.Date is not marked as deprecated.

I am writing a new project, which does not need to be backwards compatible. Should I only use LocalDate, LocalDateTime etc.? Are there any drawbacks to using this new API as opposed to the good old java.util.Date?

In particular - I am going to be working mainly with JDBC. From what I have seen JDBC handles java.util.Date well. Is it as well suited for LocalDate?


Searching yielded lots of sites telling how to convert from one format to the other, but no definitive answer as to should new code use the old API.

Thanks.

Should I use java.util.Date or switch to java.time.LocalDate

Does anyone know how to convert ByteBuffer to byte[] array? I need to get byte array from my `ByteBuffer`. When I run `bytebuffer.hasArray()` it returns no. Every question I looked so far is converting byte array to byteBuffer, but I need it other way around.
Thank you.

Convert ByteBuffer to byte array java

In Java 8 you can return an `Optional` instead of a `null`.  Java 8 documentation says that an Optional is &quot;A container object which may or may not contain a non-null value. If a value is present, isPresent() will return true and get() will return the value.&quot;

In practice, why is this useful?
Also, is there any case where using `null` would be preferred? What about performance?

Optional vs. null. What is the purpose of Optional in Java 8?

Java IO has [File.deleteOnExit()][1], which is a method that deletes the file it is called on during normal termination of the JVM. I&#39;ve found this to be very useful for cleaning up temporary files, especially during unit tests.

However, I don&#39;t see a method by the same name in Java NIO&#39;s [Files][2] class. I am aware that I can do `path.toFile().deleteOnExit()`, but I&#39;d like to know if there is an alternative using NIO.

Is there an alternative? If not, why is there not one?


  [1]: http://docs.oracle.com/javase/7/docs/api/java/io/File.html#deleteOnExit()
  [2]: http://docs.oracle.com/javase/7/docs/api/java/nio/file/Files.html

Alternative to File.deleteOnExit() in Java NIO?

    sc = new Scanner(new File(dataFile));
    sc.useDelimiter(&quot;,|\r\n&quot;);

I don&#39;t understand how delimiter works, can someone explain this in layman terms?

How do I use a delimiter with Scanner.useDelimiter in Java?

I would like to know how to ignore exceptions and continue infinite stream (in my case stream of locations)?

I&#39;m fetching current user position (using [Android-ReactiveLocation](https://github.com/mcharmas/Android-ReactiveLocation)) and then sending them to my API (using [Retrofit](http://square.github.io/retrofit/)). 

In my case, when exception occurs during network call (e.g. timeout) `onError` method is invoked and stream stops itself. How to avoid it?

Activity:

    private RestService mRestService;
    private Subscription mSubscription;
    private LocationRequest mLocationRequest = LocationRequest.create()
                .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
                .setInterval(100);
    ...
    private void start() {
        mRestService = ...;
        ReactiveLocationProvider reactiveLocationProvider = new ReactiveLocationProvider(this);
        mSubscription = reactiveLocationProvider.getUpdatedLocation(mLocationRequest)
                .buffer(50)
                .flatMap(locations -&gt; mRestService.postLocations(locations)) // can throw exception
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe();
    }

RestService:

    public interface RestService {
        @POST(&quot;/.../&quot;)
        Observable&lt;Response&gt; postLocations(@Body List&lt;Location&gt; locations);
    }

   


How to ignore error and continue infinite stream?

Given a list of cars (`List&lt;Car&gt; cars`), I can do:

    Observable.just(cars); //returns an Observable that emits one List&lt;Car&gt;
    Observable.from(cars); //returns an Observable that emits a squence of Car

Is there a way I can go from an `Observable` of a `List&lt;Car&gt;` to a sequence of `Observable&lt;Car&gt;`?

Something like a `from` without parameters

    Obserable.just(cars).from()

Convert Observable&lt;List&lt;Car&gt;&gt; to a sequence of Observable&lt;Car&gt; in RxJava

Are Java 8 streams similar to RxJava observables?

Java 8 stream definition:

&gt; Classes in the new `java.util.stream` package provide a Stream API to
&gt; support functional-style operations on streams of elements.




Difference between Java 8 streams and RxJava observables

I am having a lot of trouble understanding the zip operator in RxJava for my android project. 
Problem
I need to be able to send a network request to upload a video
Then i need to send a network request to upload a picture to go with it
finally i need to add a description and use the responses from the previous two requests to upload the location urls of the video and picture along with the description to my server.

I assumed that the zip operator would be perfect for this task as I understood we could take the response of two observables (video and picture requests) and use them for my final task.
But I cant seem to get this to occur how I envision it.

I am looking for someone to answer how this can be done conceptually with a bit of psuedo code.
Thank you

Rxjava Android how to use the Zip operator

In RxJava there are [5 different schedulers][1] to choose from:

&gt; 1. **immediate()**: Creates and returns a Scheduler that executes work immediately on the current thread.
&gt;
&gt; 2. **trampoline()**: Creates and returns a Scheduler that queues work on the current thread to be executed after the current work completes.
&gt;
&gt; 3. **newThread()**: Creates and returns a Scheduler that creates a new Thread for each unit of work.
&gt;
&gt; 4. **computation()**: Creates and returns a Scheduler intended for computational work. This can be used for event-loops, processing callbacks and other computational work. Do not perform IO-bound work on this scheduler. Use Schedulers.**io()** instead.
&gt;
&gt; 5. **io()**: Creates and returns a Scheduler intended for IO-bound work.
The implementation is backed by an Executor thread-pool that will grow as needed. This can be used for asynchronously performing blocking IO. Do not perform computational work on this scheduler. Use Schedulers.**computation()** instead.

## Questions: ##
The first 3 schedulers are pretty self explanatory; however, I&#39;m a little confused about **computation** and **io**.

 1. What exactly is &quot;IO-bound work&quot;? Is it used for dealing with streams (`java.io`) and files (`java.nio.files`)? Is it used for database queries? Is it used for downloading files or accessing REST APIs?
 2. How is **computation()** different from **newThread()**? Is it that all **computation()** calls are on a single (background) thread instead of a new (background) thread each time?
 3. Why is it bad to call **computation()** when doing IO work?
 4. Why is it bad to call **io()** when doing computational work?


  [1]: http://reactivex.io/RxJava/javadoc/rx/schedulers/Schedulers.html

Content Type	Original Author	Original Content on Stackoverflow
Question	VasyaFromRussia	View Question on Stackoverflow
Solution 1 - Java	Simon Baslé	View Answer on Stackoverflow

RxJava: difference between doOnNext and doOnEach

Java Problem Overview

Java Solutions

Solution 1 - Java

What is the best practice for importing angularjs using webpack?

Cast syntax to convert a sum to float

Attributions