Instance/object of StackTraceElement ?

Question

Hi
I will appreciate if someone can help.
I would like to create a object of class StackTraceElement. As soon as I do something simple like the following in class A:
StackTraceElement strE = new StackTraceElement();
strE.getClassName();
I get a compiler error "StackTraceElement() has private access in java.lang.StackT...".
I assume the constructor is private. Do I need to implement a interface. WHAT & HOW can I do to overcome this problem?
Thanks for the help
L

Answer 1

While the need to directly generate StackTraceElements is rare, it does exists. Interpreted languages (like Jython) and languages with sources that compile to Java source (like JSP) come to mind. A public constructor will be added in Tiger:
http://developer.java.sun.com/developer/bugParade/bugs/4712607.html
For now, here's another way to construct StackTraceElements.
import java.io.*;
* Static methods for dealing with stack traces.
public class StackTraces {
    private StackTraces() {} // prevent pointless instantiation
     * Create a StackTraceElement using the given arguments.
     * This method is a work-around until StackTraceElement has a public
     * constructor in Tiger.  This is done by using serialization and
     * deserialization, so it should be compatible with SecurityManagers
     * that prohibit reflection.
     * <p>
     * @see <a href="http://developer.java.sun.com/developer/bugParade/bugs/4712607.html">this RFE </a>
     * @param className
     * @param fileName
     * @param lineNumber
     * @param methodName
     * @param isNative (current implementation ignores this)
     * @return the StackTraceElement
    public static StackTraceElement newStackTraceElement(
        String className, String fileName, int lineNumber,
        String methodName, boolean isNative)
        byte[] copy = new byte[TEMPLATE_BYTES.length];
        for (int i=0; i<copy.length; i++)
            copy=TEMPLATE_BYTES[i];
replaceLineNumber(copy,lineNumber);
copy = replace(copy,TEMPLATE.getClassName(), className);
copy = replace(copy,TEMPLATE.getFileName(), fileName);
copy = replace(copy,TEMPLATE.getMethodName(), methodName);
try {
ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(copy));
return (StackTraceElement) in.readObject();
} catch (Throwable t) {
t.printStackTrace();
return null;
// the original element that we serialize to use as a template
private static StackTraceElement TEMPLATE;
// the serialized bytes of the template above
private static byte[] TEMPLATE_BYTES;
// offset that the line number is stored at in the serialized bytes
private static int LINE_NUMBER_OFFSET;
* This method creates the inital template bytes.
* A better way to handle this would be to load the bytes as a resource,
* or even to directly encode them into the source as a literal.
* That way we would guarantee a fixed starting point.
static {
try {
// create a template and convert it to serialized bytes
TEMPLATE = StackTraceElementTemplate.methodTemplate();
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bytes);
out.writeObject(TEMPLATE);
out.close();
TEMPLATE_BYTES = bytes.toByteArray();
// make sure the bytes are still readable
ObjectInputStream in =
new ObjectInputStream(
new ByteArrayInputStream(TEMPLATE_BYTES));
if (!TEMPLATE.equals(in.readObject()))
throw new IllegalStateException("Unable to verify template");
LINE_NUMBER_OFFSET = findLineNumberOffset();
} catch (Throwable t) {
throw new ExceptionInInitializerError(t);
// Replace the bytes that represent the line number
private static void replaceLineNumber(byte[] bytes, int lineNumber) {
bytes[LINE_NUMBER_OFFSET    ] = (byte) (lineNumber >> 8 & 0xFF);
bytes[LINE_NUMBER_OFFSET + 1] = (byte) (lineNumber & 0xFF);
// Replace the original string with the replacement string
private static byte[] replace(byte[] source, String original, String replacement) {
int offset = startOf(source,getUTF(original));
if (offset<0) {
dumpBytes(source);
throw new IllegalStateException(
original + " not found in " + new String(source));
if (offset + sizeOf(original) > source.length) {
dumpBytes(source);
throw new IllegalStateException(
offset + " not found correctly.");
int sizeDiff = sizeOf(replacement) - sizeOf(original);
byte[] dest = new byte[source.length + sizeDiff];
int destI = 0;
// copy everything up to the replacement string
for (int i=0; i<offset; i++) {
dest[destI] = source[i];
destI++;
// copy the replacement string, instead of the original
for (int i=0; i<sizeOf(replacement); i++) {
dest[destI] = getUTF(replacement)[i];
destI++;
// copy everything after the replacement string
int tail = offset + sizeOf(original);
for (int i=tail; i<source.length; i++) {
dest[destI] = source[i];
destI++;
return dest;
// Dump these bytes in a quasi-readable format
private static void dumpBytes(byte[] bytes) {
for (int i=0; i<bytes.length; i++) {
byte b = bytes[i];
String hex = Integer.toHexString(b & 0xFF);
System.out.println(i + " " + hex + " " + new String(new byte[] ));
// find the start of part within whole
private static int startOf(byte[] whole, byte[] part) {
int wholeI = 0; // whole index
int partI = 0; // part index
while (wholeI<whole.length) {
if (whole[wholeI]==part[partI]) {
wholeI++;
partI++;
if (partI>=part.length)
return wholeI - part.length;
} else {
wholeI++;
partI = 0;
return -1; // not found
private static int sizeOf(String s) {
return getUTF(s).length;
private static byte[] getUTF(String s) {
try {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
DataOutputStream out = new DataOutputStream(bytes);
out.writeUTF(s);
out.close();
return bytes.toByteArray();
} catch (IOException e) {
throw new RuntimeException(e);
private static int findLineNumberOffset() {
* This number was generated by eyeballing the dump.
* A serialization guru could provide a better way of getting it.
return 135;
// This class is just used to generate a template StackTraceElement
private static final class StackTraceElementTemplate {
private static StackTraceElement methodTemplate() {
return new Throwable().getStackTrace()[0];
} // Stack Trace Element Template
public static void main(String[] args) {
dumpBytes(TEMPLATE_BYTES);
System.out.println(newStackTraceElement(
"ClassName","FileName.java",42,"methodName",true));
System.out.println(newStackTraceElement(
"X","Y",0,"Z",true));
String LONG =
"ReallyReallyReallyReallyReallyReallyReallyReallyReally" +
"ReallyReallyReallyReallyReallyReallyReallyReallyReally" +
"ReallyReallyReallyReallyReallyReallyReallyReallyReally" +
"Long"
System.out.println(newStackTraceElement(
LONG + "X", LONG + "Y",60000,LONG + "Z",true));
} // Stack Traces