Mostrar na tela o número da linha do código

Programação Java
#1

quando a gente faz
e.prinstacktrace e uma exceção ocorrer, é mostrado em mostrado o número da linha do código que deu o problema. tem como fazer isso sem ser usando o printstack trace? tipo, eu quero dar um system.out.println em algum lugar e mostrar em que linha foi dado este comando, tem como fazer isso?

#2

System.out.println(“Aqui é a linha 1”);

Isso serve?

#3

hum…
não

#4

De um jeito fácil e/ou performático, não.

Alternativa:
1 - lance uma exceção
2 - trate-a
3 - pegue a stacktrace
4 - imprima

Shoes

#5

O objetivo é debugar a aplicação? Se sim, você deveria usar o debbuger da sua IDE. Fica mais fácil de localizar o erro. O Eclipse conta com um debbuger muito bom. :wink:

#6

[quote=pcalcado]De um jeito fácil e/ou performático, não.
Alternativa:
1 - lance uma exceção
2 - trate-a
3 - pegue a stacktrace
4 - imprima
[/quote]

Bom, se fazer o que o grande Shoes proponha num método é meio fácil, né? Tenho pensado em fazer um método assim. Seria divertido fazer, só que não consegui pensar em usos práticos para aquilo. LOG4J pega o número da linha do código, não pega? Como será que ele faz isso…?

Abraços,
Sami

#7

Performático com certeza não.

Percebi que não é preciso lancar a exceção… basta instânciar uma, pois a linha do código é a linha onde a exceção foi criado, não a de onde foi lançado(a mesma exceção pode ser lançado muitas vezes).

Então, resumindo que ainda não vejo uso prático para isso, aqui vai um exemplo tosco de como pegar a linha do stacktrace. (no fim a idéia foi atraente demais… tinha que experimentar :mrgreen: )

package net.useless;

import java.io.StringWriter;
import java.io.PrintWriter;
import java.io.BufferedReader;
import java.io.StringReader;
import java.io.IOException;
import java.util.StringTokenizer;

public class LineNumberUtility {

    public static Integer getLineNumber() {
        try {
            Exception e = new Exception();
            StringWriter sw = new StringWriter();
            PrintWriter pw = new PrintWriter(sw);
            e.printStackTrace(pw);
            pw.close();

            StringBuffer buf = sw.getBuffer();
            BufferedReader br = new BufferedReader(new StringReader(buf.
                toString()));
            br.readLine(); // exeption type
            br.readLine(); // our code
            String line = br.readLine(); // calling line
            StringTokenizer st = new StringTokenizer(line, ":)");
            st.nextToken();
            String lineNumber = st.nextToken();
            return new Integer(lineNumber);
        } catch(NumberFormatException nfe) {
            return null;
        } catch(IOException ioe) {
            return null;
        }
    }

    public static void main(String[] args) {        
        System.out.println(getLineNumber());
    }

}
#8

Sami, mesmo só instanciar a exceção foi pouco performático?

Eu tinha a impressão que isso estava relacionado a lançar a dita cuja, mas se ela descobre a linha quando instanciada realmente deve acotnecer algo a mais quando é isntanciada…uhmm… hora de um pouco de JLS :twisted:

#9

Ahh, pra falar a verdade, eu nem testei a performance… mas parseando o String e criando todos esses objetos… Eu sei lá… é tudo relativo, né? Dependeria do uso…

E também pensei no mesmo jeito que você. Mas aparentemente não é preciso lançar ela, não.

-Sami

#10