This warning is there because Java is not actually storing type information at run-time in an object that uses generics.  Thus, if `object` is actually a `List&lt;String&gt;`, there will be no `ClassCastException` at run-time except until an item is accessed from the list that doesn&#39;t match the generic type defined in the variable.  

This can cause further complications if items are added to the list, with this incorrect generic type information.  Any code still holding a reference to the list but with the correct generic type information will now have an inconsistent list.  

To remove the warning, try:

    List&lt;?&gt; list = (List&lt;?&gt;) object;

However, note that you will not be able to use certain methods such as add because the compiler doesn&#39;t know if you are trying to add an object of incorrect type.  The above will work in a lot of situations, but if you have to use add, or some similarly restricted method, you will just have to suffer the yellow underline in Eclipse (or a `SuppressWarning` annotation).

I&#39;ve always preferred to use long integers as primary keys in databases, for simplicity and (assumed) speed. But when using a [REST][1] or Rails-like URL scheme for object instances, I&#39;d then end up with URLs like this:

    http://example.com/user/783

And then the assumption is that there are also users with IDs of 782, 781, ..., 2, and 1. Assuming that the web app in question is secure enough to prevent people entering other numbers to view other users without authorization, a simple sequentially-assigned surrogate key also &quot;leaks&quot; the total number of instances (older than this one), in this case users, which might be privileged information. (For instance, I am user #726 in stackoverflow.)

Would a [UUID][2]/GUID be a better solution? Then I could set up URLs like this:

    http://example.com/user/035a46e0-6550-11dd-ad8b-0800200c9a66

Not exactly succinct, but there&#39;s less implied information about users on display. Sure, it smacks of &quot;security through obscurity&quot; which is no substitute for proper security, but it seems at least a little more secure.

Is that benefit worth the cost and complexity of implementing UUIDs for web-addressable object instances? I think that I&#39;d still want to use integer columns as database PKs just to speed up joins.

There&#39;s also the question of in-database representation of UUIDs. I know MySQL stores them as 36-character strings. Postgres seems to have a more efficient internal representation (128 bits?) but I haven&#39;t tried it myself. Anyone have any experience with this?

---

Update: for those who asked about just using the user name in the URL (e.g., http://example.com/user/yukondude), that works fine for object instances with names that are unique, but what about the zillions of web app objects that can really only be identified by number? Orders, transactions, invoices, duplicate image names, stackoverflow questions, ...


  [1]: http://en.wikipedia.org/wiki/Representational_State_Transfer
  [2]: http://en.wikipedia.org/wiki/Uuid

What&#39;s your opinion on using UUIDs as database row identifiers, particularly in web apps?

After the Spring Boot 2.5.0 update, it generates the `myprogram-0.0.1-plain.jar` file alongside the usual `myprogram-0.0.1.jar`. Can I disallow gradle to generate the `*.plain.jar` file? I use Gradle 7.0.2.

What I get:
```
build/
  libs/
    myprogram-0.0.1.jar
    myprogram-0.0.1-plain.jar
```

What I want:
```
build/
  libs/
    myprogram-0.0.1.jar
```

build.gradle:
```
plugins {
	id &#39;org.springframework.boot&#39; version &#39;2.5.0&#39;
	id &#39;io.spring.dependency-management&#39; version &#39;1.0.11.RELEASE&#39;
	id &#39;java&#39;
}

group = &#39;com.example&#39;
version = &#39;0.0.1-SNAPSHOT&#39;
sourceCompatibility = &#39;11&#39;

repositories {
	mavenCentral()
}

dependencies {
	implementation &#39;org.springframework.boot:spring-boot-starter&#39;
	testImplementation &#39;org.springframework.boot:spring-boot-starter-test&#39;
}

test {
	useJUnitPlatform()
}

```

Spring Boot 2.5.0 generates plain.jar file. Can I remove it?

What is the meaning of the *Java warning*?
 
&gt; Type safety: The cast from Object to List&amp;lt;Integer&amp;gt; is actually checking against the erased type List
 
I get this warning when I try to cast an Object to a type with generic information, such as in the following code:

    Object object = getMyList();
    List&lt;Integer&gt; list = (List&lt;Integer&gt;) object;

What is the meaning of the type safety warning in certain Java generics casts?

What is the meaning of the Java warning?
> Type safety: The cast from Object to List&#x3C;Integer> is actually checking against the erased type List
I get this warning when I try to cast an Object to a type with generic information, such as in the following code:
<pre><code class="hljs language-ini">Object object = getMyList();
List&#x3C;Integer> list = (List&#x3C;Integer>) object;
</code></pre>

I was reading *[More Joel on Software][2]* when I came across [Joel Spolsky][3] saying something about a particular type of programmer knowing the difference between an `int` and an `Integer` in Java/C# (Object-Oriented Programming Languages).

So, what is the difference?

  [1]: http://en.wikipedia.org/wiki/Borders_%28UK%29
  [2]: http://www.amazon.com/More-Joel-Software-Occasionally-Developers/dp/1430209879
  [3]: http://en.wikipedia.org/wiki/Joel_Spolsky


What is the difference between an int and an Integer in Java and C#?

Is there a way to create a `JButton` with your own button graphic and not just with an image inside the button? 

If not, is there another way to create a custom `JButton` in java?

Creating a custom JButton in Java

For parsing player commands, I&#39;ve most often used the [split][1] method to split a string by delimiters and then to then just figure out the rest by a series of `if`s or `switch`es. What are some different ways of parsing strings in Java?

[1]:http://docs.oracle.com/javase/6/docs/api/java/lang/String.html#split%28java.lang.String%29

What are the different methods to parse strings in Java?

I have a simple setter method for a property and `null` is not appropriate for this particular property. I have always been torn in this situation: should I throw an [`IllegalArgumentException`][1], or a [`NullPointerException`][2]? From the javadocs, both seem appropriate. Is there some kind of an understood standard?  Or is this just one of those things that you should do whatever you prefer and both are really correct?

  [1]: http://docs.oracle.com/javase/7/docs/api/java/lang/IllegalArgumentException.html
  [2]: http://docs.oracle.com/javase/7/docs/api/java/lang/NullPointerException.html

IllegalArgumentException or NullPointerException for a null parameter?

What code analysis tools do you use on your Java projects?

I am interested in all kinds

- static code analysis tools (FindBugs, PMD, and any others)
- code coverage tools (Cobertura, Emma, and any others)
- any other instrumentation-based tools 
- anything else, if I&#39;m missing something

If applicable, also state what build tools you use and how well these tools integrate with both your IDEs and build tools. 

If a tool is only available a specific way (as an IDE plugin, or, say, a build tool plugin) that information is also worth noting.

What code analysis tools do you use for your Java projects?

It seems that a List&lt;string&gt; object cannot be stored in a List&lt;object&gt; variable in C#, and can&#39;t even be explicitly cast that way.

    List&lt;string&gt; sl = new List&lt;string&gt;();
    List&lt;object&gt; ol;
    ol = sl;

results in Cannot implicitly convert type `System.Collections.Generic.List&lt;string&gt;` to `System.Collections.Generic.List&lt;object&gt;`

And then...

    List&lt;string&gt; sl = new List&lt;string&gt;();
    List&lt;object&gt; ol;
    ol = (List&lt;object&gt;)sl;

results in Cannot convert type `System.Collections.Generic.List&lt;string&gt;` to `System.Collections.Generic.List&lt;object&gt;`

Of course, you can do it by pulling everything out of the string list and putting it back in one at a time, but it is a rather convoluted solution.

In C#, why can&#39;t a List&lt;string&gt; object be stored in a List&lt;object&gt; variable

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

**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

So I came across an interesting problem today. We have a WCF web service that returns an IList&lt;MyObj&gt;. Not really a big deal until I wanted to sort it.

Turns out the IList interface doesn&#39;t have a sort method built in. 

I ended up using the `ArrayList.Adapter(list).Sort(new MyComparer())` method to solve the problem but it just seemed a bit &quot;ghetto&quot; to me.

I toyed with writing an extension method, also with inheriting from IList and implementing my own Sort() method as well as casting to a List&lt;MyObj&gt; but none of these seemed overly elegant.

So my question is, does anyone have an elegant solution to sorting an IList&lt;MyObj&gt;

Sorting an IList in C#

I have a generic class that should allow any type, primitive or otherwise. The only problem with this is using `default(T)`. When you call default on a value type or a string, it initializes it to a reasonable value (such as empty string). When you call `default(T)` on an object, it returns null. For various reasons we need to ensure that if it is not a primitive type, then we will have a default instance of the type, **not** null. Here is attempt 1:

    T createDefault()
    {
        if(typeof(T).IsValueType)
        {
            return default(T);
        }
        else
        {
            return Activator.CreateInstance&lt;T&gt;();
        }
    }

Problem - string is not a value type, but it does not have a parameterless constructor. So, the current solution is:

    T createDefault()
    {
        if(typeof(T).IsValueType || typeof(T).FullName == &quot;System.String&quot;)
        {
            return default(T);
        }
        else
        {
            return Activator.CreateInstance&lt;T&gt;();
        }
    }

But this feels like a kludge. Is there a nicer way to handle the string case?

Best way to test if a generic type is a string? (C#)

I am currently developing a .NET application, which consists of 20 projects. Some of those projects are compiled using .NET 3.5, some others are still .NET 2.0 projects (so far no problem).

The problem is that if I include an external component I always get the following warning:

&gt; Found conflicts between different versions of the same dependent assembly.

What exactly does this warning mean and is there maybe a possibility to exclude this warning (like using #pragma disable in the source code files)?

Warning: Found conflicts between different versions of the same dependent assembly

What is the reason for the following warning in some C++ compilers?

&gt; No newline at end of file

Why should I have an empty line at the end of a source/header file?

&quot;No newline at end of file&quot; compiler warning

I&#39;m getting a warning from ReSharper about a call to a virtual member from my objects constructor. 

Why would this be something not to do?

Virtual member call in a constructor

While developing a C++ application, I had to use a third-party library which produced a huge amount of warnings related with a harmless #pragma directive being used.

```lang-none
../File.hpp:1: warning: ignoring #pragma ident
In file included from ../File2.hpp:47,
                 from ../File3.hpp:57,
                 from File4.h:49,
```

Is it possible to disable this kind of warnings, when using the GNU C++ compiler?







How can I disable #pragma warnings?

I know that the #warning directive is not standard **C**/C++, but several compilers support it, including gcc/g++.  But for those that don&#39;t support it, will they silently ignore it or will it result in a compile failure?  In other words, can I safely use it in my project without breaking the build for compilers that don&#39;t support it?

Portability of #warning preprocessor directive

I&#39;ve been writing C and C++ code for almost twenty years, but there&#39;s one aspect of these languages that I&#39;ve never really understood. I&#39;ve obviously used regular casts i.e.

    MyClass *m = (MyClass *)ptr;

all over the place, but there seem to be two other types of casts, and I don&#39;t know the difference. What&#39;s the difference between the following lines of code?

    MyClass *m = (MyClass *)ptr;
    MyClass *m = static_cast&lt;MyClass *&gt;(ptr);
    MyClass *m = dynamic_cast&lt;MyClass *&gt;(ptr);
    

Regular cast vs. static_cast vs. dynamic_cast

How can an `int` be cast to an `enum` in C#?


How can I cast int to enum?

Are all of these equal?  Under what circumstances should I choose each over the others?

  - var.ToString()

  - CStr(var)

  - CType(var, String)

  - DirectCast(var, String)

----------
*EDIT: Suggestion from **[NotMyself][1]**&amp;hellip;*

  - TryCast(var, String)


  [1]: https://stackoverflow.com/users/303/notmyself

How should I cast in VB.NET?

Can you cast a `List&lt;int&gt;` to `List&lt;string&gt;` somehow?

I know I could loop through and .ToString() the thing, but a cast would be awesome.

I&#39;m in C# 2.0 (so no [LINQ][1]).

  [1]: http://en.wikipedia.org/wiki/Language_Integrated_Query


Cast List&lt;int&gt; to List&lt;string&gt; in .NET 2.0

I&#39;ve heard that the `static_cast` function should be preferred to C-style or simple function-style casting.  Is this true?  Why?

Why use static_cast&lt;int&gt;(x) instead of (int)x?

C++ 0x has template aliases (sometimes referred to as template typedefs). See [here][1]. Current spec of C++ does not. 

What do you like to use as work around ? Container objects or Macros ?
Do you feel its worth it ?


  [1]: http://en.wikipedia.org/wiki/C%2B%2B0x#Alias_templates

Content Type	Original Author	Original Content on Stackoverflow
Question	Mike Stone	View Question on Stackoverflow
Solution 1 - Java	Mike Stone	View Answer on Stackoverflow

What is the meaning of the type safety warning in certain Java generics casts?

Java Problem Overview

Java Solutions

Solution 1 - Java

Spring Boot 2.5.0 generates plain.jar file. Can I remove it?

What's your opinion on using UUIDs as database row identifiers, particularly in web apps?

Attributions