Java System Class Implementation Guide

designjava

The Java System class contains various data members and methods that make perfect sense being there. For instance:

System.in (variable)
System.err (variable)
System.out (variable)
System.exit(int)
System.gc()
System.getSecurityManager()

etc. However, there is one method that I don't understand being there:

System.arraycopy(Object, int, Object, int int)

Copying one array to another feels to me like it belongs in the Arrays class; following from the documentation:

This class contains various methods for manipulating arrays (such as sorting and searching). This class also contains a static factory that allows arrays to be viewed as lists.

Methods for manipulating arrays is what points me to this conclusion, as copying one array to another is surely array manipulation, right?

So my question: why is arraycopy() in System?

Is it a relic of an early Java System class implementation? The method isn't marked as deprecated, so I'm a little bit lost. Furthermore, it doesn't follow the Java camelCase standard, which brings me back to my thinking that it's a relic of the early library design.

Best Answer

System.arraycopy is implemented natively by each JVM. Here is the method declaration:

public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);

This means that it does array copying in the fastest way possible in native assembly instructions. The idea is that this is such a commonly needed, potentially slow functionality that Java should provide this behavior at a low level.

Other ways of copying arrays either wrap System.arraycopy, or use interpreted loops, which would not be as performant.

Related Solutions

Java Programming – When is Method Overloading Appropriate?

You overload when you wish to support different types:

public overload void MyMethod(int value)
{ 
}

public overload void MyMethod(bool value)
{
}

public overload void MyMethod(string value)
{
}

or to support a progressive interface using different parameter lists:

public overload void MyOtherMethod()
{
    this.MyOtherMethod(DefaultValue);
}

public overload void MyOtherMethod(int value)
{
    this.MyOtherMethod(value, DefaultOtherValue);
}

public overload void MyOtherMethod(int value, bool otherValue)
{
    ...
}

You might even get a little crazy and support both different types AND a progressive interface, but you should bear in mind that you need to avoid creating variations in behaviour between overloaded methods. Each overloaded method should be functionally the same as the others in an overloaded group, otherwise it will be unclear as to how, when or why behaviour is being varied. If you want two functions to do something completely different, then you should name them accordingly.

Java Parsing – Better Design Alternatives for Special Cases

Predictive parser you selected (LL(k)) means you will have to solve left-recursion problems. Algorithm for solving direct and indirect recursions is clearly described on wikipedia:

http://en.wikipedia.org/wiki/Left_recursion

Some info can be found in posts here on StackOverflow:

https://stackoverflow.com/questions/2652060/removing-left-recursion https://stackoverflow.com/questions/2999755/removing-left-recursion-in-antlr https://stackoverflow.com/questions/4994036/left-recursion-elimination

In human language (non-scientific :) "left-recursion problem" means you can't endlessly go into recursion with non-terminal (A -> Ab) again and again. At some time you HAVE TO feed parser algorithm with a terminal to breake a loop.

In BNF this could look like:

Recursion Problem:

NT: NT T
NT: T

One solution:

NT: T NT2
NT2: T NT2
NT2:

For your grammar this could look like:

DataType:
    PrimitiveDataType ArrayDimensions
 |  ComplexDataType ArrayDimensions

ArrayDimensions:
    [] ArrayDimensions
 |

If your parser generator doesn't allow empty productions and/or if you want to process array types separately, try something like this:

DataType:
    DataTypeName
 |  ArrayDataType

ArrayDataType:
    DataTypeName ArrayDimensions

DataTypeName:
    PrimitiveDataType
 |  ComplexDataType

ArrayDimensions:
    []
 |  [] ArrayDimensions

Best Answer

Related Solutions

Java Programming – When is Method Overloading Appropriate?

Java Parsing – Better Design Alternatives for Special Cases

Related Topic