With Java 7 you can now directly do a null safe equals:

[Objects.equals(x, y)][1]

(The Jakarta Commons library ObjectUtils.equals() has become obsolete with Java 7)

  [1]: http://docs.oracle.com/javase/7/docs/api/java/util/Objects.html

if by some chance you are have access to the Jakarta Commons library there is [ObjectUtils.equals()][1] and lots of other useful functions.


  [1]: http://commons.apache.org/lang/apidocs/org/apache/commons/lang3/ObjectUtils.html#equals(java.lang.Object,%20java.lang.Object)

EDIT: misread the question initially

If you are using &lt;1.7 but have Guava available: [`Objects.equal(x, y)`](http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/base/Objects.html#equal(java.lang.Object,%20java.lang.Object))

Is there a way to test the type of an element in JavaScript? 

The answer may or may not require the prototype library, however the following setup does make use of the library.

    function(event) {
      var element = event.element();
      // if the element is an anchor
      ...
      // if the element is a td
      ...
    }

Testing the type of a DOM element in JavaScript

Is there a way in C# to play audio (for example, MP3) direcly from a [System.IO.Stream][2] that for instance was returend from a WebRequest without saving the data temporarily to the disk?

---

### Solution with [NAudio][1]

With the help of [NAudio][1] 1.3 it is possible to:

1. Load an MP3 file from a URL into a MemoryStream
2. Convert MP3 data into wave data after it was completely loaded
3. Playback the wave data using [NAudio][1]&#39;s WaveOut class

It would have been nice to be able to even play a half loaded MP3 file, but this seems to be impossible due to the [NAudio][1] library design.

And this is the function that will do the work:

        public static void PlayMp3FromUrl(string url)
        {
            using (Stream ms = new MemoryStream())
            {
                using (Stream stream = WebRequest.Create(url)
                    .GetResponse().GetResponseStream())
                {
                    byte[] buffer = new byte[32768];
                    int read;
                    while ((read = stream.Read(buffer, 0, buffer.Length)) &gt; 0)
                    {
                        ms.Write(buffer, 0, read);
                    }
                }

                ms.Position = 0;
                using (WaveStream blockAlignedStream =
                    new BlockAlignReductionStream(
                        WaveFormatConversionStream.CreatePcmStream(
                            new Mp3FileReader(ms))))
                {
                    using (WaveOut waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
                    {
                        waveOut.Init(blockAlignedStream);
                        waveOut.Play();                        
                        while (waveOut.PlaybackState == PlaybackState.Playing )                        
                        {
                            System.Threading.Thread.Sleep(100);
                        }
                    }
                }
            }
        }

  [1]: https://github.com/naudio/NAudio
  [2]: http://msdn.microsoft.com/en-us/library/system.io.stream%28v=vs.110%29.aspx

Play audio from a stream using C#

To save some typing and clarify my code, is there a standard version of the following method?

    public static boolean bothNullOrEqual(Object x, Object y) {
      return ( x == null ? y == null : x.equals(y) );
    }

Is there a Java standard &quot;both null or equal&quot; static method?

To save some typing and clarify my code, is there a standard version of the following method?
<pre><code class="hljs language-typescript">public static boolean bothNullOrEqual(Object x, Object y) {
 return ( x == null ? y == null : x.equals(y) );
}
</code></pre>

I have a production server running with the following flag: -**XX:+HeapDumpOnOutOfMemoryError**

Last night it generated a java-38942.hprof file when our server encountered a heap error. It turns out that the developers of the system knew of the flag but no way to get any useful information from it.

Any ideas?

How do I analyze a .hprof file?

I ran into an interesting (and very frustrating) issue with the `equals()` method today which caused what I thought to be a well tested class to crash and cause a bug that took me a very long time to track down. 

Just for completeness, I wasn&#39;t using an IDE or debugger - just good old fashioned text editor and System.out&#39;s. Time was very limited and it was a school project.

Anyhow - 

I was developing a basic shopping cart which could contain an _`ArrayList` of `Book` objects_. In order to implement the `addBook()`, `removeBook()`, and `hasBook()` methods of the Cart, I wanted to check if the `Book` already existed in the `Cart`. So off I go -

    public boolean equals(Book b) {
        ... // More code here - null checks
        if (b.getID() == this.getID()) return true;
        else return false;
    }

All works fine in testing. I create 6 objects and fill them with data. Do many adds, removes, has() operations on the `Cart` and everything works fine. I read that you can _either have `equals(TYPE var)` or `equals(Object o) { (CAST) var }`_ but assumed that since it was working, it didn&#39;t matter too much.


Then I ran into a problem - I needed to create a `Book` object with _only_ the `ID` in it from within the Book class. No other data would be entered into it. Basically the following:

    public boolean hasBook(int i) {
        Book b = new Book(i);
        return hasBook(b);
    }

    public boolean hasBook(Book b) {
        // .. more code here
        return this.books.contains(b);
    }

All of a sudden, the `equals(Book b)` method no longer works. This took a VERY long time to track down without a good debugger and assuming the `Cart` class was properly tested and correct. After swaapping the `equals()` method to the following:

    public boolean equals(Object o) {
        Book b = (Book) o;
        ... // The rest goes here   
    }

Everything began to work again. Is there a reason the method decided not to take the Book parameter even though it clearly &lt;b&gt; was &lt;/b&gt; a `Book` object? The only difference seemed to be it was instantiated from within the same class, and only filled with one data member. I&#39;m very very confused. Please, shed some light?

Overriding the java equals() method - not working?

When using JDBC, I often come across constructs like  

    ResultSet rs = ps.executeQuery();
    while (rs.next()) {
        int id = rs.getInt(1);
        // Some other actions
    }

I asked myself (and authors of code too) why not to use labels for retrieving column values:  

    int id = rs.getInt(&quot;CUSTOMER_ID&quot;);

The best explanation I&#39;ve heard is something concerning performance. But actually, does it make processing extremely fast? I don&#39;t believe so, though I have never performed measurements. Even if retrieving by label would be a bit slower, nevertheless, it provide better readability and flexibility, in my opinion.  
So could someone give me good explanation of avoiding to retrieve column values by column index instead of column label? What are pros and cons of both approaches (maybe, concerning certain DBMS)? 

ResultSet: Retrieving column values by index versus retrieving by label

Would it suppose any difference regarding overhead to write an import loading all the types within one package (`import java.*`); than just a specific type (i.e. `import java.lang.ClassLoader`)? Would the second one be a more advisable way to use than the other one?

Import package.* vs import package.SpecificType

I know this is a bit of a newbie question, but are there equivalents to C#&#39;s string operations in Java?

Specifically, I&#39;m talking about `String.Format` and `String.Join`.

Java equivalents of C# String.Format() and String.Join()

I know that it _does_ consider &#39;&#160;&#39; as `NULL`, but that doesn&#39;t do much to tell me _why_ this is the case.  As I understand the SQL specifications, &#39;&#160;&#39; is not the same as `NULL` -- one is a valid datum, and the other is indicating the absence of that same information.

Feel free to speculate, but please indicate if that&#39;s the case.  If there&#39;s anyone from Oracle who can comment on it, that&#39;d be fantastic!

Why does Oracle 9i treat an empty string as NULL?

I am looking for a concise way to check a value to see if it is nil or zero.  Currently I am doing something like:

    if (!val || val == 0)
      # Is nil or zero
    end

But this seems very clumsy.

Best ruby idiom for &quot;nil or zero&quot;

I&#39;ve been searching a lot but couldn&#39;t find a solution. How do you deal with a DateTime that should be able to contain an uninitialized value (equivalent to null)? I have a class which might have a DateTime property value set or not. I was thinking of initializing the property holder to DateTime.MinValue, which then could easily be checked. I guess this is a quite common question, how do you do that?

DateTime &quot;null&quot; value

If I want to check for the null string I would do

    [ -z $mystr ]

but what if I want to check whether the variable has been defined at all? Or is there no distinction in Bash scripting?




How to tell if a string is not defined in a Bash shell script

What exactly does null do performance and storage (space) wise in MySQL?

For example:

TINYINT: 1 Byte
TINYINT w/NULL 1 byte + somehow stores NULL?

NULL in MySQL (Performance &amp; Storage)

A strict equality operator will tell you if two object **types** are equal. However, is there a way to tell if two objects are equal, **much like the hash code** value in Java?

Stack Overflow question *[Is there any kind of hashCode function in JavaScript?][1]* is similar to this question, but requires a more academic answer. The scenario above demonstrates why it would be necessary to have one, and I&#39;m wondering if there is any **equivalent solution**.

  [1]: https://stackoverflow.com/questions/194846


How to determine equality for two JavaScript objects?

When using SQL, are there any benefits of using `=` in a `WHERE` clause instead of `LIKE`?

Without any special operators, `LIKE` and `=` are the same, right?

Equals(=) vs. LIKE

I&#39;m using Eclipse to generate `.equals()` and `.hashCode()`, and there is an option labeled &quot;Use &#39;instanceof&#39; to compare types&quot;.  The default is for this option to be unchecked and use `.getClass()` to compare types.  Is there any reason I should prefer `.getClass()` over `instanceof`?

Without using `instanceof`:

    if (obj == null)
      return false;
    if (getClass() != obj.getClass())
      return false;

Using `instanceof`:

    if (obj == null)
      return false;
    if (!(obj instanceof MyClass))
      return false;

I usually check the `instanceof` option, and then go in and remove the &quot;`if (obj == null)`&quot; check. (It is redundant since null objects will always fail `instanceof`.)  Is there any reason that&#39;s a bad idea?

Any reason to prefer getClass() over instanceof when generating .equals()?

Background
---------------
I am using interface-based programming on a current project and have run into a problem when overloading operators (specifically the Equality and Inequality operators).

---------------
Assumptions
---------------
 - I&#39;m using C# 3.0, .NET 3.5 and Visual Studio 2008
 
UPDATE - The Following Assumption was False!
  
- Requiring all comparisons to use Equals rather than operator== is not a viable solution, especially when passing your types to libraries (such as Collections).

The reason I was concerned about requiring Equals to be used rather than operator== is that I could not find anywhere in the .NET guidelines that it stated it would use Equals rather than operator== or even suggest it. However, after re-reading [Guidelines for Overriding Equals and Operator==][3] I have found this:

&gt; By default, the operator == tests for reference equality by determining whether two references indicate the same object. Therefore, reference types do not have to implement operator == in order to gain this functionality. When a type is immutable, that is, the data that is contained in the instance cannot be changed, overloading operator == to compare value equality instead of reference equality can be useful because, as immutable objects, they can be considered the same as long as they have the same value. It is not a good idea to override operator == in non-immutable types.


and this [Equatable&lt;T&gt; Interface][4]

&gt; The IEquatable&lt;T&gt; interface is used by generic collection objects such as Dictionary&lt;TKey, TValue&gt;, List&lt;T&gt;, and LinkedList&lt;T&gt; when testing for equality in such methods as Contains, IndexOf, LastIndexOf, and Remove. It should be implemented for any object that might be stored in a generic collection.


---------------
Contraints
---------------
 - Any solution must not require casting the objects from their interfaces to their concrete types.

---------------
Problem
---------------
 - When ever both sides of the operator== are an interface, no operator== overload method signature from the underlying concrete types will match and thus the default Object operator== method will be called.
 - When overloading an operator on a class, at least one of the parameters of the binary operator must be the containing type, otherwise a compiler error is generated (Error BC33021 [http://msdn.microsoft.com/en-us/library/watt39ff.aspx][1])
 - It&#39;s not possible to specify implementation on an interface


See Code and Output below demonstrating the issue.

--------------
Question
--------------
**How do you provide proper operator overloads for your classes when using interface-base programming?**

--------------
References
--------------
[== Operator (C# Reference)][2]


For predefined value types, the equality operator (==) returns true if the values of its operands are equal, false otherwise. For reference types other than string, == returns true if its two operands refer to the same object. For the string type, == compares the values of the strings.

--------------
See Also
--------------

--------------
Code
--------------
    using System;

    namespace OperatorOverloadsWithInterfaces
    {
        public interface IAddress : IEquatable&lt;IAddress&gt;
        {
            string StreetName { get; set; }
            string City { get; set; }
            string State { get; set; }
        }

        public class Address : IAddress
        {
            private string _streetName;
            private string _city;
            private string _state;

            public Address(string city, string state, string streetName)
            {
                City = city;
                State = state;
                StreetName = streetName;
            }

            #region IAddress Members

            public virtual string StreetName
            {
                get { return _streetName; }
                set { _streetName = value; }
            }

            public virtual string City
            {
                get { return _city; }
                set { _city = value; }
            }

            public virtual string State
            {
                get { return _state; }
                set { _state = value; }
            }

            public static bool operator ==(Address lhs, Address rhs)
            {
                Console.WriteLine(&quot;Address operator== overload called.&quot;);
                // If both sides of the argument are the same instance or null, they are equal
                if (Object.ReferenceEquals(lhs, rhs))
                {
                    return true;
                }

                return lhs.Equals(rhs);
            }

            public static bool operator !=(Address lhs, Address rhs)
            {
                return !(lhs == rhs);
            }

            public override bool Equals(object obj)
            {
                // Use &#39;as&#39; rather than a cast to get a null rather an exception
                // if the object isn&#39;t convertible
                Address address = obj as Address;
                return this.Equals(address);
            }

            public override int GetHashCode()
            {
                string composite = StreetName + City + State;
                return composite.GetHashCode();
            }

            #endregion

            #region IEquatable&lt;IAddress&gt; Members

            public virtual bool Equals(IAddress other)
            {
                // Per MSDN documentation, x.Equals(null) should return false
                if ((object)other == null)
                {
                    return false;
                }

                return ((this.City == other.City)
                    &amp;&amp; (this.State == other.State)
                    &amp;&amp; (this.StreetName == other.StreetName));
            }

            #endregion
        }

        public class Program
        {
            static void Main(string[] args)
            {
                IAddress address1 = new Address(&quot;seattle&quot;, &quot;washington&quot;, &quot;Awesome St&quot;);
                IAddress address2 = new Address(&quot;seattle&quot;, &quot;washington&quot;, &quot;Awesome St&quot;);

                functionThatComparesAddresses(address1, address2);

                Console.Read();
            }

            public static void functionThatComparesAddresses(IAddress address1, IAddress address2)
            {
                if (address1 == address2)
                {
                    Console.WriteLine(&quot;Equal with the interfaces.&quot;);
                }

                if ((Address)address1 == address2)
                {
                    Console.WriteLine(&quot;Equal with Left-hand side cast.&quot;);
                }

                if (address1 == (Address)address2)
                {
                    Console.WriteLine(&quot;Equal with Right-hand side cast.&quot;);
                }

                if ((Address)address1 == (Address)address2)
                {
                    Console.WriteLine(&quot;Equal with both sides cast.&quot;);
                }
            }
        }
    }

--------------
Output
--------------
    Address operator== overload called
    Equal with both sides cast.

  [1]: http://msdn.microsoft.com/en-us/library/watt39ff.aspx
  [2]: http://msdn.microsoft.com/en-us/library/53k8ybth.aspx
  [3]: http://msdn.microsoft.com/en-us/library/ms173147.aspx
  [4]: http://msdn.microsoft.com/en-us/library/ms131187.aspx

Content Type	Original Author	Original Content on Stackoverflow
Question	Chris Conway	View Question on Stackoverflow
Solution 1 - Java	Kdeveloper	View Answer on Stackoverflow
Solution 2 - Java	Matt	View Answer on Stackoverflow
Solution 3 - Java	Sam Berry	View Answer on Stackoverflow

Is there a Java standard "both null or equal" static method?

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

Solution 3 - Java

Play audio from a stream using C#

Testing the type of a DOM element in JavaScript

Attributions