printstacktrace方法,如何利用printStackTrace()把异常输出到文本
printstacktrace方法,如何利用printStackTrace()把异常输出到文本详细介绍
本文目录一览： printstacktrace什么意思
捕获异常的语句：e.printStackTrace();
1、e是Throwable的实例异常对象，用在catch语句中，相当于一个形参，一旦try捕获到了异常，那么就将这个异常信息交给e，由e处理，printStackTrace()是异常类的一个方法。与它重载的方法还有printStackTrace(PrintStream s) 和printStackTrace(PrintWriter s)。
2、在Throwable类中printStackTrace()内部是这样执行的：
public void printStackTrace() {printStackTrace(System.err);
}
3、它调用了printStackTrace(PrintStream s)方法。err是System类当中的一个静态PrintStream类型字段。所以它能传递进去。
扩展资料
public void printStackTrace()将此 throwable 及其追踪输出至标准错误流。此方法将此 Throwable 对象的堆栈跟踪输出至错误输出流，作为字段 System.err 的值。输出的第一行包含此对象的 toString() 方法的结果。
剩余行表示以前由方法 fillInStackTrace() 记录的数据。此信息的格式取决于实现，但以下示例是最常见的：java.lang.NullPointerException
at MyClass.mash(MyClass.java:9)
at MyClass.crunch(MyClass.java:6)
at MyClass.main(MyClass.java:3)
参考资料
百度百科-Java
深层次的输出异常调用的流程。
比方说最终显示的是个NullPointException，用 e.printStackTrace() 就可以输出整个调用流程，比方说是 main 方法调用了某个类，这个类又初始化了一个值，然后再××××的，最后到出错这行代码抛出个异常。
java中异常的“printStackTrace()”方法是做什么的
printStackTrace()是超类Throwable的一个方法,该方法的作用是打印出抛出异常时当前位置的调用层次关系.
是用来打印异常信息的.
此方法将此 Throwable 对象的堆栈跟踪输出至错误输出流，作为字段 System.err 的值。输出的第一行包含此对象的 toString() 方法的结果。
将 throwable 及其追踪输出至标准错误流。
多数异常类中都提供此方法。有的带参数，有的不带参数。具体还是以查看JAVA API为准。
后台打印错误信息
如何利用printStackTrace()把异常输出到文本
可以通过“FileOutputStream”创建文件实例，之后过“OutputStreamWriter”流的形式进行将获取到的异常信息存储，举例：
OutputStreamWriter pw = null;//定义一个流
pw = new OutputStreamWriter(new FileOutputStream(“D:/test.txt”),"GBK");//确认流的输出文件和编码格式，此过程创建了“test.txt”实例
pw.write(printStackTrace());//此处就是需要写入到文本的信息
pw.close();//关闭流
备注：文件流用完之后必须及时通过close方法关闭，否则会一直处于打开状态，直至程序停止，增加系统负担。
不用重写，public void printStackTrace(PrintWriter s)，Java本来有这个方法。
源代码如下：已测试成功
import java.io.*;
public class ThrowableTest extends FileNotFoundException {
public static void main(String argv[]) {
try {
FileInputStream f = new FileInputStream("D:\\test.txt");
} catch (FileNotFoundException e) {
try {
PrintWriter p = new PrintWriter(new FileOutputStream("D:\\errors.txt"));
p.println("=== toString() ===");
p.println(e.toString()+"\n");
p.println("=== getLocalizedMessage() ===");
p.println(e.getLocalizedMessage());
p.println("=== getMessage() ===\n");
p.println(e.getMessage());
p.println("=== printStackTrace() ===");
e.printStackTrace(p);
p.flush();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
}
e.printStackTrace() ; 是什么意思？
当命令中的try执行语句中出现异常的时候，程序会选择转而执行catch中的语句。java程序在运行的时候，系统会自动地将写在catch语句括号中的Exception e的内容进行初始化，也就是对Exception类型的对象进行实例化。
“Exception e”中的“e”是指此对象引用名称。在Exception e的内容初始化之后，e（引用的对象）会自动调用Exception类中程序指定的方法，“e.printStackTrace() ;”也就因此出现。
JAVA程序中的“try-catch-finally语句块”一般是用来在程序中捕获异常，并对出现的异常进行处理的，例如下图：
JAVA文件追加的几种方式
java文件追加内容的三种方法：
方法一：
public static void writeToTxtByRandomAccessFile(File file, String str){
RandomAccessFile randomAccessFile = null;
try {
randomAccessFile = new RandomAccessFile(file,"rw");
long len = randomAccessFile.length();
randomAccessFile.seek(len);
randomAccessFile.writeBytes(new String(str.getBytes(),"iso8859-1")+"\r\n");
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e) {
e.printStackTrace();
}finally{
try {
randomAccessFile.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
方法二：
public static void writeToTxtByFileWriter(File file, String content){
BufferedWriter bw = null;
try {
FileWriter fw = new FileWriter(file, true);
bw = new BufferedWriter(fw);
bw.write(content);
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
方法三：
public static void writeToTxtByOutputStream(File file, String content){
BufferedOutputStream bufferedOutputStream = null;
try {
bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(file, true));
bufferedOutputStream.write(content.getBytes());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch(IOException e ){
e.printStackTrace();
}finally{
try {
bufferedOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
no stack trace available 错误是什么原因
catch(Exception e){
e.printStackTrace() ;
}
当try语句中出现异常是时，会执行catch中的语句，java运行时系统会自动将catch括号中的Exception e 初始化，也就是实例化Exception类型的对象。e是此对象引用名称。然后e（引用）会自动调用Exception类中指定的方法，也就出现了e.printStackTrace() ;。
printStackTrace()方法的意思是：在命令行打印异常信息在程序中出错的位置及原因。（这是白话解释，比较容易理解）
no stack trace available
解释：没有堆栈跟踪可用
stack trace 中包括三部分，分别为：.bss .text .data
bss： 表示程序中未初始化的全局变量的一块内存区域
text： 表示程序中已初始化的全局变量的一块内存区域
data：表示存放程序执行代码的一块内存区域
java问题，动态修改java类里面的一个方法
//创建文件输出流
PrintStream ps=new PrintStream("./log.txt");
//设置新的输出流 System.setErr(ps);
System类的out、err、in成员变量都是final类型的，不能直接复制，要通过setOut()、setErr()，setIn()方法来改变流。上例是通过setOut()方法改变输入流输入位置，将输出重定向到一个固定的目录，实现程序日志
e.printstacktrace 默认用的就是System的输出
public class PersistenceException { public PersistenceException(Exception e){ // 这里对错误信息进行持久化 System.out.println("持久化代码放这里..."); // 如果需要在控制台同时打印出日志的话 e.printStackTrace(); } /**测试主方法*/ public static void main(String[] args){ int a = 0; int b = 0; try { int c = a/b; }catch (Exception e){ new PersistenceException(e); } }}
java中求一个整数个十百千位的方法
import java.util.Scanner;public class Test{ static int[] a=new int[4];//a[0]~a[3]:个位数~千位数 public static void main(String[] args){ Scanner in=new Scanner(System.in); try{ System.out.print("输入一个整数"); int x=in.nextInt(); getValue(x);//求出个位数~千位数的方法 in.close(); } catch(Exception e){ e.printStackTrace(); } } public static void getValue(int x){ int x1=x; //先得到x的位数 int i=1,k,count=0;//count为x的位数 for(i=0;i<4;i++)//计算到千位即可 if(x1/Math.pow(10, i)!=0) count++; for(k=0;k
<count;k++){ 依次求出个位数~千位数 a[k]="x1%10;" x1="x1/10;" } system.out.println(x+"的个位数:"+a[0]); system.out.println(x+"的十位数:"+a[1]); system.out.println(x+"的百位数:"+a[2]); system.out.println(x+"的千位数:"+a[3]); }}
办法1：除以10，保留商数，余数就是个位，商再次除以10......；方法2：用函数转换成10进制字符串，字符串的最后一位是个位，倒数第二位是十位....
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Count {
public static void main(String[] args) {
System.out.println("请输入要看百千位的数(0-65535)");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String numberStr = null;
int numberInt = 0;
try {
numberStr = br.readLine(); //冲键盘读入数字
numberInt = Integer.parseInt(numberStr); //转换为数字
} catch (IOException e) {
e.printStackTrace();
} catch (NumberFormatException e) {
System.out.println("您输入的数据有误！");
}
System.out.println(numberStr.length());
PrintCHS(numberStr);
}
public static void PrintCHS(String number){
switch(number.length()){
case 1:System.out.println("个位是："+number);break;
case 2:
System.out.println("十位是：" + number.substring(0, 1));
PrintCHS(number.substring(1));
break;
case 3:
System.out.println("百位是：" + number.substring(0, 1));
PrintCHS(number.substring(1));
break;
case 4:
System.out.println("千位是：" + number.substring(0, 1));
PrintCHS(number.substring(1));
break;
case 5:
System.out.println("万位是：" + number.substring(0, 1));
PrintCHS(number.substring(1));
break;
default:
System.out.println("输入有误！");
break;
}
}}
不知道这个能不能帮你
主要的思想是先将这个整数对10求余，得到个位数，再将整数除以10得到个位数以外的其余数（除以10之后因为数为int类型所以原先的个位数作为小数被舍去），然后重复操作得到其余位数
示例代码如下（因为要求个十百千位，所以没有写求更高位数的代码）：
运行结果如下：
以下是文字版的代码：
import java.util.Scanner;
public class Test{
static int[] a=new int[4];//a[0]~a[3]:个位数~千位数
public static void main(String[] args){
Scanner in=new Scanner(System.in);
try{
System.out.print("输入一个整数");
int x=in.nextInt();
getValue(x);//求出个位数~千位数的方法
in.close();
}
catch(Exception e){
e.printStackTrace();
}
}
public static void getValue(int x){
int x1=x;
//先得到x的位数
int i=1,k,count=0;//count为x的位数
for(i=0;i<4;i++)//计算到千位即可
if(x1/Math.pow(10, i)!=0)
count++;
for(k=0;k
<count;k++){ 依次求出个位数~千位数
a[k]=x1%10;
x1=x1/10;
}
System.out.println(x+"的个位数:"+a[0]);
System.out.println(x+"的十位数:"+a[1]);
System.out.println(x+"的百位数:"+a[2]);
System.out.println(x+"的千位数:"+a[3]);
}
}
如何在程序异常退出前输出当前进程的堆栈信息 Backtraces
打印堆栈是调试的常用方法，一般在系统异常时，我们可以将异常情况下的堆栈打印出来，这样十分方便错误查找。实际上还有另外一个非常有用的功能：分析代码的行为。android代码太过庞大复杂了，完全的静态分析经常是无从下手，因此通过打印堆栈的动态分析也十分必要。
Android打印堆栈的方法，简单归类一下
1. zygote的堆栈dump
实际上这个可以同时dump java线程及native线程的堆栈，对于java线程，java堆栈和native堆栈都可以得到。
使用方法很简单，直接在adb shell或串口中输入：
[plain] view plaincopy
kill -3
输出的trace会保存在 /data/anr/traces.txt文件中。这个需要注意，如果没有 /data/anr/这个目录或/data/anr/traces.txt这个文件，需要手工创建一下，并设置好读写权限。
如果需要在代码中，更容易控制堆栈的输出时机，可以用以下命令获取zygote的core dump:
[java] view plaincopy
Process.sendSignal(pid, Process.SIGNAL_QUIT);
原理和命令行是一样的。
不过需要注意两点：
adb shell可能会没有权限，需要root。
android 4.2中关闭了native thread的堆栈打印，详见 dalvik/vm/Thread.cpp的dumpNativeThread方法：
[cpp] view plaincopy
dvmPrintDebugMessage(target,
"\"%s\" sysTid=%d nice=%d sched=%d/%d cgrp=%s\n",
name, tid, getpriority(PRIO_PROCESS, tid),
schedStats.policy, schedStats.priority, schedStats.group);
dumpSchedStat(target, tid);
// Temporarily disabled collecting native stacks from non-Dalvik
// threads because sometimes they misbehave.
//dvmDumpNativeStack(target, tid);
Native堆栈的打印被关掉了！不过对于大多数情况，可以直接将这个注释打开。
2. debuggerd的堆栈dump
debuggerd是android的一个daemon进程，负责在进程异常出错时，将进程的运行时信息dump出来供分析。debuggerd生 成的coredump数据是以文本形式呈现，被保存在 /data/tombstone/ 目录下(名字取的也很形象，tombstone是墓碑的意思)，共可保存10个文件，当超过10个时，会覆盖重写最早生成的文件。从4.2版本开 始，debuggerd同时也是一个实用工具：可以在不中断进程执行的情况下打印当前进程的native堆栈。使用方法是:
[plain] view plaincopy
debuggerd -b
这可以协助我们分析进程执行行为，但最最有用的地方是：它可以非常简单的定位到native进程中锁死或错误逻辑引起的死循环的代码位置。
3. java代码中打印堆栈
Java代码打印堆栈比较简单， 堆栈信息获取和输出，都可以通过Throwable类的方法实现。目前通用的做法是在java进程出现需要注意的异常时，打印堆栈，然后再决定退出或挽救。通常的方法是使用exception的printStackTrace()方法：
[java] view plaincopy
try {
...
} catch (RemoteException e) {
e.printStackTrace();
...
}
当然也可以只打印堆栈不退出，这样就比较方便分析代码的动态运行情况。Java代码中插入堆栈打印的方法如下：
[java] view plaincopy
Log.d(TAG,Log.getStackTraceString(new Throwable()));
4. C++代码中打印堆栈
C++也是支持异常处理的，异常处理库中，已经包含了获取backtrace的接口，Android也是利用这个接口来打印堆栈信息的。在Android的C++中，已经集成了一个工具类CallStack，在libutils.so中。使用方法：
[cpp] view plaincopy
#include
...
CallStack stack;
stack.update();
stack.dump();
使用方式比较简单。目前Andoid4.2版本已经将相关信息解析的很到位，符号表查找，demangle，偏移位置校正都做好了。
[plain] view plaincopy
5. C代码中打印堆栈
C代码，尤其是底层C库，想要看到调用的堆栈信息，还是比较麻烦的。 CallStack肯定是不能用，一是因为其实C++写的，需要重新封装才能在C中使用，二是底层库反调上层库的函数，会造成链接器循环依赖而无法链接。 不过也不是没有办法，可以通过android工具类CallStack实现中使用的unwind调用及符号解析函数来处理。
这里需要注意的是，为解决链接问题，最好使用dlopen方式，查找需要用到的接口再直接调用，这样会比较简单。如下为相关的实现代码，只需要在要 打印的文件中插入此部分代码，然后调用getCallStack()即可，无需包含太多的头文件和修改Android.mk文件：
[cpp] view plaincopy
#define MAX_DEPTH 31
#define MAX_BACKTRACE_LINE_LENGTH 800
#define PATH "/system/lib/libcorkscrew.so"
typedef ssize_t (*unwindFn)(backtrace_frame_t*, size_t, size_t);
typedef void (*unwindSymbFn)(const backtrace_frame_t*, size_t, backtrace_symbol_t*);
typedef void (*unwindSymbFreeFn)(backtrace_symbol_t*, size_t);
static void *gHandle = NULL;
static int getCallStack(void){
ssize_t i = 0;
ssize_t result = 0;
ssize_t count;
backtrace_frame_t mStack[MAX_DEPTH];
backtrace_symbol_t symbols[MAX_DEPTH];
unwindFn unwind_backtrace = NULL;
unwindSymbFn get_backtrace_symbols = NULL;
unwindSymbFreeFn free_backtrace_symbols = NULL;
// open the so.
if(gHandle == NULL) gHandle = dlopen(PATH, RTLD_NOW);
// get the interface for unwind and symbol analyse
if(gHandle != NULL) unwind_backtrace = (unwindFn)dlsym(gHandle, "unwind_backtrace");
if(gHandle != NULL) get_backtrace_symbols = (unwindSymbFn)dlsym(gHandle, "get_backtrace_symbols");
if(gHandle != NULL) free_backtrace_symbols = (unwindSymbFreeFn)dlsym(gHandle, "free_backtrace_symbols");
if(!gHandle ||!unwind_backtrace ||!get_backtrace_symbols || !free_backtrace_symbols ){
ALOGE("Error! cannot get unwind info: handle:%p %p %p %p",
gHandle, unwind_backtrace, get_backtrace_symbols, free_backtrace_symbols );
return result;
}
count= unwind_backtrace(mStack, 1, MAX_DEPTH);
get_backtrace_symbols(mStack, count, symbols);
for (i = 0; i < count; i++) {
char line[MAX_BACKTRACE_LINE_LENGTH];
const char* mapName = symbols[i].map_name ? symbols[i].map_name : "
";
const char* symbolName =symbols[i].demangled_name ? symbols[i].demangled_name : symbols[i].symbol_name;
size_t fieldWidth = (MAX_BACKTRACE_LINE_LENGTH - 80) / 2;
if (symbolName) {
uint32_t pc_offset = symbols[i].relative_pc - symbols[i].relative_symbol_addr;
if (pc_offset) {
snprintf(line, MAX_BACKTRACE_LINE_LENGTH, "#%02d pc %08x %.*s (%.*s+%u)",
i, symbols[i].relative_pc, fieldWidth, mapName,
fieldWidth, symbolName, pc_offset);
} else {
snprintf(line, MAX_BACKTRACE_LINE_LENGTH, "#%02d pc %08x %.*s (%.*s)",
i, symbols[i].relative_pc, fieldWidth, mapName,
fieldWidth, symbolName);
}
} else {
snprintf(line, MAX_BACKTRACE_LINE_LENGTH, "#%02d pc %08x %.*s",
i, symbols[i].relative_pc, fieldWidth, mapName);
}
ALOGD("%s", line);
}
free_backtrace_symbols(symbols, count);
return result;
}
对sched_policy.c的堆栈调用分析如下,注意具体是否要打印，在哪里打印，还可以通过pid、uid、property等来控制一下，这样就不会被淹死在trace的汪洋大海中。
[plain] view plaincopy
D/SchedPolicy( 1350): #00 pc 0000676c /system/lib/libcutils.so
D/SchedPolicy( 1350): #01 pc 00006b3a /system/lib/libcutils.so (set_sched_policy+49)
D/SchedPolicy( 1350): #02 pc 00010e82 /system/lib/libutils.so (androidSetThreadPriority+61)
D/SchedPolicy( 1350): #03 pc 00068104 /system/lib/libandroid_runtime.so (android_os_Process_setThreadPriority(_JNIEnv*, _jobject*, int, int)+7)
D/SchedPolicy( 1350): #04 pc 0001e510 /system/lib/libdvm.so (dvmPlatformInvoke+112)
D/SchedPolicy( 1350): #05 pc 0004d6aa /system/lib/libdvm.so (dvmCallJNIMethod(unsigned int const*, JValue*, Method const*, Thread*)+417)
D/SchedPolicy( 1350): #06 pc 00027920 /system/lib/libdvm.so
D/SchedPolicy( 1350): #07 pc 0002b7fc /system/lib/libdvm.so (dvmInterpret(Thread*, Method const*, JValue*)+184)
D/SchedPolicy( 1350): #08 pc 00060c30 /system/lib/libdvm.so (dvmCallMethodV(Thread*, Method const*, Object*, bool, JValue*, std::__va_list)+271)
D/SchedPolicy( 1350): #09 pc 0004cd34 /system/lib/libdvm.so
D/SchedPolicy( 1350): #10 pc 00049382 /system/lib/libandroid_runtime.so
D/SchedPolicy( 1350): #11 pc 00065e52 /system/lib/libandroid_runtime.so
D/SchedPolicy( 1350): #12 pc 0001435e /system/lib/libbinder.so (android::BBinder::transact(unsigned int, android::Parcel const&, android::Parcel*, unsigned int)+57)
D/SchedPolicy( 1350): #13 pc 00016f5a /system/lib/libbinder.so (android::IPCThreadState::executeCommand(int)+513)
D/SchedPolicy( 1350): #14 pc 00017380 /system/lib/libbinder.so (android::IPCThreadState::joinThreadPool(bool)+183)
D/SchedPolicy( 1350): #15 pc 0001b160 /system/lib/libbinder.so
D/SchedPolicy( 1350): #16 pc 00011264 /system/lib/libutils.so (android::Thread::_threadLoop(void*)+111)
D/SchedPolicy( 1350): #17 pc 000469bc /system/lib/libandroid_runtime.so (android::AndroidRuntime::javaThreadShell(void*)+63)
D/SchedPolicy( 1350): #18 pc 00010dca /system/lib/libutils.so
D/SchedPolicy( 1350): #19 pc 0000e3d8 /system/lib/libc.so (__thread_entry+72)
D/SchedPolicy( 1350): #20 pc 0000dac4 /system/lib/libc.so (pthread_create+160)
D/SchedPolicy( 1350): #00 pc 0000676c /system/lib/libcutils.so
D/SchedPolicy( 1350): #01 pc 00006b3a /system/lib/libcutils.so (set_sched_policy+49)
D/SchedPolicy( 1350): #02 pc 00016f26 /system/lib/libbinder.so (android::IPCThreadState::executeCommand(int)+461)
D/SchedPolicy( 1350): #03 pc 00017380 /system/lib/libbinder.so (android::IPCThreadState::joinThreadPool(bool)+183)
D/SchedPolicy( 1350): #04 pc 0001b160 /system/lib/libbinder.so
D/SchedPolicy( 1350): #05 pc 00011264 /system/lib/libutils.so (android::Thread::_threadLoop(void*)+111)
D/SchedPolicy( 1350): #06 pc 000469bc /system/lib/libandroid_runtime.so (android::AndroidRuntime::javaThreadShell(void*)+63)
D/SchedPolicy( 1350): #07 pc 00010dca /system/lib/libutils.so
D/SchedPolicy( 1350): #08 pc 0000e3d8 /system/lib/libc.so (__thread_entry+72)
D/SchedPolicy( 1350): #09 pc 0000dac4 /system/lib/libc.so (pthread_create+160)
6. 其它堆栈信息查询