I found this code to find duplicates in [SO][1] post here.
but I dont understand what this line means `int mid = (low + high) &gt;&gt;&gt; 1;`

    private static int findDuplicate(int[] array) {
    	    int low = 0;
    	    int high = array.length - 1;
    
    	    while (low &lt;= high) {
    	        int mid = (low + high) &gt;&gt;&gt; 1;
    	        System.out.println(mid);
    	        int midVal = array[mid];
    
    	        if (midVal == mid)
    	            low = mid + 1;
    	        else
    	            high = mid - 1;
    	    }
    	    return high;
    	}


  [1]: https://stackoverflow.com/questions/12372385/binary-search-olog-n-algorithm-to-find-duplicate-in-sequential-list?rq=1

what does &quot;&gt;&gt;&gt;&quot; mean in java?

I&#39;m trying to determine the type of a field on an object. I don&#39;t know the type of the object when it is passed to me but I need to find fields which are `long`s. It is easy enough to distinguish the boxed `Long`s but the primitive `long` seems more difficult.

I *can* make sure that the objects passed to me only have `Longs`, not the primitives, but I&#39;d rather not. So what I have is:

    for (Field f : o.getClass().getDeclaredFields()) {
        Class&lt;?&gt; clazz = f.getType();
        if (clazz.equals(Long.class)) {
            // found one -- I don&#39;t get here for primitive longs
        }
    }

A hacky way, which seems to work, is this:

    for (Field f : o.getClass().getDeclaredFields()) {
        Class&lt;?&gt; clazz = f.getType();
        if (clazz.equals(Long.class) ||  clazz.getName().equals(&quot;long&quot;)) {
            // found one
        }
    }

I&#39;d really like a cleaner way to do this if there is one. If there is no better way then I think that requiring the objects I receive to only use `Long` (not `long`) would be a better API.

Any ideas?

Check type of primitive field

I can create a literal long by appending an L to the value; why can&#39;t I create a literal short or byte in some similar way? Why do I need to use an int literal with a cast?

And if the answer is &quot;Because there was no short literal in C&quot;, then why are there no short literals in C?

This doesn&#39;t actually affect my life in any meaningful way; it&#39;s easy enough to write (short) 0 instead of 0S or something. But the inconsistency makes me curious; it&#39;s one of those things that bother you when you&#39;re up late at night. Someone at some point made a design decision to make it possible to enter literals for some of the primitive types, but not for all of them. Why?

Why are there no byte or short literals in Java?

If a method has a local variable `i`:

    int i = 10;

and then I assign a new value:

    i = 11;

Will this allocate a new memory location? Or just replace the original value?

Does this mean that primitives are immutable?

Are Java primitives immutable?

I need to make some reflective method calls in Java. Those calls will include methods that have arguments that are primitive types (int, double, etc.). The way to specify such types when looking up the method reflectively is int.class, double.class, etc.

The challenge is that I am accepting input from an outside source that will specify the types dynamically. Therefore, I need to come up with these Class references dynamically as well. Imagine a delimited file a list of method names with lists of parameter types:

    doSomething int double
    doSomethingElse java.lang.String boolean

If the input was something like `java.lang.String`, I know I could use `Class.forName(&quot;java.lang.String&quot;)` to that Class instance back. Is there any way to use that method, or another, to get the primitive type Classes back?

**Edit:**
Thanks to all the respondents. It seems clear that there is no built-in way to cleanly do what I want, so I will settle for reusing the `ClassUtils` class from the Spring framework. It seems to contain a replacement for Class.forName() that will work with my requirements.

Dynamically find the class that represents a primitive Java type

Why do generics in Java work with classes but not with primitive types?

For example, this works fine:

    List&lt;Integer&gt; foo = new ArrayList&lt;Integer&gt;();

but this is not allowed:

    List&lt;int&gt; bar = new ArrayList&lt;int&gt;();








Why don&#39;t Java Generics support primitive types?

I have a class that I want to use to store &quot;properties&quot; for another class. These properties simply have a name and a value. Ideally, what I would like is to be able to add _typed_ properties, so that the &quot;value&quot; returned is always of the type that I want it to be.

The type should always be a primitive. This class subclasses an abstract class which basically stores the name and value as string. The idea being that this subclass will add some type-safety to the base class (as well as saving me on some conversion).

So, I have created a class which is (roughly) this:

    public class TypedProperty&lt;DataType&gt; : Property
    {
        public DataType TypedValue
        {
            get { // Having problems here! }
            set { base.Value = value.ToString();}
        }
    }

So the question is:

**Is there a &quot;generic&quot; way to convert from string back to a primitive?**

I can&#39;t seem to find any generic interface that links the conversion across the board (something like _ITryParsable_ would have been ideal!).





Generic type conversion FROM string

As of Java 1.5, you can pretty much interchange `Integer` with `int` in many situations.

However, I found a potential defect in my code that surprised me a bit.

The following code:

    Integer cdiCt = ...;
    Integer cdsCt = ...;
    ...
    if (cdiCt != null &amp;&amp; cdsCt != null &amp;&amp; cdiCt != cdsCt)
        mismatch = true;

appeared to be incorrectly setting mismatch when the values were equal, although I can&#39;t determine under what circumstances. I set a breakpoint in Eclipse and saw that the `Integer` values were both 137, and I inspected the boolean expression and it said it was false, but when I stepped over it, it was setting mismatch to true.

Changing the conditional to:

    if (cdiCt != null &amp;&amp; cdsCt != null &amp;&amp; !cdiCt.equals(cdsCt))

fixed the problem.

Can anyone shed some light on why this happened? So far, I have only seen the behavior on my localhost on my own PC. In this particular case, the code successfully made it past about 20 comparisons, but failed on 2. The problem was consistently reproducible.

If it is a prevalent problem, it should be causing errors on our other environments (dev and test), but so far, no one has reported the problem after hundreds of tests executing this code snippet.

Is it still not legitimate to use `==` to compare two `Integer` values?

In addition to all the fine answers below, the following stackoverflow link has quite a bit of additional information. It actually would have answered my original question, but because I didn&#39;t mention autoboxing in my question, it didn&#39;t show up in the selected suggestions:

[Why can&#39;t the compiler/JVM just make autoboxing “just work”?][1]

  [1]: https://stackoverflow.com/questions/2602636/why-cant-the-compiler-jvm-just-make-autoboxing-just-work

Java: Integer equals vs. ==

Since Java 5, we&#39;ve had boxing/unboxing of primitive types so that `int` is wrapped to be `java.lang.Integer`, and so and and so forth. 

I see a lot of new Java projects lately (that _definitely_ require a JRE of at least version 5, if not 6) that are using `int` rather than `java.lang.Integer`, though it&#39;s much more convenient to use the latter, as it has a few helper methods for converting to `long` values et al. 

Why do some __still__ use primitive types in Java? Is there any tangible benefit?

Why do people still use primitive types in Java?

In C++, I enjoyed having access to a 64 bit unsigned integer, via `unsigned long long int`, or via `uint64_t`. Now, in Java longs are 64 bits, I know. However, they are signed.

Is there an unsigned long (long) available as a Java primitive? How do I use it?

Java equivalent of unsigned long long?

When adding `&#39;a&#39; + &#39;b&#39;` it produces 195. Is the output datatype `char` or `int`?


In Java, is the result of the addition of two chars an int or a char?

How can I cast a Java object into a boolean primitive 

I tried like below but it doesn&#39;t work

    boolean di = new Boolean(someObject).booleanValue();

&gt;The constructor Boolean(Object) is undefined

Please advise.

How to cast Object to boolean?

There are related questions, such as [How can I pass in 2 parameters to a AsyncTask class? ][1], but I ran into the difficulty of trying in vain to pass multiple primitives as parameters to an AsyncTask, so I want to share what I discovered. This subtlety is not captured in the existing questions and answers, so I want to help out anyone who runs into the same problem as I did and save them the pain.

The question is this: I have multiple *primitive* parameters (e.g. two longs) that I want to pass to an AsyncTask to be executed in the background--how can it be done? (My answer...after struggling with this for awhile...can be found below.)


  [1]: https://stackoverflow.com/questions/5546049/how-can-i-pass-in-2-parameters-to-a-asynctask-class

How can you pass multiple primitive parameters to AsyncTask?

On this site they say there are 10 LISP primitives. 
The primitives are: `atom, quote, eq, car, cdr, cons, cond, lambda, label, apply`.

http://hyperpolyglot.wikidot.com/lisp#ten-primitives 

Stevey reckons there are seven (or five):

&gt; Its part of the purity of the idea of LISP: you only need the seven (or is 
&gt; it five?) primitives to build the full machine.
http://steve-yegge.blogspot.com/2006/04/lisp-is-not-acceptable-lisp.html 

What is the minimum number of primitives to build a LISP machine (ie something that can run an eval/value function on LISP code)? (And which ones are they?)

(I can understand you could live without `atom, label and apply`)

How many primitives does it take to build a LISP machine? Ten, seven or five?

I have a question about the primitive type `short` in Java. I am using JDK 1.6. 

If I have the following: 

    short a = 2;
    short b = 3;
    short c = a + b;

the compiler does not want to compile - it says that it &quot;cannot convert from int to short&quot; and suggests that I make a cast to `short`, so this:

    short c = (short) (a + b);

really works. But my question is why do I need to cast? The values of a and b are in the range of `short` - the range of short values is {-32,768, 32767}.
I also need to cast when I want to perform the operations -, *, / (I haven&#39;t checked for others).

If I do the same for primitive type `int`, I do not need to cast aa+bb to `int`. The following works fine:

    int aa = 2;
    int bb = 3;
    int cc = aa +bb;

I discovered this while designing a class where I needed to add two variables of type short, and the compiler wanted me to make a cast. If I do this with two variables of type `int`, I don&#39;t need to cast. 

A small remark: the same thing also happens with the primitive type `byte`. So, this works:

    byte a = 2;
    byte b = 3;
    byte c = (byte) (a + b);

but this not:

    byte a = 2;
    byte b = 3;
    byte c = a + b;

For `long`, `float`, `double`, and `int`, there is no need to cast. Only for `short` and `byte` values. 

Primitive type &#39;short&#39; - casting in Java

This is a past exam question and I was wondering what a primitive type and reference type are first off?
With an array I know the a reference type is where the array is composed of objects or variables, but a primitive type is where you would create the array with just int or strings. (right?)

How do you think you would answer the question on the test and be given good credit? Without really referring directly to an primitive ARRAY type... Is there a way to do it without that? Or do you think it would be fine to just explain it with the array.

What&#39;s the difference between primitive and reference types?

**Is there a way to enforce/limit the types that are passed to primitives?** _(bool, int, string, etc.)_

Now, I know you can limit the generic type parameter to a type or interface implementation via the _where_ clause. However, this doesn&#39;t fit the bill for primitives (AFAIK) because they do not all have a common ground (apart from _object_ before someone says! :P).

So, my current thoughts are to just grit my teeth and do a big _switch_ statement and throw an _ArgumentException_ on failure.

_ _ _
**EDIT 1:**

Just to clarify:

The code definition should be like this:

    public class MyClass&lt;GenericType&gt; ....

And instantiation:

    MyClass&lt;bool&gt; = new MyClass&lt;bool&gt;(); // Legal
    MyClass&lt;string&gt; = new MyClass&lt;string&gt;(); // Legal
    MyClass&lt;DataSet&gt; = new MyClass&lt;DataSet&gt;(); // Illegal
    MyClass&lt;RobsFunkyHat&gt; = new MyClass&lt;RobsFunkyHat&gt;(); // Illegal (but looks awesome!)

_ _ _
**EDIT 2** 

@Jon Limjap - Good point, and something I was already considering. I&#39;m sure there is a generic method that can be used to determine if the type is of a value or reference type.

This could be useful in instantly removing a lot of the objects I don&#39;t want to deal with (but then you need to worry about the structs that are used such as _Size_ ). Interesting problem no? :)

Here it is:

    where T: struct

Taken from [MSDN](http://msdn.microsoft.com/en-us/library/d5x73970.aspx).

----------

I&#39;m curious. Could this be done in .NET 3.x using extension methods? Create an interface, and implement the interface in the extension methods (which would probably be cleaner than a bit fat switch). Plus if you then need to later extend to any lightweight custom types, they can also implement the same interface, with no changes required to the base code.

What do you guys think?

The sad news is I am working in Framework 2!! :D

_ _ _
**EDIT 3** 

This was so simple following on from [Jon Limjaps Pointer](https://stackoverflow.com/questions/8941/generic-type-checking#8956).. So simple I almost want to cry, but it&#39;s great because the code works like a charm!

So here is what I did (you&#39;ll laugh!):

## Code added to the generic class

    bool TypeValid()
    {
        // Get the TypeCode from the Primitive Type
        TypeCode code = Type.GetTypeCode(typeof(PrimitiveDataType));

        // All of the TypeCode Enumeration refer Primitive Types
        // with the exception of Object and Empty (Null).
        // Since I am willing to allow Null Types (at this time)
        // all we need to check for is Object!
        switch (code)
        {
            case TypeCode.Object:
                return false;
            default:
                return true;
        }
    }

Then a little utility method to check the type and throw an exception,

    private void EnforcePrimitiveType()
    {
        if (!TypeValid())
            throw new InvalidOperationException(
                &quot;Unable to Instantiate SimpleMetadata based on the Generic Type of &#39;&quot; + typeof(PrimitiveDataType).Name + 
                &quot;&#39; - this Class is Designed to Work with Primitive Data Types Only.&quot;);
    }

All that then needs to be done is to call _EnforcePrimitiveType()_ in the classes constructors. Job done! :-)

The only downside, it only throws an exception at runtime (obviously) rather than design time. But that&#39;s no big deal and could be picked up with utilities like [FxCop][1] (which we don&#39;t use at work).

Special thanks to Jon Limjap on this one!

  [1]: http://en.wikipedia.org/wiki/FxCop


Generic type checking

I need to create a data transfer object, which I will use for storing the records retrieved from database. In this data transfer object, I need to declare a numeric field. For that which one is better - **int** or **Integer**

If I am defining the field as Integer, will there be any performance impact because of &#39;Integer&#39; type if I am going to retrieve more than 2000 records from DB!?

Thanks in advance.

Which one to use, int or Integer

In the Kotlin language we, by default, have to initialize each variable when it is introduced. To avoid this, the `lateinit` keyword can be used. Referring to a `lateinit` variable before it has been initialized results in a runtime exception.

`lateinit` can not, however, be used with the primitive types. Why is it so?

Why doesn&#39;t Kotlin allow to use lateinit with primitive types?

I came across a class using Integer variables to capture size to be used in a for loop. Is this good practice or should we use the int primitive data type?

    Integer size = something.getFields().size();
    for (Integer j = 0; j &lt; size - 1; ++j) 

Using int vs Integer

Can someone please explain to me what is going on here:

    char c = &#39;+&#39;;
    int i = (int)c;
    System.out.println(&quot;i: &quot; + i + &quot; ch: &quot; + Character.getNumericValue(c));

This prints `i: 43 ch:-1 `. Does that mean I have to rely on primitive conversions to convert `char` to `int`? So how can I convert a `Character` to `Integer`?

**Edit:** Yes I know `Character.getNumericValue` returns `-1` if it is not a numeric value and that makes sense to me. The question is: why does doing primitive conversions return `43`?

**Edit2:** `43` is the ASCII for `+`, but I would expect the cast to not succeed just like `getNumericValue` did not succeed. Otherwise that means there are two semantic equivalent ways to perform the same operation but with different results?

Converting characters to integers in Java

I&#39;m reading &#39;Professional Javascript for Web Developers&#39; Chapter 4 and it tells me that the five types of primitives are: undefined, null, boolean, number and string.

If `null` is a primitive, why does `typeof(null)` return `&quot;object&quot;`?

Wouldn&#39;t that mean that `null` is passed by reference (I&#39;m assuming here all objects are passed by reference), hence making it NOT a primitive?

Why is typeof null &quot;object&quot;?

The question is basically self-explanatory.  I haven&#39;t been able to find an API for arrays (other than this [Arrays](http://docs.oracle.com/javase/6/docs/api/java/util/Arrays.html), but this just defines a bunch of static helper functions for dealing with actual arrays).  If there is no class for it, this seems to suggest that an array can&#39;t be an `Object`.

However, the fact that an array has public fields like `length` and methods that it can invoke like `.equals()` and `.clone()` seem to suggest (very strongly) the complete opposite.

What is the explanation for the odd presentation and behavior of primitive arrays?

As a note, I tried to use the &quot;Open Implementation&quot; Eclipse feature on the `.clone()` method of an array just now, hoping that I would be able to look at where and how this method was defined (since it said int[] overrode it from Object), but it actually caused my entire Eclipse to freeze up and crash...

All Primitive Solutions on Gang of Coders

Total of 23 Primitive Solutions

what does ">>>" mean in java?