From the [Java Language Specification][1] (on Expressions):

&gt; 15.7.4 Argument Lists are Evaluated Left-to-Right
&gt; 
&gt; In a method or constructor invocation
&gt; or class instance creation expression,
&gt; argument expressions may appear within
&gt; the parentheses, separated by commas.
&gt; Each argument expression appears to be
&gt; fully evaluated before any part of any
&gt; argument expression to its right.

  [1]: http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.7.4

How can I change background color of `ListView` items on a per-item basis. When I use `android:backgroundColor` in the `ListView` item layout I can achieve this, however the list selector is no longer visible. I can make the selector visible again by setting `drawSelectorOnTop` to true but then the selector overlays the whole item.

Any ideas how to change those background colors and keep the selector?

PS I would rather not change the selector itself.

EDIT: Authors of GMail application have managed to achieve exactly this so it&#39;s definitely possible.

Changing background color of ListView items on Android

OSX: This works from the command line:

    alias ruby=&quot;/opt/local/bin/ruby1.9&quot;

but in side a shell script, it has no effect.  I want to write a script that will switch between ruby 1.8 and ruby 1.9, so this needs to be a script - not in my profile.

It appears &quot;source script.sh&quot; works, but &quot;./script.sh&quot;.  Why is this?  How can I replicate this in my script?

How to set an alias inside a bash shell script so that is it visible from the outside?

Given the following function call in `C`:

    fooFunc( barFunc(), bazFunc() );

The order of execution of `barFunc` and `BazFunc` is not specified, so `barFunc()` may be called before `bazFunc()` or `bazFunc()` before `barFunc()` in `C`. 

Does `Java` specify an order of execution of function argument expressions or like `C` is that unspecified? 

Order of execution of parameters guarantees in Java?

Given the following function call in <code>C</code>:
<pre><code class="hljs language-scss">fooFunc( barFunc(), bazFunc() );
</code></pre>
The order of execution of <code>barFunc</code> and <code>BazFunc</code> is not specified, so <code>barFunc()</code> may be called before <code>bazFunc()</code> or <code>bazFunc()</code> before <code>barFunc()</code> in <code>C</code>.
Does <code>Java</code> specify an order of execution of function argument expressions or like <code>C</code> is that unspecified?

I am trying to convert an [ISO 8601][1] formatted String to a `java.util.Date`. 

I found the pattern `yyyy-MM-dd&#39;T&#39;HH:mm:ssZ` to be ISO8601-compliant if used with a Locale (compare sample).

However, using the `java.text.SimpleDateFormat`, I cannot convert the correctly formatted String `2010-01-01T12:00:00+01:00`. I have to convert it first to `2010-01-01T12:00:00+0100`, without the colon. 

So, the current solution is

&lt;!-- language: lang-java --&gt;

    SimpleDateFormat ISO8601DATEFORMAT = new SimpleDateFormat(&quot;yyyy-MM-dd&#39;T&#39;HH:mm:ssZ&quot;, Locale.GERMANY);
    String date = &quot;2010-01-01T12:00:00+01:00&quot;.replaceAll(&quot;\\+0([0-9]){1}\\:00&quot;, &quot;+0$100&quot;);
    System.out.println(ISO8601DATEFORMAT.parse(date));

which obviously isn&#39;t that nice. Am I missing something or is there a better solution?


----------


**Answer**

Thanks to JuanZe&#39;s comment, I found the [Joda-Time][2] magic, it is also [described here][3].

So, the solution is

&lt;!-- language: lang-java --&gt;
     
    DateTimeFormatter parser2 = ISODateTimeFormat.dateTimeNoMillis();
    String jtdate = &quot;2010-01-01T12:00:00+01:00&quot;;
    System.out.println(parser2.parseDateTime(jtdate));

Or more simply, use the default parser via the constructor:

&lt;!-- language: lang-java --&gt;

    DateTime dt = new DateTime( &quot;2010-01-01T12:00:00+01:00&quot; ) ;

To me, this is nice.


  [1]: http://en.wikipedia.org/wiki/ISO_8601
  [2]: http://www.joda.org/joda-time/
  [3]: http://johannburkard.de/blog/programming/java/date-time-parsing-formatting-joda-time.html

Converting ISO 8601-compliant String to java.util.Date

I have long java class and method names

    LONGGGGGGGGGGGGGGGClass.longggggggggggggggggggggggggMethod();

I want to alias it to
`g.m();` in another class
can this be done?

class or method alias in java

I&#39;m trying to find a way to iterate through an enum&#39;s values while using generics.  Not sure how to do this or if it is possible.  

The following code illustrates what I want to do. Note that the code **T.values()** is not valid in the following code.

    public class Filter&lt;T&gt; {
    	private List&lt;T&gt; availableOptions = new ArrayList&lt;T&gt;();
    	private T selectedOption;
    
    	public Filter(T selectedOption) {
    		this.selectedOption = selectedOption;
    		for (T option : T.values()) {  // INVALID CODE
    			availableOptions.add(option);
    		}
    	}
    }

Here is how I would instantiate a Filter object:

    Filter&lt;TimePeriod&gt; filter = new Filter&lt;TimePeriod&gt;(TimePeriod.ALL);

The enum is defined as follows:

    public enum TimePeriod {
    	ALL(&quot;All&quot;), 
    	FUTURE(&quot;Future&quot;), 
    	NEXT7DAYS(&quot;Next 7 Days&quot;), 
    	NEXT14DAYS(&quot;Next 14 Days&quot;), 
    	NEXT30DAYS(&quot;Next 30 Days&quot;), 
    	PAST(&quot;Past&quot;),
    	LAST7DAYS(&quot;Last 7 Days&quot;), 
    	LAST14DAYS(&quot;Last 14 Days&quot;),
    	LAST30DAYS(&quot;Last 30 Days&quot;); 
    
    	private final String name;
    	
    	private TimePeriod(String name) {
    		this.name = name;
    	}
    
    	@Override
    	public String toString() {
    		return name;
    	}
    }

I realize it might not make sense to copy a enum&#39;s values to a list, but I&#39;m using a library that needs a list of values as input and won&#39;t work with enums.

---

EDIT 2/5/2010:

Most of the answers proposed are very similar and suggest doing something like this:

    class Filter&lt;T extends Enum&lt;T&gt;&gt; {
        private List&lt;T&gt; availableOptions = new ArrayList&lt;T&gt;();
        private T selectedOption;
    
        public Filter(T selectedOption) {
            Class&lt;T&gt; clazz = (Class&lt;T&gt;) selectedOption.getClass();
            for (T option : clazz.getEnumConstants()) {
                availableOptions.add(option);
            }
        }
    }

This would work great if I can be sure that selectedOption has a non-null value.  Unfortunately, in my use case, this value is often null, as there is a **public Filter()** no-arg constructor as well. This means I can&#39;t do a selectedOption.getClass() without getting an NPE.  This filter class manages a list of available options which of the options is selected. When nothing is selected, selectedOption is null.

The only thing I can think to solve this is to actually pass in a Class&lt;T&gt; in the constructor.  So something like this:

    class Filter&lt;T extends Enum&lt;T&gt;&gt; {
        private List&lt;T&gt; availableOptions = new ArrayList&lt;T&gt;();
        private T selectedOption;

        public Filter(Class&lt;T&gt; clazz) {
            this(clazz,null);
        }
    
        public Filter(Class&lt;T&gt; clazz, T selectedOption) {
            this.selectedOption = selectedOption;
            for (T option : clazz.getEnumConstants()) {
                availableOptions.add(option);
            }
        }
    }

Any ideas how to do this without needing an extra Class&lt;T&gt; parameter in the constructors?






Iterate enum values using java generics

I wish to parse java source code files, and extract the methods source code.

I would need a method like this : 

    /** Returns a map with key = method name ; value = method source code */
    Map&lt;String,String&gt; getMethods(File javaFile);

Is there a simple way to achieve this, a library to help me build my method, etc. ?

Java : parse java source code, extract methods

I have a multiline string which is delimited by a set of different delimiters:


    (Text1)(DelimiterA)(Text2)(DelimiterC)(Text3)(DelimiterB)(Text4)


I can split this string into its parts, using `String.split`, but it seems that I can&#39;t get the actual string, which matched the delimiter regex.

In other words, this is what I get:

* `Text1`
* `Text2`
* `Text3`
* `Text4`

This is what I want

* `Text1`
* `DelimiterA`
* `Text2`
* `DelimiterC`
* `Text3`
* `DelimiterB`
* `Text4`

Is there any JDK way to split the string using a delimiter regex but also keep the delimiters?

How to split a string, but also keep the delimiters?

Let&#39;s take a simple example of an object `Cat`.  I want to be sure the &quot;not null&quot; `cat` is either orange or grey.

    if(cat != null &amp;&amp; cat.getColor() == &quot;orange&quot; || cat.getColor() == &quot;grey&quot;) {
    //do stuff
    }

I believe AND comes first, then the OR.  I&#39;m kinda fuzzy though, so here are my questions: 

1. Can someone walk me through this statement so I&#39;m sure I get what happens?

2. Also, what happens if I add parentheses; does that change the order of operations?

3. Will my order of operations change from language to language? 


In Java, what are the boolean &quot;order of operations&quot;?

I have a codebase where developers decided to use `AND` and `OR` instead of `&amp;&amp;` and `||`.

I know that there is a difference in operators&#39; precedence (`&amp;&amp;` goes before `and`), but with the given framework ([PrestaShop][1] to be precise) it is clearly not a reason.

Which version are you using? Is `and` more readable than `&amp;&amp;`? Or is there no difference?

  [1]: https://en.wikipedia.org/wiki/PrestaShop


&#39;AND&#39; vs &#39;&amp;&amp;&#39; as operator

I like Scala&#39;s propose of operator precedence but in some rare cases, unmodified rules may be inconvenient, because you have restrictions in naming your methods. Are there ways to define another rules for a class/file, etc. in Scala? If not, would it be resolved in the future?


Operator precedence in Scala

The following for loops produce identical results even though one uses post increment and the other pre-increment.

Here is the code:

    for(i=0; i&lt;5; i++) {
        printf(&quot;%d&quot;, i);
    }

    for(i=0; i&lt;5; ++i) {
        printf(&quot;%d&quot;, i);
    }

I get the same output for both &#39;for&#39; loops.  Am I missing something?

Post-increment and pre-increment within a &#39;for&#39; loop produce same output

I am reading some Java text and got the following code:

    int[] a = {4,4};
    int b = 1;
    a[b] = b = 0;

In the text, the author did not give a clear explanation and the effect of the last line is: `a[1] = 0;`

I am not so sure that I understand: how did the evaluation happen?

What are the rules for evaluation order in Java?

Background (question further down)
===

I&#39;ve been Googling this back and forth reading RFCs and SO questions trying to crack this, but I still don&#39;t got jack.

So I guess we just vote for the &quot;best&quot; answer and that&#39;s it, or?

Basically it boils down to this.

&gt; 3.4. Query Component
&gt; 
&gt; The query component is a string of information to be interpreted by the resource.
&gt; 
&gt; `query         = *uric`
&gt; 
&gt; Within a query component, the characters &quot;;&quot;, &quot;/&quot;, &quot;?&quot;, &quot;:&quot;, &quot;@&quot;, &quot;&amp;&quot;, &quot;=&quot;, &quot;+&quot;, &quot;,&quot;, and &quot;$&quot; are reserved.

The first thing that boggles me is that *uric is defined like this

&gt; `uric          = reserved | unreserved | escaped`
&gt;
&gt; `reserved      = &quot;;&quot; | &quot;/&quot; | &quot;?&quot; | &quot;:&quot; | &quot;@&quot; | &quot;&amp;&quot; | &quot;=&quot; | &quot;+&quot; | &quot;$&quot; | &quot;,&quot;`

This is however somewhat clarified by paragraphs such as

&gt; The &quot;reserved&quot; syntax class above refers to those characters that are allowed within a URI, but which may not be allowed within a particular component of the generic URI syntax; they are used as delimiters of the components described in Section 3.
&gt;
&gt; Characters in the &quot;reserved&quot; set are not reserved in all contexts. The set of characters actually reserved within any given URI component is defined by that component. In general, a character is reserved if the semantics of the URI changes if the character is replaced with its escaped US-ASCII encoding.

This last excerpt feels somewhat backwards, but it clearly states that the reserved character set depends on context. Yet 3.4 states that all the reserved characters are reserved within a query component, however, the only things that would change the semantics here is escaping the question mark (?) as URIs do not define the concept of a query string.

At this point I&#39;ve given up on the RFCs entirely but found RFC 1738 particularly interesting.

&gt; An HTTP URL takes the form:
&gt;
&gt; `http://&lt;host&gt;:&lt;port&gt;/&lt;path&gt;?&lt;searchpart&gt;`
&gt;
&gt;  Within the &amp;lt;path&amp;gt; and &amp;lt;searchpart&amp;gt; components, &quot;/&quot;, &quot;;&quot;, &quot;?&quot; are reserved. The &quot;/&quot; character may be used within HTTP to designate a hierarchical structure.

I interpret this at least with regards to HTTP URLs that RFC 1738 supersedes RFC 2396. Because the URI query has no notion of a query string also the interpretation of reserved doesn&#39;t really let allow me to define query strings as I&#39;m used to doing by now.

Question
===

This all started when I wanted to pass a list of numbers together with the request of another resource. I didn&#39;t think much of it, and just passed it as a comma separated values. To my surprise though the comma was escaped. The query `page.html?q=1,2,3` encoded turned into `page.html?q=1%2C2%2C3` it works, but it&#39;s ugly and didn&#39;t expect it. That&#39;s when I started going through RFCs.

My first question is simply, is encoding commas really necessary?

My answer, according to RFC 2396: yes, according to RFC 1738: no

Later I found related posts regarding the passing of lists between requests. Where the csv approach was poised as bad. This showed up instead, (haven&#39;t seen this before).

    page.html?q=1;q=2;q=3

My second question, is this a valid URL?

My answer, according to RFC 2396: no, according to RFC 1738: no (; is reserved)

I don&#39;t have any issues with passing csv as long as it&#39;s numbers, but yes you do run into the risk of having to encode and decode values back and forth if the comma suddenly is needed for something else. Anyway I tried the semi-colon query string thing with ASP.NET and the result was not what I expected.

    Default.aspx?a=1;a=2&amp;b=1&amp;a=3

    Request.QueryString[&quot;a&quot;] = &quot;1;a=2,3&quot;
    Request.QueryString[&quot;b&quot;] = &quot;1&quot;

I fail to see how this greatly differs from a csv approach as when I ask for &quot;a&quot; I get a string with commas in it. ASP.NET certainly is not a reference implementation but it hasn&#39;t let me down yet.

But most importantly -- my third question -- where is specification for this? and what would you do or for that matter not do?

What&#39;s valid and what&#39;s not in a URI query?

I am using rSpec for testing my application.  In my application controller I have a method like so:

    def set_current_account
      @current_account ||= Account.find_by_subdomain(request.subdomains.first)
    end

Is it possible to set the request.subdomain in my spec?  Maybe in the before block?  I am new to rSpec so any advice on this would be great thanks.

Eef



Rails rspec set subdomain

I read recently (I can&#39;t recall where, or I&#39;d return to that source) that the misspelling of HTTP header field name Referer in the specification was intentional.  Is that accurate?  If so, why?

Was the misspelling of the HTTP field name Referer intentional?

I have a enum `SOME_ENUM`: 

    public enum SOME_ENUM {
      EN_ONE,
      EN_TWO,
      EN_THREE;
    }

Will `SOME_ENUM.values()` always return the enums in the order of enum declarations:
`EN_ONE, EN_TWO, EN_THREE`? Is it a rule or it is not guaranteed to be not changed in the next JDK releases? 

enum.values() - is an order of returned enums deterministic

As far as I know, `private` is the default *everywhere* in C# (meaning that if I don&#39;t write `public`, `protected`, `internal`, etc. it will be `private` by default). (Please correct me if I am wrong.)

So, what&#39;s the reason to write that keyword, or why does it even exist for members?

For example, when an event handler is auto-generated it looks like this:

    private void RatTrap_MouseEnter(object sender, CheeseEventArgs e)
    {
        
    }

But why does it even write private if that&#39;s implied and default? Just so that novice developers (who don&#39;t know it&#39;s the C# default) know that it&#39;s private? Or is there a difference for the compiler?

Moreover, is there a case where writing &quot;private&quot; (alone) *will* change the accessibility of the member?


Any reason to write the &quot;private&quot; keyword in C#?

I have 3 classes:

    public class Alpha {
        public Number number;
    }
    
    public class Beta extends Alpha {
        public String number;
    }
    
    public class Gama extends Beta {
        public int number;
    }

Why does the following code compile? And, why does the test pass without any runtime errors?

    @Test
    public void test() {
        final Beta a = new Gama();
        a.number = &quot;its a string&quot;;
        ((Alpha) a).number = 13;
        ((Gama) a).number = 42;
    
        assertEquals(&quot;its a string&quot;, a.number);
        assertEquals(13, ((Alpha) a).number);
        assertEquals(42, ((Gama) a).number);
    }

If you overwrite a field in a subclass of a class, the subclass has two fields with the same name(and different type)?

This code:

    interface Config {
        int MAX_CONN = 20;
    }

compiled and worked as I expected. It looks like this is the same as:

    interface Config {
        public static final int MAX_CONN = 20;
    }

Is &quot;public static final&quot; redundant for a constant in a Java interface? Is this true for Java 1.1, 1.2, 1.3, 1.4,..., 1.8 or did it change in a Java release?

Is &quot;public static final&quot; redundant for a constant in a Java interface?

Consider the following example code
	
	class MyClass {
		public String var = &quot;base&quot;;
	
		public void printVar() {
			System.out.println(var);
		}
	}
	
	class MyDerivedClass extends MyClass {
		public String var = &quot;derived&quot;;
	
		public void printVar() {
			System.out.println(var);
		}
	}
	
	public class Binding {
		public static void main(String[] args) {
			MyClass base = new MyClass();
			MyClass derived = new MyDerivedClass();
			
			System.out.println(base.var);
			System.out.println(derived.var);
			base.printVar();
			derived.printVar();
		}
	}

it gives the following output

    base
    base
    base
    derived

Method calls are resolved at runtime and the correct overridden method is called, as expected.  
The variables access is instead resolved at compile time as I later learned.
I was expecting an output as

    base
    derived
    base
    derived

because in the derived class the re-definition of `var` shadows the one in the base class.  
Why does the binding of variables happens at compile time and not at runtime? Is this only for performance reasons?

Why does Java bind variables at compile time?

Consider the following example:

    class Quirky {
        public static void main(String[] args) {
            int x = 1;
            int y = 3;
    
            System.out.println(x == (x = y)); // false
            x = 1; // reset
            System.out.println((x = y) == x); // true
         }
    }

I&#39;m not sure if there is an item in the Java Language Specification that dictates loading the previous value of a variable for comparison with the right side (`x = y`) which, by the order implied by brackets, should be calculated first.

Why does the first expression evaluate to `false`, but the second evaluate to `true`? I would have expected `(x = y)` to be evaluated first, and then it would compare `x` with itself (`3`) and return `true`.

---
This question is different from https://stackoverflow.com/questions/32755655/order-of-evaluation-of-subexpressions-in-a-java-expression in that `x` is definitely not a &#39;subexpression&#39; here. It needs to be **loaded** for the comparison rather than to be &#39;evaluated&#39;. The question is Java-specific and the expression `x == (x = y)`, unlike far-fetched impractical constructs commonly crafted for tricky interview questions, came from a real project. It was supposed to be a one-line replacement for the compare-and-replace idiom

    int oldX = x;
    x = y;
    return oldX == y;

which, being even simpler than x86 CMPXCHG instruction, deserved a shorter expression in Java.

Why is x == (x = y) not the same as (x = y) == x?

Take a look at below code:

    class Foo{
        public static int x = 1;
    }

    class Bar{    
        public static void main(String[] args) {
            Foo foo;
            System.out.println(foo.x); // Error: Variable &#39;foo&#39; might not have been initialized
        }
    }

As you see while trying to access static field `x` via an *uninitialized* local variable `Foo foo;` code `foo.x` generates compilation error: `Variable &#39;foo&#39; might not have been initialized`.

It could ***seem*** like this error makes sense, but only until we realize that to access a `static` member the JVM doesn&#39;t actually *use* the ***value*** of a variable, but only its ***type***.  

For instance I can initialize `foo` with value `null` and this will let us access `x` without any problems:

    Foo foo = null;
    System.out.println(foo.x); //compiles and at runtime prints 1!!! 

Such scenario works because compiler realizes that `x` is static and treats `foo.x` as if it was written like `Foo.x` (at least that is what I thought until now). 

So why compiler suddenly insists on `foo` having a value *which it will NOT use* at all?

----
&lt;sup&gt;Disclaimer: This is not code which would be used in real application, but interesting phenomenon which I couldn&#39;t find answer to on Stack Overflow, so I decided to ask about it.&lt;/sup&gt;


Content Type	Original Author	Original Content on Stackoverflow
Question	tpdi	View Question on Stackoverflow
Solution 1 - Java	Michael Easter	View Answer on Stackoverflow

Order of execution of parameters guarantees in Java?

Java Problem Overview

Java Solutions

Solution 1 - Java

How to set an alias inside a bash shell script so that is it visible from the outside?

Changing background color of ListView items on Android

Attributions