java.lang.NullPointerException错误处理方法及原因分析
java.lang.NullPointerException处理之完整方案与原因分析！java.lang.NullPointerException错误的神秘面纱!史上最全,最深入的分析! 让你看完这篇不用再看下一篇废话不多说。下面开始全面分析。（环境：tomcat+sql server+jsp）本质上。这个错误是数据库连接的错误（当然前提是代码本身没错，因为我们说的是源码！）。经过我舍友的仔细研究（他是个低调的人，所以就由我帮他写了。必须达到以下条件（错误原因就是以下六条没配置完）：1.JAVA环境配置正确。2.源码里面的包没有与tomcat的包冲突。3.把数据库文件给导入到了SQL SERVER（或者其它数据库系统）里面。并且数据库系统正在运行。4.添加了数据源。5.数据库源文件的系统类型匹配(不匹配重新建立数据库，源码里面一般含有数据库的表结构及内容。)，且数据库的连接密码正确。6.JDBC驱动文件(或者其它)存在且放在tomcat的lib目录下面。（msbase.jar，mssqlserver.jarmsutil.jar）下面开始说如何配置以上几项。1.JAVA环境变量配置-》。按照里面说的配置。最后测试javac能否显示信息。显示成功完成此步。2.网站源码-》WEB-INF-》lib里面的.jar包没有和tomcat的lib目录下的包重复。有的话把源码里面的包删除。3.SQL SERVER企业管理器。在数据库上右键-》所有任务-》附加数据库。把源码里面的数据库.mdf文件选上。所有都选SA（一般是这样选择，选其它的话。连接数据库的时候得把用户名密码写对。）。确定。4.win+R-&odbcad32-》回车-》添加-》选择SQL SERVER -&数据源名称应用数据库文件的名称。服务器一般是 (local)-&使用用户登录-》填入sa +密码-》更改默认数据库为添加的-》下一步-》完成-》确定。5.数据库系统类型是否匹配可在网站源码-》src-》...-》toolsbean-》DB.java（这里指数据库连接的源码文件）找到这样一句private final String url = &jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db_Blog&;这里就可以看到数据库是SQL SERVER以及连接用户名密码。private final String userName = &sa&;private final String password = &sa&;将其修改为你的。但是我们这里只是修改的源码。这还不够。把改好的DB.java放到C盘根目录。启动cmd cd \ 命令切换到C根目录。用javac DB.java生成一个DB.class。把这个文件复制到WEB-INF-&classes-&....-&toolsbean下面替换原来的DB.class6.把源码LIB下面的msbase.jar，mssqlserver.jarmsutil.jar（JDBC驱动）剪切到tomcat的LIB目录下面。复制会存在包冲突。OK。完了。怎么还不能还是没用？嘿嘿。最后还得把SQL SERVER 2000升级到SP4版本哦。这个就不知道是什么原因了。反正这步是相当之关键。前面全部配置正确。如果没升级也还是连接不上数据库。这下可以测试了：http://localhost:8080/源码目录 是不是终于把主页显示出来了？
阅读本文后您有什么感想? 已有
人给出评价!
注：您的评论需要经过审核才会显示出来
没有查询到任何记录。
Copyright &
PC6下载().All Rights Reserved
备案编号:湘ICP备号在Java中对值为null的指针调用任何方法，就会引发空指针异常(java.lang.NullPointerException)。空指针异常绝对 是Java中最难查找和调试的一种异常，你永远无法得到任何有用的调试信息。通过个人日常总结和网上搜集整理，归纳如下，供大家参考。空指针异常产生的主 要原因如下:所以在Java中一般报空指针异常的原因有以下几种： 1字符串变量未初始化； 2接口类型的对象没有用具体的类初始化，比如： List lt；会报错 List lt = new ArrayList()；则不会报错了 3当一个对象的值为空时，你没有判断为空的情况。你可以试着把下面的代码前加一行代码： if(rb!=null && rb!="") 改成： if(rb==null); if(rb!==null&&rb!="") 或者if((“”).equals(rb)) 空指针的解决办法： &&&&&& 重点关注报错发生的所在行，通过空指针异常产生的两条主要原因诊断具体的错误。同时为了避免空指针的发生，最好在做判断处理时将“null”或者空值放于 设定的值之前。 常见空指针异常的简要分析： （1）空指针错误 &&& Java中的8种基本数据类型，变量的值可以有其默认值，加入没有对其正常赋值，java虚拟机是不能 正确编译通过的，因此使用基本的Java数据类型一般不会是不会引起空指针异常的。实际开发中，大多数的空指针异常主要与对象的操作相关。 下面列出可能发生空指针异常的几种情况及相应解决方案： 代码段1： 　　out.println(request.getParameter("username")); 　　分析：代码段1的功能十分简单，就是输出用户输入"username"的值。 &&&&&& 说明：看上去，上面的语句找不出什么语法错误，而且在大多数情况下也遇不到什么问题。但是，如果某个用户在输入数据时并没有提供表单 域"username" 的值，或通过某种途径绕过表单直接输入时，此request.getParameter("username")的值为空（注意不是空字符串，是空对象 null。），out对象的println方法是无法直接对空对象操作的，因此代码段1所在的JSP页面将会抛出 "Java.lang.NullPointerException"异常。而且即使对象可能为空时，也调用Java.lang.Object或 Object对象本身的一些方法如toString()， equal(Object obj)等操作。 代码段2： 　　String userName = request.getParameter("username"); 　　If (userName.equals("root")) 　　{....} 　　分析：代码段2的功能是检测用户提供的用户名，如果是用户名称为"root"的用户时，就执行一些特别的操 作。&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& &&&&& 说明：在代码段2中，如果有用户没有提供表单域"username"的值时，字符串对象userName为null值，不能够将一个null的对象与另一 个对象直接比较，同样，代码段2所在的JSP页面就会抛空指针错误。 一个小技巧：如果要把某个方法的返回值与常量做比较，把常量放在前面，可以避免调用null对象的equals方法。譬如：& If ("root".equals(userName)) 　　{....} & 即使userName对象返回了null对象，这里也不会有空指针异常，可以照常运转。 代码段3： 　　String userName = session.getAttribute("session.username").toString(); &&&&&&& 分析：代码段3的功能是将session中session.username的值取出，并将该值赋给字符串对象userName。 &&&&&& 说明：在一般情况下，如果在用户已经进行某个会话，则不会出现什么问题；但是，如果此时应用服务器重新启动，而用户还没有重新登录，（也可能是用户关闭浏 览器，但是仍打开原来的页面。）那么，此时该session的值就会失效，同时导致session中的session.username的值为空。对一个 为 null的对象的直接执行toString()操作，就会导致系统抛出空指针异常。 代码段4： public static void main(String args[]){ &&&&&& Person p= &&&&&&& p.setName("张三")； &&& System.out.println(p.getName()); } 分析：声明一个Person对象，并打印出该对象的中的Name名字。 说明：这个时候你的p就出现空指针异常，因为你只是声明了这个Person类型的对象并没有创建对象，所以它的堆里面没有地址引用，切忌你要用对 象掉用方法的时候一定要创建对象。
阅读(...) 评论()java&数组复制:System.arrayCopy&深入解析
先看ArrayList源码中数组复制的代码：
其实ArrayList
就是一个数组的形式存放数据的。没有高深的地方。
他的性能在于他的索引能力，正因为他是数组形式，所以索引元素的时候他表现得非常的快速成,试想一下，只要知道这个元素的索引，E[2]
你看对像就出来了。
这就是ArrayList
最突出的地方。
让我们来看下ArrayList
内部数组是如何自我Copy的。
要想深入的了解他就必需要看他的API，add
方法与remove 方式。
看完后你就会对它有一个深刻的理解了，如下原码：
public void add(int index, E
element) {
& if (index & size ||
index & 0)
& &throw new
IndexOutOfBoundsException( "Index: "+index+", Size:
& ensureCapacity(size+1); //
Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1, size -
& elementData[index] =
remove 方法
public E remove(int index)
RangeCheck(index);
modCount++;
& E oldValue =
elementData[index];
& int numMoved = size - index
& if (numMoved &
& System.arraycopy(elementData, index+1,
elementData, index, numMoved);
& elementData[--size] =
// Let gc do its work
上述两个方法足以让你认识他们了。
他的主要执行过程就在于数组对像的自我复制。
System.arrayCopy这个方法是System类中的一个JNI方式实现类。
(JNI，Java Native Interface
故名思意，就是java语言调其它语言的一个接口)
这个JNI的底层在不同的平台上不一样。
打个比方windows
其实java的JNI就是调了dll。
Unix 其实就是调了.so
做过C++的一定明白。
这个暂且放一下，让我们来关注一下arrayCopy
如何复制数组元素的。
如果有人对java
的JNI接口有兴趣朋友，不防去Sun网站下它的源码。嘎嘎。C代码还是有点深度的。
SCSL 源码就能看到，地址：
/is-bin/INTERSHOP.enfinity/WFS/CDS-CDS_Developer-Site/en_US/-/USD/ViewFilteredProducts-SingleVariationTypeFilter
(说明：要注册一个SUN的账号.才可以下载)
在JAVA里面，可以用复制语句"A=B"给基本类型的数据传递值，但是如果A，B是两个同类型的数组，复制就相当于将一个数组变量的引用传递给另一个数组；
如果一个数组发生改变，那么引用同一数组的变量也要发生改变。
以下是归纳的JAVA中复制数组的方法：
1.使用FOR循环,将数组的每个元素复制或者复制指定元素，不过效率差一点
2.使用clone方法,得到数组的值，而不是引用，不能复制指定元素，灵活性差一点
3.使用System.arraycopy(src, srcPos, dest,
destPos, length)方法，推荐使用
1.使用FOR循环
src={1,3,5,6,7,8};
int[] dest = new int[6];
for(int i=0;i&6;i++) dest[i] =
2.使用clone
src={1,3,5,6,7,8};
dest=(int[])
src.clone();//使用clone创建
副本,注意clone要使用强制转换
3.使用System.arraycopy
src={1,3,5,6,7,8};
int[] dest = new int[6];
System.arraycopy(src, 0, dest, 0,
-------------------------------------------------------------------
System提供了一个静态方法arraycopy()，我们可以使用它来实现数组之间的复制。
其函数原型是：
& public static void
arraycopy(Object src, int srcPos, Object dest, int destPos, int
src：源数组；
srcPos：源数组要复制的起始位置；
dest：目的数组；
destPos：目的数组放置的起始位置；
length：复制的长度。
注意：src and
dest都必须是同类型或者可以进行转换类型的数组。
有趣的是这个函数可以实现自己到自己复制，
={0,1,2,3,4,5,6};
System.arraycopy(fun,0,fun,3,3);
则结果为：{0,1,2,0,1,2,6};
JAVA提高教程-System.arraycopy方法的使用
java.util.A&
public class LessionSystemArraycopy
& public static void
main(String[] args) {&
此方位为native方法。&
public static native void
arraycopy(&
Object src, int srcPos, Object
& & // int
destPos, int length);&
ids = { 1, 2, 3, 4, 5 };&
System.out.println(Arrays.toString(ids)); // [1, 2, 3, 4,
测试自我复制&
把从索引0开始的2个数字复制到索引为3的位置上&
System.arraycopy(ids, 0, ids, 3,
System.out.println(Arrays.toString(ids)); // [1, 2, 3, 1,
测试复制到别的数组上&
将数据的索引1开始的3个数据复制到目标的索引为0的位置上&
ids2 = new int[6];&
System.arraycopy(ids, 1, ids2, 0,
System.out.println(Arrays.toString(ids2)); // [2, 3, 1, 0, 0,
此功能要求&
源的起始位置+长度不能超过末尾&
目标起始位置+长度不能超过末尾&
且所有的参数不能为负数&
& System.arraycopy(ids, 0, ids2, 0, ids.length +
& & } catch
(IndexOutOfBoundsException ex)
发生越界异常，数据不会改变&
System.out.println("拷贝发生异常：数据越界。");&
System.out.println(Arrays.toString(ids2)); // [2, 3, 1, 0, 0,
如果是类型转换问题&
& & Object[]
o1 = { 1, 2, 3, 4.5, 6.7 };&
Integer[] o2 = new Integer[5];&
System.out.println(Arrays.toString(o2)); // [null, null, null,
null, null]&
& System.arraycopy(o1, 0, o2, 0,
o1.length);&
& & } catch
(ArrayStoreException ex) {&
发生存储转换，部分成功的数据会被复制过去&
System.out.println("拷贝发生异常：数据转换错误，无法存储。");&
从结果看，前面3个可以复制的数据已经被存储了。剩下的则没有&
System.out.println(Arrays.toString(o2)); // [1, 2, 3, null,
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。Java性能漫谈－数组复制之System.arraycopy_Java教程_动态网站制作指南
Java性能漫谈－数组复制之System.arraycopy
来源：人气：1589
当我还年幼的时候，我很任性，复制数组也是，写一个for循环，来回倒腾，后来长大了，就发现了System.arraycopy的好处。
为了测试俩者的区别我写了一个简单赋值int[100000]的程序来对比，并且中间使用了nanoTime来计算时间差：
程序如下：
int[] a = new int[100000];
for(int i=0;i&a.i++){
int[] b = new int[100000];
int[] c = new int[100000];
for(int i=0;i&c.i++){
int[] d = new int[100000];
for(int k=0;k&10;k++){
long start1 = System.nanoTime();
for(int i=0;i&a.i++){
b[i] = a[i];
long end1 = System.nanoTime();
System.out.intln("end1 - start1 = "+(end1-start1));
long start2 = System.nanoTime();
System.arraycopy(c, 0, d, 0, 100000);
long end2 = System.nanoTime();
System.out.println("end2 - start2 = "+(end2-start2));
System.out.println();
为了避免内存不稳定干扰和运行的偶然性结果，我在一开始的时候把所有空间申明完成，并且只之后循环10次执行，得到如下结果：
end1 - start1 = 366806
end2 - start2 = 109154
end1 - start1 = 380529
end2 - start2 = 79849
end1 - start1 = 421422
end2 - start2 = 68769
end1 - start1 = 344463
end2 - start2 = 72020
end1 - start1 = 333174
end2 - start2 = 77277
end1 - start1 = 377335
end2 - start2 = 82285
end1 - start1 = 370608
end2 - start2 = 66937
end1 - start1 = 349067
end2 - start2 = 86532
end1 - start1 = 389974
end2 - start2 = 83362
end1 - start1 = 347937
end2 - start2 = 63638
可以看出，System.arraycopy的性能很不错，为了看看究竟这个底层是如何处理的，我找到openJDK的一些代码留恋了一些：
System.arraycopy是一个native函数，需要看native层的代码：
public static native void arraycopy(Object src,
Object dest, int destPos,
int length);
找到对应的openjdk6-src/hotspot/src/share/vm/prims/jvm.cpp，这里有JVM_ArrayCopy的入口：
JVM_ENTRY(void, JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos,
jobject dst, jint dst_pos, jint length))
JVMWrapper("JVM_ArrayCopy");
// Check if we have null pointers
if (src == NULL || dst == NULL) {
THROW(vmSymbols::_lang_NullPointerException());
arrayOop s = arrayOop(JNIHandles::resolve_non_null(src));
arrayOop d = arrayOop(JNIHandles::resolve_non_null(dst));
assert(s-&is_oop(), "JVM_ArrayCopy: src not an oop");
assert(d-&is_oop(), "JVM_ArrayCopy: dst not an oop");
// Do copy
Klass::cast(s-&klass())-&copy_array(s, src_pos, d, dst_pos, length, thread);
前面的语句都是判断，知道最后的copy_array(s, src_pos, d, dst_pos, length, thread)是真正的copy，进一步看这里，在openjdk6-src/hotspot/src/share/vm/oops/typeArrayKlass.cpp中：
void typeArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS) {
assert(s-&is_typeArray(), "must be type array");
// Check destination
if (!d-&is_typeArray() || element_type() != typeArrayKlass::cast(d-&klass())-&element_type()) {
THROW(vmSymbols::java_lang_ArrayStoreException());
// Check is all offsets and lengths are non negative
if (src_pos & 0 || dst_pos & 0 || length & 0) {
THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
// Check if the ranges are valid
( (((unsigned int) length + (unsigned int) src_pos) & (unsigned int) s-&length())
|| (((unsigned int) length + (unsigned int) dst_pos) & (unsigned int) d-&length()) ) {
THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
// Check zero copy
if (length == 0)
// This is an attempt to make the copy_array fast.
int l2es = log2_element_size();
int ihs = array_header_in_bytes() / S
char* src = (char*) ((oop*)s + ihs) + ((size_t)src_pos && l2es);
char* dst = (char*) ((oop*)d + ihs) + ((size_t)dst_pos && l2es);
Copy::conjoint_memory_atomic(src, dst, (size_t)length && l2es);//还是在这里处理copy
这个函数之前的仍然是一堆判断，直到最后一句才是真实的拷贝语句。
在openjdk6-src/hotspot/src/share/vm/utilities/copy.cpp中找到对应的函数：
// C larger units are filled atomically if everything is aligned.
void Copy::conjoint_memory_atomic(void* from, void* to, size_t size) {
address src = (address) from;
address dst = (address)
uintptr_t bits = (uintptr_t) src | (uintptr_t) dst | (uintptr_t)
We could improve performance by ignoring the low bits of size,
// and putting a short cleanup loop after each bulk copy loop.
// There are plenty of other ways to make this faster also,
// and it's a slpery slope.
For now, let's keep this code simple
// since the simplicity helps clarify the atomicity semantics of
// this tion.
There are also CPU-specific assembly versions
// which may or may not want to include such optimizations.)
if (bits % sizeof(jlong) == 0) {
Copy::conjoint_jlongs_atomic((jlong*) src, (jlong*) dst, size / sizeof(jlong));
} else if (bits % sizeof(jint) == 0) {
Copy::conjoint_jints_atomic((jint*) src, (jint*) dst, size / sizeof(jint));
} else if (bits % sizeof(jshort) == 0) {
Copy::conjoint_jshorts_atomic((jshort*) src, (jshort*) dst, size / sizeof(jshort));
// Not aligned, so no need to be atomic.
Copy::conjoint_jbytes((void*) src, (void*) dst, size);
上面的代码展示了选择哪个copy函数，我们选择conjoint_jints_atomic，在openjdk6-src/hotspot/src/share/vm/utilities/copy.hpp进一步查看：
conjoint, atomic on each jint
static void conjoint_jints_atomic(jint* from, jint* to, size_t count) {
assert_params_ok(from, to, LogBytesPerInt);
pd_conjoint_jints_atomic(from, to, count);
继续向下查看，在openjdk6-src/hotspot/src/cpu/zero/vm/copy_zero.hpp中：
static void pd_conjoint_jints_atomic(jint* from, jint* to, size_t count) {
_Copy_conjoint_jints_atomic(from, to, count);
继续向下查看，在openjdk6-src/hotspot/src/os_cpu/_zero/vm/os_linux_zero.cpp中：
void _Copy_conjoint_jints_atomic(jint* from, jint* to, size_t count) {
if (from & to) {
jint *end = from +
while (from & end)
*(to++) = *(from++);
else if (from & to) {
jint *end = from;
from += count - 1;
+= count - 1;
while (from &= end)
*(to--) = *(from--);
可以看到，直接就是内存块赋值的逻辑了，这样避免很多引用来回倒腾的时间，必然就变快了。
优质网站模板}