`$` is used internally by the compiler to decorate certain names. Wikipedia [gives the following example][1]:


    public class foo {
        class bar {
            public int x;
        }
     
        public void zark () {
            Object f = new Object () {
                public String toString() {
                    return &quot;hello&quot;;
                }
            };
        }
    }

Compiling this program will produce three .class files:

 - `foo.class`, containing the main (outer) class `foo`
 - `foo$bar.class`,
   containing the named inner class `foo.bar` 
 - `foo$1.class`, containing the
   anonymous inner class (local to method `foo.zark`)

All of these class names are valid (as `$` symbols are permitted in the JVM specification).



In a similar vein, `javac` uses `$` in some automatically-generated **variable names**: for example, `this$0` et al are used for the implicit `this` references from the inner classes to their outer classes.

Finally, [the JLS recommends the following][2]:

&gt; The `$` character should be used only in mechanically generated source
&gt; code or, rarely, to access preexisting names on legacy systems.


  [1]: http://en.wikipedia.org/wiki/Name_mangling#Creating_unique_names_for_inner_and_anonymous_classes
  [2]: https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.8

There is no special meaning for a `$` in a variable’s name. 

While technically allowed, starting the variable name with a dollar sign goes against convention, generally used only by code-generators.

To quote the [Java Tutorial][1] by Oracle:

&gt;Variable names are case-sensitive. A variable&#39;s name can be any legal identifier — an unlimited-length sequence of Unicode letters and digits, beginning with a letter, the dollar sign &quot;$&quot;, or the underscore character &quot;\_&quot;. The convention, however, is to always begin your variable names with a letter, not &quot;$&quot; or &quot;\_&quot;. Additionally, the dollar sign character, by convention, is never used at all. You may find some situations where auto-generated names will contain the dollar sign, but your variable names should always avoid using it. A similar convention exists for the underscore character; while it&#39;s technically legal to begin your variable&#39;s name with &quot;\_&quot;, this practice is discouraged. White space is not permitted.


  [1]: http://download.oracle.com/javase/tutorial/java/nutsandbolts/variables.html

I&#39;m trying to use Pex to test some code. I have an abstract class with four concrete implementations.  I have created factory methods for each of the four concrete types. I had also created one for the abstract type, except as &lt;a href=&quot;http://social.msdn.microsoft.com/Forums/en/pex/thread/d218e494-c000-4c5e-b45d-8f0be29df635&quot;&gt;this nice thread&lt;/a&gt; explains, Pex will not use the abstract factory method, nor should it.

The problem is that some of my code depends on the four concrete types being all there are (since it is very, very unlikely that any more subclasses will be created), but Pex is breaking the code by using Moles to create a stub.

How can I force Pex to use one of the factory methods (any one, I don&#39;t care) to create instances of the abstract class without ever creating Moles stubs for that abstract class?  Is there a &lt;code&gt;PexAssume&lt;/code&gt; directive that will accomplish this?  Note that some of the concrete types form a type of tree structure, so say &lt;code&gt;ConcreteImplementation&lt;/code&gt; derives from &lt;code&gt;AbstractClass&lt;/code&gt;, and &lt;code&gt;ConcreteImplementation&lt;/code&gt; has two properties of type &lt;code&gt;AbstractClass&lt;/code&gt;.  I need to ensure that no stubs are used anywhere in the tree at all.  (Not all the concrete implementations have &lt;code&gt;AbstractClass&lt;/code&gt; properties.)

**Edit:**

It appears that I need to add some more information on how the class structure itself works, though remember that the goal is still how to get Pex not to stub classes.

Here are simplified versions of the abstract base class and the four concrete implementations thereof.

    public abstract class AbstractClass
    {
        public abstract AbstractClass Distill();

        public static bool operator ==(AbstractClass left, AbstractClass right)
        {
             // some logic that returns a bool
        }
 
        public static bool operator !=(AbstractClass left, AbstractClass right)
        {
             // some logic that basically returns !(operator ==)
        }

        public static Implementation1 Implementation1
        {
            get
            {
                return Implementation1.GetInstance;
            }
        }
    }

    public class Implementation1 : AbstractClass, IEquatable&lt;Implementation1&gt;
    {
        private static Implementation1 _implementation1 = new Implementation1();

        private Implementation1()
        {
        }

        public override AbstractClass Distill()
        {
            return this;
        }

        internal static Implementation1 GetInstance
        {
            get
            {
                return _implementation1;
            }
        }

        public bool Equals(Implementation1 other)
        {
            return true;
        }
    }

    public class Implementation2 : AbstractClass, IEquatable&lt;Implementation2&gt;
    {
        public string Name { get; private set; }
        public string NamePlural { get; private set; }

        public Implementation2(string name)
        {
            // initializes, including
            Name = name;
            // and sets NamePlural to a default
        }

        public Implementation2(string name, string plural)
        {
            // initializes, including
            Name = name;
            NamePlural = plural;
        }

        public override AbstractClass Distill()
        {
            if (String.IsNullOrEmpty(Name))
            {
                return AbstractClass.Implementation1;
            }
            return this;
        }

        public bool Equals(Implementation2 other)
        {
            if (other == null)
            {
                return false;
            }

            return other.Name == this.Name;
        }
    }

    public class Implementation3 : AbstractClass, IEquatable&lt;Implementation3&gt;
    {
        public IEnumerable&lt;AbstractClass&gt; Instances { get; private set; }

        public Implementation3()
            : base()
        {
            Instances = new List&lt;AbstractClass&gt;();
        }

        public Implementation3(IEnumerable&lt;AbstractClass&gt; instances)
            : base()
        {
            if (instances == null)
            {
                throw new ArgumentNullException(&quot;instances&quot;, &quot;error msg&quot;);
            }

            if (instances.Any&lt;AbstractClass&gt;(c =&gt; c == null))
            {
                thrown new ArgumentNullException(&quot;instances&quot;, &quot;some other error msg&quot;);
            }

            Instances = instances;
        }

        public override AbstractClass Distill()
        {
            IEnumerable&lt;AbstractClass&gt; newInstances = new List&lt;AbstractClass&gt;(Instances);

            // &quot;Flatten&quot; the collection by removing nested Implementation3 instances
            while (newInstances.OfType&lt;Implementation3&gt;().Any&lt;Implementation3&gt;())
            {
                newInstances = newInstances.Where&lt;AbstractClass&gt;(c =&gt; c.GetType() != typeof(Implementation3))
                                           .Concat&lt;AbstractClass&gt;(newInstances.OfType&lt;Implementation3&gt;().SelectMany&lt;Implementation3, AbstractUnit&gt;(i =&gt; i.Instances));
            }

            if (newInstances.OfType&lt;Implementation4&gt;().Any&lt;Implementation4&gt;())
            {
                List&lt;AbstractClass&gt; denominator = new List&lt;AbstractClass&gt;();
 
                while (newInstances.OfType&lt;Implementation4&gt;().Any&lt;Implementation4&gt;())
                {
                    denominator.AddRange(newInstances.OfType&lt;Implementation4&gt;().Select&lt;Implementation4, AbstractClass&gt;(c =&gt; c.Denominator));
                    newInstances = newInstances.Where&lt;AbstractClass&gt;(c =&gt; c.GetType() != typeof(Implementation4))
                                               .Concat&lt;AbstractClass&gt;(newInstances.OfType&lt;Implementation4&gt;().Select&lt;Implementation4, AbstractClass&gt;(c =&gt; c.Numerator));
                }

                return (new Implementation4(new Implementation3(newInstances), new Implementation3(denominator))).Distill();
            }

            // There should only be Implementation1 and/or Implementation2 instances
            // left.  Return only the Implementation2 instances, if there are any.
            IEnumerable&lt;Implementation2&gt; i2s = newInstances.Select&lt;AbstractClass, AbstractClass&gt;(c =&gt; c.Distill()).OfType&lt;Implementation2&gt;();
            switch (i2s.Count&lt;Implementation2&gt;())
            {
                case 0:
                    return AbstractClass.Implementation1;
                case 1:
                    return i2s.First&lt;Implementation2&gt;();
                default:
                    return new Implementation3(i2s.OrderBy&lt;Implementation2, string&gt;(c =&gt; c.Name).Select&lt;Implementation2, AbstractClass&gt;(c =&gt; c));
            }
        }

        public bool Equals(Implementation3 other)
        {
            // omitted for brevity
            return false;
        }
    }

    public class Implementation4 : AbstractClass, IEquatable&lt;Implementation4&gt;
    {
        private AbstractClass _numerator;
        private AbstractClass _denominator;

        public AbstractClass Numerator
        {
            get
            {
                return _numerator;
            }

            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException(&quot;value&quot;, &quot;error msg&quot;);
                }

                _numerator = value;
            }
        }

        public AbstractClass Denominator
        {
            get
            {
                return _denominator;
            }

            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException(&quot;value&quot;, &quot;error msg&quot;);
                }
                _denominator = value;
            }
        }

        public Implementation4(AbstractClass numerator, AbstractClass denominator)
            : base()
        {
            if (numerator == null || denominator == null)
            {
                throw new ArgumentNullException(&quot;whichever&quot;, &quot;error msg&quot;);
            }

            Numerator = numerator;
            Denominator = denominator;
        }

        public override AbstractClass Distill()
        {
            AbstractClass numDistilled = Numerator.Distill();
            AbstractClass denDistilled = Denominator.Distill();

            if (denDistilled.GetType() == typeof(Implementation1))
            {
                return numDistilled;
            }
            if (denDistilled.GetType() == typeof(Implementation4))
            {
                Implementation3 newInstance = new Implementation3(new List&lt;AbstractClass&gt;(2) { numDistilled, new Implementation4(((Implementation4)denDistilled).Denominator, ((Implementation4)denDistilled).Numerator) });
                return newInstance.Distill();
            }
            if (numDistilled.GetType() == typeof(Implementation4))
            {
                Implementation4 newImp4 = new Implementation4(((Implementation4)numReduced).Numerator, new Implementation3(new List&lt;AbstractClass&gt;(2) { ((Implementation4)numDistilled).Denominator, denDistilled }));
                return newImp4.Distill();
            }

            if (numDistilled.GetType() == typeof(Implementation1))
            {
                return new Implementation4(numDistilled, denDistilled);
            }

            if (numDistilled.GetType() == typeof(Implementation2) &amp;&amp; denDistilled.GetType() == typeof(Implementation2))
            {
                if (((Implementation2)numDistilled).Name == (((Implementation2)denDistilled).Name)
                {
                    return AbstractClass.Implementation1;
                }
                return new Implementation4(numDistilled, denDistilled);
            }

            // At this point, one or both of numerator and denominator are Implementation3
            // instances, and the other (if any) is Implementation2.  Because both
            // numerator and denominator are distilled, all the instances within either
            // Implementation3 are going to be Implementation2.  So, the following should
            // work.
            List&lt;Implementation2&gt; numList =
                numDistilled.GetType() == typeof(Implementation2) ? new List&lt;Implementation2&gt;(1) { ((Implementation2)numDistilled) } : new List&lt;Implementation2&gt;(((Implementation3)numDistilled).Instances.OfType&lt;Implementation2&gt;());

            List&lt;Implementation2&gt; denList =
                denDistilled.GetType() == typeof(Implementation2) ? new List&lt;Implementation2&gt;(1) { ((Implementation2)denDistilled) } : new List&lt;Implementation2&gt;(((Implementation3)denDistilled).Instances.OfType&lt;Implementation2&gt;());

            Stack&lt;int&gt; numIndexesToRemove = new Stack&lt;int&gt;();
            for (int i = 0; i &lt; numList.Count; i++)
            {
                if (denList.Remove(numList[i]))
                {
                    numIndexesToRemove.Push(i);
                }
            }

            while (numIndexesToRemove.Count &gt; 0)
            {
                numList.RemoveAt(numIndexesToRemove.Pop());
            }

            switch (denList.Count)
            {
                case 0:
                    switch (numList.Count)
                    {
                        case 0:
                            return AbstractClass.Implementation1;
                        case 1:
                            return numList.First&lt;Implementation2&gt;();
                        default:
                            return new Implementation3(numList.OfType&lt;AbstractClass&gt;());
                    }
                case 1:
                    switch (numList.Count)
                    {
                        case 0:
                            return new Implementation4(AbstractClass.Implementation1, denList.First&lt;Implementation2&gt;());
                        case 1:
                            return new Implementation4(numList.First&lt;Implementation2&gt;(), denList.First&lt;Implementation2&gt;());
                        default:
                            return new Implementation4(new Implementation3(numList.OfType&lt;AbstractClass&gt;()), denList.First&lt;Implementation2&gt;());
                    }
                default:
                    switch (numList.Count)
                    {
                        case 0:
                            return new Implementation4(AbstractClass.Implementation1, new Implementation3(denList.OfType&lt;AbstractClass&gt;()));
                        case 1:
                            return new Implementation4(numList.First&lt;Implementation2&gt;(), new Implementation3(denList.OfType&lt;AbstractClass&gt;()));
                        default:
                            return new Implementation4(new Implementation3(numList.OfType&lt;AbstractClass&gt;()), new Implementation3(denList.OfType&lt;AbstractClass&gt;()));
                    }
            }
        }

        public bool Equals(Implementation4 other)
        {
            return Numerator.Equals(other.Numerator) &amp;&amp; Denominator.Equals(other.Denominator);
        }
    }

The heart of what I am trying to test is the &lt;code&gt;Distill&lt;/code&gt; method, which as you can see has the potential to run recursively.  Because a stubbed &lt;code&gt;AbstractClass&lt;/code&gt; is meaningless in this paradigm, it breaks the algorithm logic.  Even trying to test for a stubbed class is somewhat useless, since there is little I can do about it other than throw an exception or pretend that it is an instance of &lt;code&gt;Implementation1&lt;/code&gt;.  I would prefer not to have to rewrite the code under test to accommodate a specific testing framework in that way, but writing the test itself in such a way as never to stub &lt;code&gt;AbstractClass&lt;/code&gt; is what I am trying to do here.

I hope it is apparent how what I am doing differs from a type-safe enum construct, for instance.  Also, I anonymized objects for posting here (as you can tell), and I did not include all methods, so if you&#39;re going to comment to tell me that &lt;code&gt;Implementation4.Equals(Implementation4)&lt;/code&gt; is broken, don&#39;t worry, I&#39;m aware that it is broken here, but my actual code takes care of the issue.

**Another edit:**

Here is an example of one of the factory classes.  It is in the Factories directory of the Pex-generated test project.

    public static partial class Implementation3Factory
    {
        [PexFactoryMethod(typeof(Implementation3))]
        public static Implementation3 Create(IEnumerable&lt;AbstractClass&gt; instances, bool useEmptyConstructor)
        {
            Implementation3 i3 = null;
            if (useEmptyConstructor)
            {
                i3 = new Implementation3();
            }
            else
            {
                i3 = new Implementation3(instances);
            }

            return i3;
        }
    }

In my factory methods for these concrete implementations, it is possible to use any constructor to create the concrete implementation.  In the example, the &lt;code&gt;useEmptyConstructor&lt;/code&gt; parameter controls which constructor to use.  The other factory methods have similar features.  I recall reading, though I cannot immediately find the link, that these factory methods should allow the object to be created in every possible configuration.


How to tell Pex not to stub an abstract class that has concrete implementations

Say I have a `data.frame` object:

    df &lt;- data.frame(name=c(&#39;black&#39;,&#39;black&#39;,&#39;black&#39;,&#39;red&#39;,&#39;red&#39;),
                     type=c(&#39;chair&#39;,&#39;chair&#39;,&#39;sofa&#39;,&#39;sofa&#39;,&#39;plate&#39;),
                     num=c(4,5,12,4,3))

Now I want to count the number of rows (observations) of for each combination of `name` and `type`. This can be done like so:

    table(df[ , c(&quot;name&quot;,&quot;type&quot;)])

or possibly also with `plyr`, (though I am not sure how).

However, how do I get the results incorporated into the original data frame?  So that the results will look like this:

    df
    #    name  type num count
    # 1 black chair   4     2
    # 2 black chair   5     2
    # 3 black  sofa  12     1
    # 4   red  sofa   4     1
    # 5   red plate   3     1

where `count` now stores the results from the aggregation.

A solution with `plyr` could be interesting to learn as well, though I would like to see how this is done with base R.

Count number of rows per group and add result to original data frame

Recently I read that the sign $ is allowed in Java variable names, but has a special meaning. Unfortunately it isn&#39;t mentioned what this special meaning is.

Therefore I ask here: What is the special meaning of $ in variable names in Java?

Here is the exact quote from 

&gt; Java: An Introduction to Problem Solving and Programming

 from Walter Savitch:

&gt; Java does allow the dollar sign symbol $ to appear in an identifier,
&gt; but these identifiers have a special meaning, so you should not use
&gt; the $ symbol in your identifiers.

What is the meaning of $ in a variable name?

Recently I read that the sign $ is allowed in Java variable names, but has a special meaning. Unfortunately it isn't mentioned what this special meaning is.
Therefore I ask here: What is the special meaning of $ in variable names in Java?
Here is the exact quote from
> Java: An Introduction to Problem Solving and Programming
from Walter Savitch:
> Java does allow the dollar sign symbol $ to appear in an identifier,
> but these identifiers have a special meaning, so you should not use
> the $ symbol in your identifiers.

I am having trouble compiling and running my Java code, intended to allow me to interface Java with a shared object for Vensim, a simulation modeling package.

The following code compiles without error:

    javac -d . -cp ./apache-log4j-1.2.16/log4j-1.2.16.jar:./vensim.jar SpatialModel.java     VensimHelper.java VensimException.java VensimContextRepository.java

However, when I try to run the following:

    java -cp ./apache-log4j-1.2.16/log4j-1.2.16.jar:./vensim.jar SpatialModel vars

I get the following error: &quot;Error: Could not find or load main class SpatialModel
&quot;.  My SpatialModel.java code does contain a &#39;main&#39; method (below), so I&#39;m not sure what the problem is - can anyone please help me out?  Thanks.

	import java.io.File;
	import java.text.NumberFormat;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.List;
	
	import org.apache.log4j.Logger;
	
	public class SpatialModel {
	
		private VensimHelper vh;
	
		public static final String DLL_LIBNAME_PARAM = &quot;vensim_lib_nam&quot;;
	
		public static final String MODEL_PATH_PARAM = &quot;vensim_model_path&quot;;
	
		private final static int VENSIM_CONTEXT_CREATION_MAX_FAILURE_COUNT = 10;
	
		public SpatialModel() throws SpatialException {
	
			String libName = System.getProperty(DLL_LIBNAME_PARAM);
			String modelPath = System.getProperty(MODEL_PATH_PARAM);		
	
			if(libName == null || libName.trim().equals(&quot;&quot;)) {
				log.error(&quot;Vensim library name has to be set with -D&quot; + DLL_LIBNAME_PARAM);
				throw new SpatialException(&quot;Vensim library name has to be set with -D&quot; + DLL_LIBNAME_PARAM);
			}
	
			if(modelPath == null || modelPath.trim().equals(&quot;&quot;)) {
				log.error(&quot;Model path has to set with -D&quot; + MODEL_PATH_PARAM);
				throw new SpatialException(&quot;Model path ahs to be set with -D&quot; + MODEL_PATH_PARAM);
			}
	
			for (int i = 0; i &lt; VENSIM_CONTEXT_CREATION_MAX_FAILURE_COUNT &amp;&amp; vh == null; i++) {
				try {
					log.info(&quot;creating new vensim helper\n\tdll lib: &quot; + libName + &quot;\n\tmodel path: &quot; + modelPath);
					vh = new VensimHelper(libName, modelPath);
				} catch (Throwable e) {
					log.error(&quot;An exception was thrown when initializing Vensim, try: &quot; + i, e);
				}
			}
			if (vh == null) {
				throw new SpatialException(&quot;Can&#39;t initialize Vensim&quot;);
			}
	
		}
	
		public static void main(String[] args) throws VensimException {
	
			long before = System.currentTimeMillis();	
			String libName = System.getProperty(DLL_LIBNAME_PARAM);
			String modelPath = System.getProperty(MODEL_PATH_PARAM);
	
			if (libName == null) {
				libName = &quot;libvensim&quot;;
			}
			if(modelPath == null) {
				modelPath = &quot;~/BassModel.vmf&quot;;
			}
	
			System.setProperty(DLL_LIBNAME_PARAM, libName);
			System.setProperty(MODEL_PATH_PARAM, modelPath);
	
			if (args.length &gt; 0 &amp;&amp; args[0].equals(&quot;info&quot;)) {
				System.out.println(new VensimHelper(libName, modelPath).getVensimInfo());
			} else if (args.length &gt; 0 &amp;&amp; args[0].equals(&quot;vars&quot;)) {
				VensimHelper helper = new VensimHelper(libName, modelPath);
				String[] vars = helper.getVariables();
				for (String var : vars) {
					System.out.println(helper.getVariableInfo(var));
				}
			} else {
	
				File f = new File(&quot;.&quot;);
				System.out.println(f.getAbsolutePath());
	
				SpatialModel sm = new SpatialModel();
			}
	
			System.out.println(&quot;Execution time: &quot; + (System.currentTimeMillis() - before));
		}
	
	}

Error: Could not find or load main class

Is there anything like `static class` in java?

What is the meaning of such a class. Do all the methods of the static class need to be `static` too?

Is it required the other way round, that if a class contains all the static methods, shall the class be static too?

What are static classes good  for?

Static Classes In Java

I have list with long values (for example: 1220227200, 1220832000, 1221436800...) which I downloaded from web service. I must convert it to Dates. Unfortunately this way, for example:

    Date d = new Date(1220227200);

returns 1 Jan 1970. Anyone know another way to convert it correctly?

Converting Long to Date in Java returns 1970

I want to name new files created by my Java application with the current timestamp.

I need help with this. How do I name the new files created with the current timestamp? Which classes should I include?

Current timestamp as filename in Java

Is there any built-in method in Java which allows us to convert comma separated String to some container (e.g array, List or Vector)? Or do I need to write custom code for that? 

    String commaSeparated = &quot;item1 , item2 , item3&quot;;
    List&lt;String&gt; items = //method that converts above string into list??

Content Type	Original Author	Original Content on Stackoverflow
Question	anon	View Question on Stackoverflow
Solution 1 - Java	NPE	View Answer on Stackoverflow
Solution 2 - Java	pablosaraiva	View Answer on Stackoverflow

What is the meaning of $ in a variable name?

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

Count number of rows per group and add result to original data frame

How to tell Pex not to stub an abstract class that has concrete implementations

Attributions