txt - leer una linea especifica de un archivo en java

¿Cómo podemos imprimir los números de línea en el registro en Java?

Question

Cómo imprimir números de línea en el registro. Diga al enviar cierta información al registro, también quiero imprimir el número de línea donde ese resultado está en el código fuente. Como podemos ver en el seguimiento de la pila, muestra el número de línea donde se produjo la excepción. Stack trace está disponible en el objeto de excepción.

Otra alternativa podría ser incluir manualmente el número de línea al imprimir en el registro. ¿Hay alguna otra manera?

Answer 1

A mi manera me funciona

String str = "select os.name from os where os.idos="+nameid; try {
PreparedStatement stmt = conn.prepareStatement(str);
ResultSet rs = stmt.executeQuery();
if (rs.next()) {
a = rs.getString("os.n1ame");//<<<----Here is the ERROR
}
stmt.close();
} catch (SQLException e) {
System.out.println("error line : " + e.getStackTrace()[2].getLineNumber());
return a;
}

Answer 2

Aquí está el registrador que usamos.

se ajusta a Android Logger y muestra el nombre de la clase, el nombre del método y el número de línea.

http://www.hautelooktech.com/2011/08/15/android-logging/

Answer 3

El código publicado por @ simon.buchan funcionará ...

Thread.currentThread().getStackTrace()[2].getLineNumber()

Pero si lo llamas en un método, siempre devolverá el número de línea de la línea en el método, así que mejor utiliza el fragmento de código en línea.

Answer 4

Log4J le permite incluir el número de línea como parte de su patrón de salida. Consulte http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/PatternLayout.html para obtener detalles sobre cómo hacer esto (el elemento clave en el patrón de conversión es "L"). Sin embargo, el Javadoc incluye lo siguiente:

ADVERTENCIA La generación de la información de ubicación de la persona que llama es extremadamente lenta. Se debe evitar su uso a menos que la velocidad de ejecución no sea un problema.

Answer 5

Manera rápida y sucia:

System.out.println("I''m in line #" +
new Exception().getStackTrace()[0].getLineNumber());

Con algunos detalles más:

StackTraceElement l = new Exception().getStackTrace()[0];
System.out.println(
l.getClassName()+"/"+l.getMethodName()+":"+l.getLineNumber());

Eso dará como resultado algo como esto:

com.example.mytest.MyClass/myMethod:103

Answer 6

Me veo obligado a responder al no responder su pregunta. Supongo que está buscando el número de línea únicamente para admitir la depuración. Hay mejores formas. Hay formas malintencionadas de obtener la línea actual. Todo lo que he visto es lento. Es mejor utilizar un marco de registro como el del paquete java.util.logging o log4j . Al usar estos paquetes, puede configurar su información de registro para incluir el contexto hasta el nombre de la clase. Entonces cada mensaje de registro sería lo suficientemente único como para saber de dónde vino. Como resultado, su código tendrá una variable ''logger'' que usted llama a través de

logger.debug("a really descriptive message")

en lugar de

System.out.println("a really descriptive message")

Answer 7

Mira este enlace . En ese método puede saltar a su código de línea, cuando hace doble clic en la fila de LogCat.

También puede usar este código para obtener el número de línea:

public static int getLineNumber()
{
int lineNumber = 0;
StackTraceElement[] stackTraceElement = Thread.currentThread()
.getStackTrace();
int currentIndex = -1;
for (int i = 0; i < stackTraceElement.length; i++) {
if (stackTraceElement[i].getMethodName().compareTo("getLineNumber") == 0)
{
currentIndex = i + 1;
break;
}
}
lineNumber = stackTraceElement[currentIndex].getLineNumber();
return lineNumber;
}

Answer 8

No puede garantizar la coherencia del número de línea con el código, especialmente si está compilado para su publicación. No recomendaría usar números de línea para ese propósito de todos modos, sería mejor dar una carga útil del lugar donde se presentó la excepción (el método trivial es configurar el mensaje para incluir los detalles de la llamada al método).

Es posible que desee ver el enriquecimiento de excepciones como una técnica para mejorar el manejo de excepciones http://tutorials.jenkov.com/java-exception-handling/exception-enrichment.html

Answer 9

Si ha sido compilado para su lanzamiento, esto no es posible. Es posible que desee buscar en algo como Log4J que automáticamente le dará información suficiente para determinar muy de cerca dónde se produjo el código registrado.

Answer 10

Terminamos usando una clase personalizada como esta para nuestro trabajo con Android:

import android.util.Log;
public class DebugLog {
public final static boolean DEBUG = true;
public static void log(String message) {
if (DEBUG) {
String fullClassName = Thread.currentThread().getStackTrace()[2].getClassName();
String className = fullClassName.substring(fullClassName.lastIndexOf(".") + 1);
String methodName = Thread.currentThread().getStackTrace()[2].getMethodName();
int lineNumber = Thread.currentThread().getStackTrace()[2].getLineNumber();
Log.d(className + "." + methodName + "():" + lineNumber, message);
}
}
}

Answer 11

Todos estos te dan los números de línea de tu hilo y método actual, que funcionan muy bien si usas un try catch donde esperas una excepción. Pero si desea capturar cualquier excepción no controlada, entonces está utilizando el controlador de excepciones no detectadas predeterminado y el hilo actual devolverá el número de línea de la función del controlador, no el método de clase que arrojó la excepción. En lugar de usar Thread.currentThread () simplemente use el Throwable pasado por el manejador de excepciones:

Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
public void uncaughtException(Thread t, Throwable e) {
if(fShowUncaughtMessage(e,t))
System.exit(1);
}
});

En el uso anterior use e.getStackTrace () [0] en su función de controlador (fShowUncaughtMessage) para obtener al delincuente.

Answer 12

Utilizo este pequeño método que genera el número de línea y rastreo del método que lo llamó.

 Log.d(TAG, "Where did i put this debug code again? " + Utils.lineOut());

¡Haz doble clic en la salida para ir a esa línea de código fuente!

Es posible que deba ajustar el valor del nivel dependiendo de dónde coloque su código.

public static String lineOut() {
int level = 3;
StackTraceElement[] traces;
traces = Thread.currentThread().getStackTrace();
return (" at " + traces[level] + " " );
}

Answer 13

Yo recomendaría usar un kit de herramientas de registro como log4j . El registro se puede configurar a través de archivos de propiedades en tiempo de ejecución, y puede activar / desactivar características como el número de línea / registro de nombre de archivo.

Si mira el javadoc para http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/PatternLayout.html obtendrá la lista completa de opciones: lo que busca es% L.

Answer 14

primero, el método general (en una clase de utilidad, en el antiguo código java1.4 simple, puede que tenga que volver a escribirlo para java1.5 y más)

/**
* Returns the first "[class#method(line)]: " of the first class not equal to "StackTraceUtils" and aclass. <br />
* Allows to get past a certain class.
* @param aclass class to get pass in the stack trace. If null, only try to get past StackTraceUtils.
* @return "[class#method(line)]: " (never empty, because if aclass is not found, returns first class past StackTraceUtils)
*/
public static String getClassMethodLine(final Class aclass) {
final StackTraceElement st = getCallingStackTraceElement(aclass);
final String amsg = "[" + st.getClassName() + "#" + st.getMethodName() + "(" + st.getLineNumber()
+")] <" + Thread.currentThread().getName() + ">: ";
return amsg;
}

Luego, el método de utilidad específico para obtener el stackElement correcto:

/**
* Returns the first stack trace element of the first class not equal to "StackTraceUtils" or "LogUtils" and aClass. <br />
* Stored in array of the callstack. <br />
* Allows to get past a certain class.
* @param aclass class to get pass in the stack trace. If null, only try to get past StackTraceUtils.
* @return stackTraceElement (never null, because if aClass is not found, returns first class past StackTraceUtils)
* @throws AssertionFailedException if resulting statckTrace is null (RuntimeException)
*/
public static StackTraceElement getCallingStackTraceElement(final Class aclass) {
final Throwable t = new Throwable();
final StackTraceElement[] ste = t.getStackTrace();
int index = 1;
final int limit = ste.length;
StackTraceElement st = ste[index];
String className = st.getClassName();
boolean aclassfound = false;
if(aclass == null) {
aclassfound = true;
}
StackTraceElement resst = null;
while(index < limit) {
if(shouldExamine(className, aclass) == true) {
if(resst == null) {
resst = st;
}
if(aclassfound == true) {
final StackTraceElement ast = onClassfound(aclass, className, st);
if(ast != null) {
resst = ast;
break;
}
}
else
{
if(aclass != null && aclass.getName().equals(className) == true) {
aclassfound = true;
}
}
}
index = index + 1;
st = ste[index];
className = st.getClassName();
}
if(isNull(resst)) {
throw new AssertionFailedException(StackTraceUtils.getClassMethodLine() + " null argument:" + "stack trace should null"); //$NON-NLS-1$
}
return resst;
}
static private boolean shouldExamine(String className, Class aclass) {
final boolean res = StackTraceUtils.class.getName().equals(className) == false && (className.endsWith(LOG_UTILS
) == false || (aclass !=null && aclass.getName().endsWith(LOG_UTILS)));
return res;
}
static private StackTraceElement onClassfound(Class aclass, String className, StackTraceElement st) {
StackTraceElement resst = null;
if(aclass != null && aclass.getName().equals(className) == false)
{
resst = st;
}
if(aclass == null)
{
resst = st;
}
return resst;
}

Answer 15

puede usar -> Reporter.log ("");

Answer 16

De Angsuman Chakraborty :

/** Get the current line number.
* @return int - Current line number.
*/
public static int getLineNumber() {
return Thread.currentThread().getStackTrace()[2].getLineNumber();
}

Answer 17

Debajo del código se ha probado el código para la línea de registro, no hay nombre de clase y nombre de método desde donde se llama el método de registro

public class Utils {
/*
* debug variable enables/disables all log messages to logcat
* Useful to disable prior to app store submission
*/
public static final boolean debug = true;
/*
* l method used to log passed string and returns the
* calling file as the tag, method and line number prior
* to the string''s message
*/
public static void l(String s) {
if (debug) {
String[] msg = trace(Thread.currentThread().getStackTrace(), 3);
Log.i(msg[0], msg[1] + s);
} else {
return;
}
}
/*
* l (tag, string)
* used to pass logging messages as normal but can be disabled
* when debug == false
*/
public static void l(String t, String s) {
if (debug) {
Log.i(t, s);
} else {
return;
}
}
/*
* trace
* Gathers the calling file, method, and line from the stack
* returns a string array with element 0 as file name and
* element 1 as method[line]
*/
public static String[] trace(final StackTraceElement e[], final int level) {
if (e != null && e.length >= level) {
final StackTraceElement s = e[level];
if (s != null) { return new String[] {
e[level].getFileName(), e[level].getMethodName() + "[" + e[level].getLineNumber() + "]"
};}
}
return null;
}
}

Answer 18

private static final int CLIENT_CODE_STACK_INDEX;
static {
// Finds out the index of "this code" in the returned stack Trace - funny but it differs in JDK 1.5 and 1.6
int i = 0;
for (StackTraceElement ste : Thread.currentThread().getStackTrace()) {
i++;
if (ste.getClassName().equals(Trace.class.getName())) {
break;
}
}
CLIENT_CODE_STACK_INDEX = i;
}
private String methodName() {
StackTraceElement ste=Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX+1];
return ste.getMethodName()+":"+ste.getLineNumber();
}