Consider a bunch of bananas. This is a `Collection&lt;? extends Fruit&gt;` in that it&#39;s a collection of a particular kind of fruit - but you don&#39;t know (from that declaration) what kind of fruit it&#39;s a collection of. You can *get* an item from it and know it will definitely be a fruit, but you can&#39;t *add* to it - you might be trying to add an apple to a bunch of bananas, which would definitely be wrong. You *can* add `null` to it, as that will be a valid value for *any* kind of fruit.

Now consider a fruitbowl. This is a `Collection&lt;? super Banana&gt;`, in that it&#39;s a collection of some type &quot;greater than&quot; `Banana` (for instance, `Collection&lt;Fruit&gt;` or `Collection&lt;TropicalFruit&gt;`). You can *definitely* add a banana to this, but if you fetch an item from the bowl you don&#39;t know what you&#39;ll get - it may well *not* be a banana. All you know for sure is that it will be a valid (possibly `null`) `Object` reference.

(In general, for Java generics questions, the [Java Generics FAQ][1] is an excellent resource which contains the answer to almost anything generics-related you&#39;re likely to throw at it.)


  [1]: http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html

Just got a notice that the provisioning profile for one of my apps is about to expire. Is there some way I can renew the existing one or must I recreate a new one?

Renew Provisioning Profile

In my .NET 2.0 application, I need to check if sufficient permissions exist to create and write to files to a directory. To this end, I have the following function that attempts to create a file and write a single byte to it, deleting itself afterwards to test that permissions do exist.

I figured the best way to check was to actually try and do it, catching any exceptions that occur. I&#39;m not particularly happy about the general Exception catch though, so is there a better or perhaps a more accepted way of doing this?


    private const string TEMP_FILE = &quot;\\tempFile.tmp&quot;;
    
    /// &lt;summary&gt;
    /// Checks the ability to create and write to a file in the supplied directory.
    /// &lt;/summary&gt;
    /// &lt;param name=&quot;directory&quot;&gt;String representing the directory path to check.&lt;/param&gt;
    /// &lt;returns&gt;True if successful; otherwise false.&lt;/returns&gt;
    private static bool CheckDirectoryAccess(string directory)
    {
        bool success = false;
        string fullPath = directory + TEMP_FILE;
    
        if (Directory.Exists(directory))
        {
            try
            {
                using (FileStream fs = new FileStream(fullPath, FileMode.CreateNew, 
                                                                FileAccess.Write))
                {
                    fs.WriteByte(0xff);
                }
    
                if (File.Exists(fullPath))
                {
                    File.Delete(fullPath);
                    success = true;
                }
            }
            catch (Exception)
            {
                success = false;
            }
        }

Checking for directory and file write permissions in .NET

I have read O&#39;Reilly book, in that I came to know this **_get-put principle_**.

&gt; - Use an **`extends`** wildcard when you only **get** values out of a structure. 
- Use a **`super`** wildcard when you only **put** values into a structure.
- And don&#39;t use a wildcard when you both want to get and put from/to a structure.

**Exceptions** are:

&gt; - You cannot put anything into a type declared with an **`extends`** wildcard except for the value **`null`**, which belongs to every reference type.
 
&gt; - You cannot get anything out from a type declared with an **`super`** wildcard except for a value of type **`Object`**, which is a super type of every reference type.


Can anyone help me to explore this rule at depth? If possible, please put them hierarchical manner.

Explanation of the get-put principle

I have read O'Reilly book, in that I came to know this get-put principle.
> - Use an <code>extends</code> wildcard when you only get values out of a structure.
<ul>
<li>Use a <code>super</code> wildcard when you only put values into a structure.</li>
<li>And don't use a wildcard when you both want to get and put from/to a structure.</li>
</ul>
Exceptions are:
> - You cannot put anything into a type declared with an <code>extends</code> wildcard except for the value <code>null</code>, which belongs to every reference type.
> - You cannot get anything out from a type declared with an <code>super</code> wildcard except for a value of type <code>Object</code>, which is a super type of every reference type.
Can anyone help me to explore this rule at depth? If possible, please put them hierarchical manner.

I would like to understand the difference between the `Boolean` and `boolean` types in Java, specifically as they relate to GWT.
I know that methods are not supported but I want more info if it is available.

What&#39;s the difference between boolean and Boolean in Java?

I used the following line to convert float to int, but it&#39;s not as accurate as I&#39;d like:

     float a=8.61f;
     int b;
    
     b=(int)a;
    
The result is : `8` (It should be `9`)

When `a = -7.65f`, the result is : `-7` (It should be `-8`)

What&#39;s the best way to do it ?

How to convert float to int with Java

At work I&#39;ve been tasked with turning a bunch of `HTML` files into a simple `JSP` project. It&#39;s really all static, no serverside logic to program. I should mention I&#39;m completely new to Java. JSP files seem to make it easy to work with common includes and variables, much like `PHP`, but I&#39;d like to know a simple way to get something like template inheritance (`Django` style) or at least be able to have a base.jsp file containing the header and the footer, so I can insert content later.

*Ben Lings* seems to offer some hope in his answer here:
https://stackoverflow.com/questions/490390/jsp-template-inheritance
Can someone explain how to achieve this?

Given that I don&#39;t have much time I think dynamic routing is a little much, so I&#39;m happy to just to have URLs map directly onto `.jsp` files, but I&#39;m open to suggestion.

*Thanks.*

**edit:** I don&#39;t want to use any external libraries, because it would increase the learning curve for myself and others who work on the project, and the company I work for has been contracted to do this.

**Another edit:** I&#39;m not sure if `JSP tags` will be useful because my content doesn&#39;t really have any template variables. What I need is a way to be able to do this:

`base.html:`

    &lt;html&gt;&lt;body&gt;
    { content.body }
    &lt;/body&gt;&lt;/html&gt;

`somepage.html`

    &lt;wrapper:base.html&gt;
    &lt;h1&gt;Welcome&lt;/h1&gt;
    &lt;/wrapper&gt;

with the output being:

    &lt;html&gt;&lt;body&gt;
    &lt;h1&gt;Welcome&lt;/h1&gt;
    &lt;/body&gt;&lt;/html&gt;

I think this would give me enough versatility to do everything I need. It could be achieved with `includes` but then I would need a top and a bottom include for each wrapper, which is kind of messy.

JSP tricks to make templating easier?

I have a generic interface

    public interface Consumer&lt;E&gt; {
        public void consume(E e);
    }

I have a class that consumes two types of objects, so I would like to do something like:

    public class TwoTypesConsumer implements Consumer&lt;Tomato&gt;, Consumer&lt;Apple&gt;
    {
       public void consume(Tomato t) {  .....  }
       public void consume(Apple a) { ...... }
    }

Apparently I can&#39;t do that.

I can of course implement the dispatch myself, e.g.

    public class TwoTypesConsumer implements Consumer&lt;Object&gt; {
       public void consume(Object o) {
          if (o instanceof Tomato) { ..... }
          else if (o instanceof Apple) { ..... }
          else { throw new IllegalArgumentException(...) }
       }
    }

But I am looking for the compile-time type-checking and dispatching solution that generics provide.

The best solution I can think of is to define separate interfaces, e.g.

    public interface AppleConsumer {
       public void consume(Apple a);
    }

Functionally, this solution is OK, I think. It&#39;s just verbose and ugly.

Any ideas? 

How to make a Java class that implements one interface with two generic types?

This (should) be a rather simple thing to do, however I am struggling.

I want a table to be generated like this:
&lt;pre&gt;
id 
organizationNumber 
name
&lt;/pre&gt;

However, when I look in the database, I see that the ordering is wrong. Does anybody know how I can force hibernate/jpa to generate the table with correct ordering? 

&lt;pre&gt;
desc Organization;
+--------------------+--------------+------+-----+---------+----------------+
| Field              | Type         | Null | Key | Default | Extra          |
+--------------------+--------------+------+-----+---------+----------------+
| id                 | bigint(20)   | NO   | PRI | NULL    | auto_increment | 
| name               | varchar(255) | NO   |     | NULL    |                | 
| organizationNumber | varchar(255) | NO   | UNI | NULL    |                | 
+--------------------+--------------+------+-----+---------+----------------+
&lt;/pre&gt;

This is how my entity bean looks like: 

    @Entity
    @NamedQuery(name = &quot;allOrganizations&quot;, query = &quot;SELECT org FROM Organization org order by name&quot;)
    public class Organization {
    
    	private Long id;
    	private String organizationNumber;
    	private String name;
    
    	public Organization() {
    	}
    
    	public Organization(String name) {
    		this.name = name;
    	}
    
    	@Id
    	@GeneratedValue
    	public Long getId() {
    		return id;
    	}
    
    	@SuppressWarnings(&quot;unused&quot;)
    	private void setId(Long id) {
    		this.id = id;
    	}
    
    	@NotEmpty
    	@Column(unique=true, nullable=false)
    	public String getOrganizationNumber() {
    		return organizationNumber;
    	}
           public void setOrganizationNumber(String organizationNumber) {
    		this.organizationNumber = organizationNumber;
    	}
    
    	
    	@NotEmpty
    	@Column(nullable=false)
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    	@Override
    	public String toString() {
    		return this.name + &quot; &quot; + this.organizationNumber;
    	}
    }



Wrong ordering in generated table in jpa

I&#39;m drawing a blank on this one and can&#39;t seem to find any previous example that I wrote. I&#39;m trying to implement a generic interface with a class. When I implement the interface I think something isn&#39;t working right because Visual Studio continually produces errors saying that I&#39;m not implmenting all of the methods in the Generic Interface.

Here&#39;s a stub of what I&#39;m working with:

    public interface IOurTemplate&lt;T, U&gt;
    {
        IEnumerable&lt;T&gt; List&lt;T&gt;() where T : class;
        T Get&lt;T, U&gt;(U id)
            where T : class
            where U : class;
    }

So what should my class look like?

Implement an Interface with Generic Methods

I keep hearing that in .net 3.5 you should use IEnumerable over a List, but I can’t find any reference materials or articles that explain why it’s so much more proficient.  Does anyone know of any content that explains this? 

The purpose of asking this question is to get a better understanding of what IEnumerable is doing under the hood.  If you can provide me with any links I will do the research and post an answer. 




Explanation why IEnumerable is more efficient than a List

What is the difference between `&lt;? super E&gt;` and `&lt;? extends E&gt;`?

For instance when you take a look at class &lt;code&gt;java.util.concurrent.LinkedBlockingQueue&lt;E&gt;&lt;/code&gt; there is the following signature for the constructor:

    public LinkedBlockingQueue(Collection&lt;? extends E&gt; c)

and for one for the method: 

    public int drainTo(Collection&lt;? super E&gt; c)

What is a difference between &lt;? super E&gt; and &lt;? extends E&gt;?

I have the following class (from a simple Spring tutorial)

    public class CarValidator implements Validator {
    
        public boolean supports(Class aClass) {
            return Car.class.equals(aClass);
        }
    
        public void validate(Object obj, Errors errors) {
            Car car = (Car) obj;
    
            ValidationUtils.rejectIfEmptyOrWhitespace(errors, &quot;model&quot;, &quot;field.required&quot;, &quot;Required field&quot;);
    
            ValidationUtils.rejectIfEmptyOrWhitespace(errors, &quot;price&quot;, &quot;field.required&quot;, &quot;Required field&quot;);
    
            if( ! errors.hasFieldErrors(&quot;price&quot;)) {
                if (car.getPrice().intValue() == 0) {
                    errors.rejectValue(&quot;price&quot;, &quot;not_zero&quot;, &quot;Can&#39;t be free!&quot;);
                }
            }
    
        }
    }
    
Where the Validator class is the `org.springframework.validation.Validator` class from Spring 2.5.

The supports method is showing a warning (Class is a raw type. References to generic type Class&lt;T&gt; should be parameterized), if I try to add parameters to this such as 

    public boolean supports(Class&lt;?&gt; aClass) ...

I get the following error:

```The method supports(Class&lt;?&gt;) of type CarValidator has the same erasure as supports(Class) of type Validator but does not override it```

There are lots of threads about this type of question, but I want to get a complete answer and actually understand it without &#39;hiding&#39; the problem with a `@SupressWarnings`!

Content Type	Original Author	Original Content on Stackoverflow
Question	JavaResp	View Question on Stackoverflow
Solution 1 - Java	Jon Skeet	View Answer on Stackoverflow

Explanation of the get-put principle

Java Problem Overview

Java Solutions

Solution 1 - Java

Checking for directory and file write permissions in .NET

Renew Provisioning Profile

Attributions