java

空指向错误啊,你的代码呢,贴出来啊

你弄个try{}catch(){}，看看哪一行出错啊~

这应该是jsp解析后台数据报错，你自己在jsp页面找下吧

JAVA中初始化一个变量为null，然后不做任何改变就直接使用这个变量，就会出这样的“空指针异常”。如果你在登陆的时候用户名和密码都不为空应该不会出现这种异常。所以猜测是银行的程序与浏览器是否允许Java执行之间出了某些问题，尝试以下方法：方法一：更改兼容性视图设置1. 打开IE， 点击右上角的“工具”选项，再选择“兼容性视图设置”2. 将该行网站添加到“兼容性视图中的网站”3. 关闭IE，重新登入第二步：添加受信任的站点1. 打开IE， 点击右上角的“工具”选项，再选择“Internet选项”2. 点击界面的上方的“安全”选项卡，然后点击“受信任的站点”3. 点击“站点”，添加该行的网站第三步：关闭保护模式1. 打开IE， 点击右上角的“工具”选项，再选择“Internet选项”2. 点击界面的上方的“安全”选项卡，然后点击“Internet”3. 把“启用保护模式”的勾选去掉，另外，切换到“高级”选项卡，找到“增强保护模式”，如果前面有勾选并可选的话，请您将前面的勾去掉4. 关闭IE，重新登入

一般报java.lang.NullPointerException的原因有以下几种： ·字符串变量未初始化； ·接口类型的对象没有用具体的类初始化，比如： List lt; 会报错 List lt = new ArrayList(); 则不会报错了 ·当一个对象的值为空时，你没有判断为空的情况。 你可以试着把下面的代码前加一行代码： if(rb!=null); ...................String类型的对象可以做如下判断if(rb!==null&&!"".equals(rb)) ……当然还可以多做一个判断，是否不为空字符串if(rb!==null&&!"".equals(rb.trim()))

肯定是你网页跳转时附带的某个或某些字段没有复制，在java代码中运行时正好这个值不能为空，所以报了空指正错误，仔细找找是哪个字段没有赋值！

空指针异常，没有得到数据。

空指针异常这不是你的问题，是你手机的软件的问题，如果包换你就换一个吧你自己解决不了的

bin一般放的是CS项目中生成的class文件及目录；lib一般放的是CS/BS项目中外部引入的jar包文件。

bin字节码，lib应该是类库吧

在lib这个目录下面,一定有很很多以.jar为后缀的文件(尤其是dt.jar和tools.jar),这是压缩文件,你可以用winRAR解压查看的.SUN公司发布的一些系统类就在这里,是JAVA程序运行所依赖的.例如:在JAVA程序在进行输入和输出的时候要用到很输入输出类,如StreamInput,StreamOutput,你直接在程序的开头写上import java.io.*,编译器就到会lib目录下找相关的系统类.

额jar就是我们要依赖的包,lib就是由一个或多个Jar组成的

它的意思是捆 扎，一批，据个人理解，应该是，，和包差不多，就是把这一堆代码放在一起的意思，应该和数据库有一定的关系把

如果是文件上传时遇到的问题的话检查一下是不是没有common-fileupload.jar包，还有类导入是不是以下几个import org.apache.commons.fileupload.FileItem;import org.apache.commons.fileupload.disk.DiskFileItemFactory;import org.apache.commons.fileupload.servlet.ServletFileUpload;

1. ActionContext在Struts2开发中,除了将请求参数自动设置到Action的字段中,我们往往也需要在Action里直接获取请求(Request)或会话(Session)的一些信息,甚至需要直接对JavaServlet Http的请求(HttpServletRequest),响应(HttpServletResponse)操作. 我们需要在Action中取得request请求参数"username"的值:ActionContext context = ActionContext.getContext();Map params = context.getParameters();String username = (String) params.get("username");on执行时的上下文,上下文可以看作是一个容器(其实我们这里的容器就是一个Map而已),它存放的是Action在执行时需要用到的对象. 一般情况, 我们的ActionContext都是通过: ActionContext context = (ActionContext) actionContext.get();来获取的.我们再来看看这里的actionContext对象的创建:static ThreadLocal actionContext = new ActionContextThreadLocal();ActionContextThreadLocal是实现ThreadLocal的一个内部类.ThreadLocal可以命名为"线程局部变量",它为每一个使用该变量的线程都提供一个变量值的副本,使每一个线程都可以独立地改变自己的副本,而不会和其它线程的副本冲突.这样,我们ActionContext里的属性只会在对应的当前请求线程中可见,从而保证它是线程安全的.通过ActionContext取得HttpSession: Map session = ActionContext.getContext().getSession();2. ServletActionContextServletActionContext(com.opensymphony.webwork. ServletActionContext),这个类直接继承了我们上面介绍的ActionContext,它提供了直接与Servlet相关对象访问的功能,它可以取得的对象有:(1)javax.servlet.http.HttpServletRequest : HTTPservlet请求对象(2)javax.servlet.http.HttpServletResponse : HTTPservlet相应对象(3)javax.servlet.ServletContext : Servlet上下文信息(4)javax.servlet.ServletConfig : Servlet配置对象(5)javax.servlet.jsp.PageContext : Http页面上下文如何从ServletActionContext里取得Servlet的相关对象:<1>取得HttpServletRequest对象: HttpServletRequest request = ServletActionContext. getRequest();<2>取得HttpSession对象: HttpSession session = ServletActionContext. getRequest().getSession();3. ServletActionContext和ActionContext联系ServletActionContext和ActionContext有着一些重复的功能,在我们的Action中,该如何去抉择呢?我们遵循的原则是:如果ActionContext能够实现我们的功能,那最好就不要使用ServletActionContext,让我们的Action尽量不要直接去访问Servlet的相关对象.注意：在使用ActionContext时有一点要注意: 不要在Action的构造函数里使用ActionContext.getContext(),因为这个时候ActionContext里的一些值也许没有设置,这时通过ActionContext取得的值也许是null；同样，HttpServletRequest req = ServletActionContext.getRequest()也不要放在构造函数中，也不要直接将req作为类变量给其赋值。至于原因，我想是因为前面讲到的static ThreadLocal actionContext = new ActionContextThreadLocal()，从这里我们可以看出ActionContext是线程安全的，而ServletActionContext继承自ActionContext，所以ServletActionContext也线程安全，线程安全要求每个线程都独立进行，所以req的创建也要求独立进行，所以ServletActionContext.getRequest()这句话不要放在构造函数中，也不要直接放在类中，而应该放在每个具体的方法体中(eg：login()、queryAll()、insert()等)，这样才能保证每次产生对象时独立的建立了一个req。4. struts2中获得request、response和session(1)非IoC方式方法一：使用org.apache.struts2.ActionContext类，通过它的静态方法getContext()获取当前Action的上下文对象。ActionContext ctx = ActionContext.getContext();ctx.put("liuwei", "andy"); //request.setAttribute("liuwei", "andy"); Map session = ctx.getSession(); //sessionHttpServletRequest request = ctx.get(org.apache.struts2.StrutsStatics.HTTP_REQUEST); HttpServletResponse response = ctx.get(org.apache.struts2.StrutsStatics.HTTP_RESPONSE);细心的朋友可以发现这里的session是个Map对象, 在Struts2中底层的session都被封装成了Map类型. 我们可以直接操作这个Map对象进行对session的写入和读取操作, 而不用去直接操作HttpSession对象.方法二：使用org.apache.struts2.ServletActionContext类public class UserAction extends ActionSupport {//其他代码片段private HttpServletRequest req; // private HttpServletRequest req = ServletActionContext.getRequest(); 这条语句放在这个位置是错误的，同样把这条语句放在构造方法中也是错误的。public String login() {req = ServletActionContext.getRequest(); //req的获得必须在具体的方法中实现user = new User();user.setUid(uid);user.setPassword(password);if (userDAO.isLogin(user)) {req.getSession().setAttribute("user", user);return SUCCESS;}return LOGIN;}public String queryAll() {req = ServletActionContext.getRequest(); //req的获得必须在具体的方法中实现uList = userDAO.queryAll();req.getSession().setAttribute("uList", uList);return SUCCESS;}//其他代码片段 }(2)IoC方式(即使用Struts2 Aware拦截器)要使用IoC方式，我们首先要告诉IoC容器(Container)想取得某个对象的意愿，通过实现相应的接口做到这点。public class UserAction extends ActionSupport implements SessionAware, ServletRequestAware, ServletResponseAware {private HttpServletRequest request;private HttpServletResponse response;public void setServletRequest(HttpServletRequest request) {this.request = request;}public void setServletResponse(HttpServletResponse response) {this.response = response;}public String execute() {HttpSession session = request.getSession();return SUCCESS;} }

如果你有JAVA项目的源代码的话：1.把JAVA项目的src文件夹的内容复制到Android项目的src文件夹下或者 将JAVA项目的src文件夹重命名后复制到Android项目根目录下，之后在图2的Source选项下添加此文件夹2.把JAVA项目所用的jar包复制到Android项目的libs文件夹下(Android Private Libraries下面自动导入此jar包)

<html><head><title>九九乘法表</title><style type="text/css">.i{color:red}.j{color:blue}.k{color:purple}div{display:inline } //内部css，可以放在新建的xxx.css文件中</style></head><body><script>document.write("<table>");for (var i = 1; i <= 9; i++){document.write("<tr>");for (var j = 1; j <= i; j++){<!-- document.write("<td>"+j+"x"+i+"="+j*i+"</td>"); -->document.write("<td>"+ "<div class="j">" +j+"</div>" +"x"+"<div class="i">"+i+"</div>"+"="+"<div class="k">"+j*i+"</div>"+"</td>");}document.write("</tr>");}document.write("</table>");</script></body> </html>

不知道啊，问一下高人吧，实在不懂

要看你选择的单位

int ImageStretchByHistogram(IplImage *src1,IplImage *dst1) /*************************************************Function: 通过直方图变换进行图像增强，将图像灰度的域值拉伸到0-255src1: 单通道灰度图像 dst1: 同样大小的单通道灰度图像 *************************************************/ { assert(src1->width==dst1->width); double p[256],p1[256],num[256]; memset(p,0,sizeof(p)); memset(p1,0,sizeof(p1)); memset(num,0,sizeof(num)); int height=src1->height; int width=src1->width; long wMulh = height * width; //statistics for(int x=0;x<src1->width;x++) { for(int y=0;y<src1-> height;y++){ uchar v=((uchar*)(src1->imageData + src1->widthStep*y))[x]; num[v]++; } } //calculate probability for(int i=0;i<256;i++) { p[i]=num[i]/wMulh; } //p1[i]=sum(p[j]); j<=i; for(int i=0;i<256;i++) { for(int k=0;k<=i;k++) p1[i]+=p[k]; } // histogram transformation for(int x=0;x<src1->width;x++) { for(int y=0;y<src1-> height;y++){ uchar v=((uchar*)(src1->imageData + src1->widthStep*y))[x]; ((uchar*)(dst1->imageData + dst1->widthStep*y))[x]= p1[v]*255+0.5; } } return 0; } void CCVMFCView::OnImageAdjustContrast() { if(workImg->nChannels>1) OnColorToGray(); Invalidate(); dst=cvCreateImage(cvGetSize(workImg),workImg->depth,workImg->nChannels); ImageStretchByHistogram(workImg,dst); m_dibFlag=imageReplace(dst,&workImg); Invalidate(); }这个是C++代码格式的，你可以参考一下思路

楼上正解

Android上的界面展示都是通过Activity实现的，Activity实在是太常用了。但是Activity也有它的局限性，同样的界面在手机上显示可能很好看，在平板上就未必了，因为平板的屏幕非常大，手机的界面放在平板上可能会有过分被拉长、控件间距过大等情况。这个时候更好的体验效果是在Activity中嵌入"小Activity"，然后每个"小Activity"又可以拥有自己的布局。因此，我们今天的主角Fragment登场了。 一、Fragment初探： Fragment是activity的界面中的一部分或一种行为。你可以把多个Fragment们组合到一个activity中来创建一个多面界面，并且你可以在多个activity中重用一个Fragment。你可以把Fragment认为模块化的一段activity，它具有自己的生命周期，接收它自己的事件，并可以在activity运行时被添加或删除。 Fragment不能独立存在，它必须嵌入到activity中，而且Fragment的生命周期直接受所在的activity的影响。例如：当activity暂停时，它拥有的所有的Fragment们都暂停了，当activity销毁时，它拥有的所有Fragment们都被销毁。然而，当activity运行时（在onResume()之后，onPause()之前），你可以单独地操作每个Fragment，比如添加或删除它们。当你在执行上述针对Fragment的事务时，你可以将事务添加到一个栈中，这个栈被activity管理，栈中的每一条都是一个Fragment的一次事务。有了这个栈，就可以反向执行Fragment的事务，这样就可以在Fragment级支持“返回”键（向后导航）。 当向activity中添加一个Fragment时，它须置于ViewGroup控件中，并且需定义Fragment自己的界面。你可以在layoutxml文件中声明Fragment，元素为：<fragment>；也可以在代码中创建Fragment，然后把它加入到ViewGroup控件中。然而，Fragment不一定非要放在activity的界面中，它可以隐藏在后台为actvitiy工作。 设计的哲学： 为了让界面可以在平板上更好地展示，Android在3.0版本引入了Fragment(碎片)功能，通过官方文档中的这张图片可以很明显地看到Fragment的好处：注：左边为平板，右边为手持设备。二、Fragment的生命周期： 因为Fragment必须嵌入在Acitivity中使用，所以Fragment的生命周期和它所在的Activity是密切相关的。 如果Activity是暂停状态，其中所有的Fragment都是暂停状态；如果Activity是stopped状态，这个Activity中所有的Fragment都不能被启动；如果Activity被销毁，那么它其中的所有Fragment都会被销毁。 但是，当Activity在活动状态，可以独立控制Fragment的状态，比如加上或者移除Fragment。 当这样进行fragment transaction（转换）的时候，可以把fragment放入Activity的back stack中，这样用户就可以进行返回操作。 使用Fragment时，需要继承Fragment或者Fragment的子类（DialogFragment, ListFragment, PreferenceFragment, WebViewFragment），所以Fragment的代码看起来和Activity的类似。 每当创建一个Fragment时，首先添加以下三个回调方法： onCreate()：系统在创建Fragment的时候调用这个方法，这里应该初始化相关的组件，一些即便是被暂停或者被停止时依然需要保留的东西。onCreateView()：当第一次绘制Fragment的UI时系统调用这个方法，该方法将返回一个View，如果Fragment不提供UI也可以返回null。注意，如果继承自ListFragment，onCreateView()默认的实现会返回一个ListView，所以不用自己实现。onPause()：当用户离开Fragment时第一个调用这个方法，需要提交一些变化，因为用户很可能不再返回来。将Fragment加载到Activity当中有两种方式： 方式一：添加Fragment到Activity的布局文件当中方式二：在Activity的代码中动态添加Fragment第一种方式虽然简单但灵活性不够。添加Fragment到Activity的布局文件当中,就等同于将Fragment及其视图与activity的视图绑定在一起，且在activity的生命周期过程中，无法切换fragment视图。 第二种方式比较复杂，但也是唯一一种可以在运行时控制fragment的方式（加载、移除、替换）。 下面将分别介绍一下。 　　 三、在Activity的布局文件中添加Fragment：（不推荐） 平板的模拟器参数如下：然后新建一个工程文件。然后继续如下步骤： （1）新建文件fragment_hello.xml和HelloFragment.java： fragment_hello.xml代码如下：（即Fragment的布局文件） 复制代码<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" android:orientation="vertical" > <EditText android:layout_width="match_parent" android:layout_height="wrap_content" android:hint="请输入内容"/> <RatingBar android:id="@+id/ratingBar1" android:layout_width="wrap_content" android:layout_height="wrap_content" /></LinearLayout>复制代码HelloFragment.java代码如下： 复制代码 1 package com.example.m01_fragment01; 2 3 import android.app.Fragment; 4 import android.os.Bundle; 5 import android.view.LayoutInflater; 6 import android.view.View; 7 import android.view.ViewGroup; 8 9 public class HelloFragment extends Fragment {10 11 @Override12 public void onCreate(Bundle savedInstanceState) {13 super.onCreate(savedInstanceState);14 }15 16 @Override17 public View onCreateView(LayoutInflater inflater, ViewGroup container,18 Bundle savedInstanceState) {19 View view = inflater.inflate(R.layout.fragment_hello, null); // View android.view.LayoutInflater.inflate(int resource, ViewGroup root) 20 return view;21 }22 23 @Override24 public void onPause() {25 super.onPause();26 }27 }复制代码重点在于第19和20行，通过inflate()方法将自定义的fragment的布局加载进来。 19行代码中，第二个参数中，如果布局没有根，那就用null。 注：上方代码中，因为我们的程序是面对Android 4.0以上版本的，所以导入Fragment的包时，选择第一个：android.app.Fragment（2）将Fragment添加到Activity的布局中： 修改activity_main.xml的代码如下： 复制代码 1 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 2 xmlns:tools="http://schemas.android.com/tools" 3 android:layout_width="match_parent" 4 android:layout_height="match_parent" 5 tools:context=".MainActivity" > 6 7 <fragment 8 android:id="@+id/fragment_hello" 9 android:name="com.example.m01_fragment02.HelloFragment"10 android:layout_width="wrap_content"11 android:layout_height="wrap_content" />12 </LinearLayout>复制代码08行和09行是关键。其中android:name属性填上你自己创建的fragment的完整类名。如下图：当系统创建这个Activity的布局文件时，系统会实例化每一个fragment，并且调用它们的onCreateView()方法，来获得相应fragment的布局，并将返回值插入fragment标签所在的地方。 运行之后，效果如下：实际上，这种方式在开发中并不推荐，我们来介绍另外一种方法。四、在activity代码中添加fragment： 【实例】点击左侧fragment中的按钮，弹出右侧的fragment。新建一个工程文件，然后步骤如下： （1）将activity_main的布局分为两部分：左边占1/4，右边占3/4。修改activity_main.xml的代码如下： 复制代码<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".MainActivity" android:orientation="horizontal" > <LinearLayout android:id="@+id/left" android:layout_width="0dp" android:layout_height="match_parent" android:orientation="vertical" android:layout_weight="1" android:background="#00BFFF" > <Button android:id="@+id/button1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="显示"/> </LinearLayout> <LinearLayout android:id="@+id/right" android:layout_width="0dp" android:layout_height="match_parent" android:layout_weight="3" android:background="#00FFFF" android:orientation="vertical" > </LinearLayout> </LinearLayout>复制代码上方代码中，一个LinearLayout代表一个Fragment的容器，记得要给每个fragment加一个容器的id。

抛出一个输入/输出异常

try-catch就是捕获throw抛出的异常，程序执行到throw语句时立即终止。如果想要在上一级代码捕获并处理异常，就要用throws。

请举个不用的例子~

一、概念如果某个方法不能按照正常的途径完成任务，就可以通过另一种路径退出方法。在这种情况下会抛出一个封装了错误信息的对象。此时，这个方法会立刻退出同时不返回任何值。另外，调用这个方法的其他代码也无法继续执行，异常处理机制会将代码执行交给异常处理器。二、异常分类Throwable 是 Java 语言中所有错误或异常的超类，在 Java 中只有 Throwable 类型的实例才可以被抛出（throw）或者捕获（catch），它是异常处理机制的基本组成类型。实例分为 Error 和 Exception 两种。2.1、ErrorError 类是指 java 运行时系统的内部错误和资源耗尽错误。应用程序不会抛出该类对象。如果出现了这样的错误，除了告知用户，剩下的就是尽力使程序安全的终止。2.2、ExceptionException 又有两个分支 ， 一个是运行时异常 RuntimeException ， 一 个是检查异常 CheckedException。RuntimeException 如 ：NullPointerException 、 ClassCastException ；CheckedException 如： I/O 错误导致的 IOException、SQLException。RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。 如果出现 RuntimeException，那么一定是程序员代码书写导致的错误.CheckedException：一般是外部错误，这种异常都发生在编译阶段，Java 编译器会强制程序去捕获此类异常，即会出现要求你把这段可能出现异常的程序进行 try catch，该类异常一般包括几个方面：试图在文件尾部读取数据试图打开一个错误格式的 URL试图根据给定的字符串查找 class 对象，而这个字符串表示的类并不存在三、异常的处理方式3.1、不处理遇到异常问题不进行具体处理，而是继续抛给调用者 （throw，throws）抛出异常有三种形式，一是 throw，再就是 throws，还有一种系统自动抛异常。public static void main(String[] args) { String s = "abc"; if(s.equals("abc")) { /** 手动抛出一个数字格式化异常 **/ throw new NumberFormatException(); } else { System.out.println(s); }}int div(int a,int b) throws Exception{ return a/b;}3.2、处理try catch 捕获异常针对性处理方式四、Throw 和 throws 的区别throws 用在函数上，后面跟的是异常类，可以跟多个；语法：(修饰符)(方法名)([参数列表])[throws(异常类)]{……}public void doA(int a) throws Exception1,Exception3{……}throw 用在函数内，后面跟的是异常对象。throws E1,E2,E3只是告诉程序这个方法可能会抛出这些异常，方法的调用者可能要处理这些异常，而这些异常E1，E2，E3可能是该函数体产生的。throw则是明确了这个地方要抛出这个异常。结合来看：void doA(int a) throws IOException,{ try{ ...... }catch(Exception1 e){ throw e; }catch(Exception2 e){ System.out.println("出错了！"); } if(a!=b) throw new Exception3("自定义异常");}throws 用来声明异常，让调用者知道该功能可能会出现的问题（比如上方的 IO 异常），可以给出预先的处理方式；throw 抛出具体的问题对象，执行到 throw，功能就已经结束了，跳转到调用者，并将具体的问题对象抛给调用者。也就是说 throw 语句独立存在时，下面不要定义其他语句，因为执行不到。概括:throws 表示出现异常的一种可能性，并不一定会发生这些异常；throw 则是抛出了异常，执行 throw 则一定抛出了某种异常对象。五、总结了解 Exception、Error 两种异常的区别，面试可能会问。区分 throws、throw使用维度。

因为这三个是运行时异常，所以不能声明抛出。如果是想要自行抛出，请使用throw关键字注意throw和throws的S（应该把 这一类型的真没见过

在Java中有异常处理机制，其作用和处理就不多说了，这里我只说throws和throw的区别。 throws是方法体签名使用，也就是只能用在方法的后面，比如main()throws servlet Exception,IOException就表明这个方法会抛出Exception,IOException异常，至于具体抛出什么异常，不用我们操心，JVM会处理。比如你用到了File类的一些方法，如果你不给这个方法声明抛出异常，那么它就会报错。处理这个报错有两种方法，一种是在方法体内写try{}cathc{}方法块进行判断，另一种是直接在方法体后声明抛出异常，交给java处理。 而throw是抛出一个具体的异常实例，是要写在方法体里面的。比如throw new Exception()等等。

一、Java异常的基础知识 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。比如说，你的代码少了一个分号，那么运行出来结果是提示是错误java.lang.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出java.lang.ArithmeticException的异常。 有些异常需要做处理，有些则不需要捕获处理，后面会详细讲到。 天有不测风云，人有旦夕祸福，Java的程序代码也如此。在编程过程中，首先应当尽可能去避免错误和异常发生，对于不可避免、不可预测的情况则在考虑异常发生时如何处理。 Java中的异常用对象来表示。Java对异常的处理是按异常分类处理的，不同异常有不同的分类，每种异常都对应一个类型（class），每个异常都对应一个异常（类的）对象。 异常类从哪里来？有两个来源，一是Java语言本身定义的一些基本异常类型，二是用户通过继承Exception类或者其子类自己定义的异常。Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。 异常的对象从哪里来呢？有两个来源，一是Java运行时环境自动抛出系统生成的异常，而不管你是否愿意捕获和处理，它总要被抛出！比如除数为0的异常。二是程序员自己抛出的异常，这个异常可以是程序员自己定义的，也可以是Java语言中定义的，用throw 关键字抛出异常，这种异常常用来向调用者汇报异常的一些信息。 异常是针对方法来说的，抛出、声明抛出、捕获和处理异常都是在方法中进行的。 Java异常处理通过5个关键字try、catch、throw、throws、finally进行管理。基本过程是用try语句块包住要监视的语句，如果在try语句块内出现异常，则异常会被抛出，你的代码在catch语句块中可以捕获到这个异常并做处理；还有以部分系统生成的异常在Java运行时自动抛出。你也可以通过throws关键字在方法上声明该方法要抛出异常，然后在方法内部通过throw抛出异常对象。finally语句块会在方法执行return之前执行，一般结构如下： try{ 程序代码 }catch(异常类型1 异常的变量名1){ 程序代码 }catch(异常类型2 异常的变量名2){ 程序代码 }finally{ 程序代码 } catch语句可以有多个，用来匹配多个异常，匹配上多个中一个后，执行catch语句块时候仅仅执行匹配上的异常。catch的类型是Java语言中定义的或者程序员自己定义的，表示代码抛出异常的类型，异常的变量名表示抛出异常的对象的引用，如果catch捕获并匹配上了该异常，那么就可以直接用这个异常变量名，此时该异常变量名指向所匹配的异常，并且在catch代码块中可以直接引用。这一点非常非常的特殊和重要！ Java异常处理的目的是提高程序的健壮性，你可以在catch和finally代码块中给程序一个修正机会，使得程序不因异常而终止或者流程发生以外的改变。同时，通过获取Java异常信息，也为程序的开发维护提供了方便，一般通过异常信息就很快就能找到出现异常的问题（代码）所在。 Java异常处理是Java语言的一大特色，也是个难点，掌握异常处理可以让写的代码更健壮和易于维护。 二、Java异常类类图 下面是这几个类的层次图： java.lang.Object java.lang.Throwable java.lang.Exception java.lang.RuntimeException java.lang.Error java.lang.ThreadDeath 下面四个类的介绍来自java api 文档。 1、Throwable Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。 两个子类的实例，Error 和 Exception，通常用于指示发生了异常情况。通常，这些实例是在异常情况的上下文中新近创建的，因此包含了相关的信息（比如堆栈跟踪数据）。 2、Exception Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件，表示程序本身可以处理的异常。 3、Error Error 是 Throwable 的子类，表示仅靠程序本身无法恢复的严重错误，用于指示合理的应用程序不应该试图捕获的严重问题。 在执行该方法期间，无需在方法中通过throws声明可能抛出但没有捕获的 Error 的任何子类，因为Java编译器不去检查它，也就是说，当程序中可能出现这类异常时，即使没有用try...catch语句捕获它，也没有用throws字句声明抛出它，还是会编译通过。 4、RuntimeException RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。Java编译器不去检查它，也就是说，当程序中可能出现这类异常时，即使没有用try...catch语句捕获它，也没有用throws字句声明抛出它，还是会编译通过，这种异常可以通过改进代码实现来避免。 5、ThreadDeath 调用 Thread 类中带有零参数的 stop 方法时，受害线程将抛出一个 ThreadDeath 实例。 仅当应用程序在被异步终止后必须清除时才应该捕获这个类的实例。如果 ThreadDeath 被一个方法捕获，那么将它重新抛出非常重要，因为这样才能让该线程真正终止。 如果没有捕获 ThreadDeath，则顶级错误处理程序不会输出消息。 虽然 ThreadDeath 类是“正常出现”的，但它只能是 Error 的子类而不是 Exception 的子类，因为许多应用程序捕获所有出现的 Exception，然后又将其放弃。 以上是对有关异常API的一个简单介绍，用法都很简单，关键在于理解异常处理的原理，具体用法参看Java API文档。 三、Java异常处理机制 对于可能出现异常的代码，有两种处理办法： 第一、在方法中用try...catch语句捕获并处理异常，catach语句可以有多个，用来匹配多个异常。例如： public void p(int x){ try{ ... }catch(Exception e){ ... }finally{ ... } } 第二、对于处理不了的异常或者要转型的异常，在方法的声明处通过throws语句抛出异常。例如： public void test1() throws MyException{ ... if(....){ throw new MyException(); } } 如果每个方法都是简单的抛出异常，那么在方法调用方法的多层嵌套调用中，Java虚拟机会从出现异常的方法代码块中往回找，直到找到处理该异常的代码块为止。然后将异常交给相应的catch语句处理。如果Java虚拟机追溯到方法调用栈最底部main()方法时，如果仍然没有找到处理异常的代码块，将按照下面的步骤处理： 第一、调用异常的对象的printStackTrace()方法，打印方法调用栈的异常信息。 第二、如果出现异常的线程为主线程，则整个程序运行终止；如果非主线程，则终止该线程，其他线程继续运行。 通过分析思考可以看出，越早处理异常消耗的资源和时间越小，产生影响的范围也越小。因此，不要把自己能处理的异常也抛给调用者。 还有一点，不可忽视：finally语句在任何情况下都必须执行的代码，这样可以保证一些在任何情况下都必须执行代码的可靠性。比如，在数据库查询异常的时候，应该释放JDBC连接等等。finally语句先于return语句执行，而不论其先后位置，也不管是否try块出现异常。finally语句唯一不被执行的情况是方法执行了System.exit()方法。System.exit()的作用是终止当前正在运行的 Java 虚拟机。finally语句块中不能通过给变量赋新值来改变return的返回值，也建议不要在finally块中使用return语句，没有意义还容易导致错误。 最后还应该注意一下异常处理的语法规则： 第一、try语句不能单独存在，可以和catch、finally组成 try...catch...finally、try...catch、try...finally三种结构，catch语句可以有一个或多个，finally语句最多一个，try、catch、finally这三个关键字均不能单独使用。 第二、try、catch、finally三个代码块中变量的作用域分别独立而不能相互访问。如果要在三个块中都可以访问，则需要将变量定义到这些块的外面。 第三、多个catch块时候，Java虚拟机会匹配其中一个异常类或其子类，就执行这个catch块，而不会再执行别的catch块。 第四、throw语句后不允许有紧跟其他语句，因为这些没有机会执行。 第五、如果一个方法调用了另外一个声明抛出异常的方法，那么这个方法要么处理异常，要么声明抛出。 那怎么判断一个方法可能会出现异常呢？一般来说，方法声明的时候用了throws语句，方法中有throw语句，方法调用的方法声明有throws关键字。 throw和throws关键字的区别 throw用来抛出一个异常，在方法体内。语法格式为：throw 异常对象。 throws用来声明方法可能会抛出什么异常，在方法名后，语法格式为：throws 异常类型1，异常类型2...异常类型n。 四、如何定义和使用异常类 1、使用已有的异常类，假如为IOException、SQLException。 try{ 程序代码 }catch(IOException ioe){ 程序代码 }catch(SQLException sqle){ 程序代码 }finally{ 程序代码 } 2、自定义异常类 创建Exception或者RuntimeException的子类即可得到一个自定义的异常类。例如: public class MyException extends Exception{ public MyException(){} public MyException(String smg){ super(smg); } } 3、使用自定义的异常 用throws声明方法可能抛出自定义的异常，并用throw语句在适当的地方抛出自定义的异常。例如： 在某种条件抛出异常 public void test1() throws MyException{ ... if(....){ throw new MyException(); } } 将异常转型（也叫转译），使得异常更易读易于理解 public void test2() throws MyException{ ... try{ ... }catch(SQLException e){ ... throw new MyException(); } } 还有一个代码，很有意思： public void test2() throws MyException{ ... try { ... } catch (MyException e) { throw e; } } 这段代码实际上捕获了异常，然后又和盘托出，没有一点意义，如果这样还有什么好处理的，不处理就行了，直接在方法前用throws声明抛出不就得了。异常的捕获就要做一些有意义的处理。 五、运行时异常和受检查异常 Exception类可以分为两种：运行时异常和受检查异常。 1、运行时异常 RuntimeException类及其子类都被称为运行时异常，这种异常的特点是Java编译器不去检查它，也就是说，当程序中可能出现这类异常时，即使没有用try...catch语句捕获它，也没有用throws字句声明抛出它，还是会编译通过。例如，当除数为零时，就会抛出java.lang.ArithmeticException异常。 2、受检查异常 除了RuntimeException类及其子类外，其他的Exception类及其子类都属于受检查异常，这种异常的特点是要么用try...catch捕获处理，要么用throws语句声明抛出，否则编译不会通过。 3、两者的区别 运行时异常表示无法让程序恢复运行的异常，导致这种异常的原因通常是由于执行了错误的操作。一旦出现错误，建议让程序终止。 受检查异常表示程序可以处理的异常。如果抛出异常的方法本身不处理或者不能处理它，那么方法的调用者就必须去处理该异常，否则调用会出错，连编译也无法通过。当然，这两种异常都是可以通过程序来捕获并处理的，比如除数为零的运行时异常： public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World!!!"); try{ System.out.println(1/0); }catch(ArithmeticException e){ System.out.println("除数为0!"); } System.out.println("除数为零后程序没有终止啊，呵呵!!!"); } } 运行结果： Hello World!!! 除数为0! 除数为零后程序没有终止啊，呵呵!!! 4、运行时错误 Error类及其子类表示运行时错误，通常是由Java虚拟机抛出的，JDK中与定义了一些错误类，比如VirtualMachineError 和OutOfMemoryError，程序本身无法修复这些错误.一般不去扩展Error类来创建用户自定义的错误类。而RuntimeException类表示程序代码中的错误，是可扩展的，用户可以创建特定运行时异常类。 Error（运行时错误）和运行时异常的相同之处是:Java编译器都不去检查它们，当程序运行时出现它们，都会终止运行。 5、最佳解决方案 对于运行时异常，我们不要用try...catch来捕获处理，而是在程序开发调试阶段，尽量去避免这种异常，一旦发现该异常，正确的做法就会改进程序设计的代码和实现方式，修改程序中的错误，从而避免这种异常。捕获并处理运行时异常是好的解决办法，因为可以通过改进代码实现来避免该种异常的发生。 对于受检查异常，没说的，老老实实去按照异常处理的方法去处理，要么用try...catch捕获并解决，要么用throws抛出！ 对于Error（运行时错误），不需要在程序中做任何处理，出现问题后，应该在程序在外的地方找问题，然后解决。 六、异常转型和异常链 异常转型在上面已经提到过了，实际上就是捕获到异常后，将异常以新的类型的异常再抛出，这样做一般为了异常的信息更直观！比如： public void run() throws MyException{ ... try{ ... }catch(IOException e){ ... throw new MyException(); }finally{ ... } } 异常链，在JDK1.4以后版本中，Throwable类支持异常链机制。Throwable 包含了其线程创建时线程执行堆栈的快照。它还包含了给出有关错误更多信息的消息字符串。最后，它还可以包含 cause（原因）：另一个导致此 throwable 抛出的 throwable。它也称为异常链 设施，因为 cause 自身也会有 cause，依此类推，就形成了异常链，每个异常都是由另一个异常引起的。 通俗的说，异常链就是把原始的异常包装为新的异常类，并在新的异常类中封装了原始异常类，这样做的目的在于找到异常的根本原因。 通过Throwable的两个构造方法可以创建自定义的包含异常原因的异常类型： Throwable(String message, Throwable cause) 构造一个带指定详细消息和 cause 的新 throwable。 Throwable(Throwable cause) 构造一个带指定 cause 和 (cause==null ? null :cause.toString())（它通常包含类和 cause 的详细消息）的详细消息的新 throwable。 getCause() 返回此 throwable 的 cause；如果 cause 不存在或未知，则返回 null。 initCause(Throwable cause) 将此 throwable 的 cause 初始化为指定值。 在Throwable的子类Exception中，也有类似的指定异常原因的构造方法： Exception(String message, Throwable cause) 构造带指定详细消息和原因的新异常。 Exception(Throwable cause) 根据指定的原因和 (cause==null ? null : cause.toString()) 的详细消息构造新异常（它通常包含 cause 的类和详细消息）。 因此，可以通过扩展Exception类来构造带有异常原因的新的异常类。 七、Java异常处理的原则和技巧 1、避免过大的try块，不要把不会出现异常的代码放到try块里面，尽量保持一个try块对应一个或多个异常。 2、细化异常的类型，不要不管什么类型的异常都写成Excetpion。 3、catch块尽量保持一个块捕获一类异常，不要忽略捕获的异常，捕获到后要么处理，要么转译，要么重新抛出新类型的异常。 4、不要把自己能处理的异常抛给别人。 5、不要用try...catch参与控制程序流程，异常控制的根本目的是处理程序的非正常情况。

用来抛出io的错误，不仅仅是文件读写，还包括很多stream的读写，而且throws是用来放在函数定义的函数体前函数名后的，表示这个函数将会在出现异常的书后会抛出io异常，所以在以后的程序中调用这个函数的时候就必须用try和catch来捕获异常，否则编译会抱错，这主要涉及到java的安全机制，可能规模小的程序不见的比if判断更方便，可是在多人开发的规模比较大的程序开发过程中就能充分体会他的好处

1、作用不同：throw用于程序员自行产生并抛出异常；throws用于声明在该方法内抛出了异常2、使用的位置不同：throw位于方法体内部，可以作为单独语句使用；throws必须跟在方法参数列表的后面，不能单独使用。3、内容不同：throw抛出一个异常对象，且只能是一个；throws后面跟异常类，而且可以有多个。

1、作用不同：throw用于程序员自行产生并抛出异常；throws用于声明在该方法内抛出了异常2、使用的位置不同：throw位于方法体内部，可以作为单独语句使用；throws必须跟在方法参数列表的后面，不能单独使用。3、内容不同：throw抛出一个异常对象，且只能是一个；throws后面跟异常类，而且可以有多个。

你可以这样写public void function() throws Exception { ...... throw new Exception(); ...... } 也可以这样写public void function() { try{..........}catch(Exception e){............}}

throws 声明异常throw 抛出异常try 捕捉异常catch 报出异常执行的操作finally 必须执行的代码 如:关闭Connection

throws 主要是给调用者看的，如果调用者发现这个方法抛出异常，那么他必须一：处理这个异常二：或者抛出这个异常

你可以自己定义异常是什么，并且给异常信息，如果别人调用你的方法时就要try/catch你封装的异常，这样只要执行有异常就知道你定义的异常信息是什么，方便别人封装或者修改！希望能帮到你！

throws是把要处理的异常给回避过去了，在当时不做处理，但是当调用抛方法的异常时候必须处理该方法回避的异常，当然，这时还可以回避此异常。就是这个意思，在实际应用中，比如数据库的操作， ResultSet Rs;当Rs.next() 方法时系统会提示你必须处理SQLException异常，但是此时你不想处理那么就用throws关键给回避掉。等调用这个方法的时候再处理异常，这样很多个异常只在一个方法里处理就好了，可以节省很多的代码。至于你说的什么情况下不用通过throws关键字声明转移异常，当你在这个方法中要处理这个异常的时候就不用了。不想处理就抛出去。有些异常是可处理也可不处理的比如控指针异常， 你可以不抛出的，但是系统会接收到，如果API中的方法定义是否回避了某个异常你再使用时会否必须处理该异常，不想再使用时候处理就必须回避掉。可能你听得有点模糊不懂在联系吧，你问的就含糊，对throws关键的真正用途还缺乏了解。

当方法里有异常时：有两种处理方式：1、抛出异常，交给调用者处理2、方法里自己将这个异常try catch，捕获异常，并进行异常处理第一种：抛出异常，交给调用者处理时，就需要在方法头上追加throws 来抛出可能发生的所有异常而第二种，使用try catch方法，将可能发生异常的代码包裹，进行异常处理，是不用在方法头上抛出异常的try｛可能出现异常的代码...｝catch（Exception ex）｛异常处理...｝finally｛不管是否出现异常，都将会执行，一般用于关闭释放资源..｝

有区别

对于这个理解和应用是这样的，比如在项目开发中，定义好了接口，如果你想把接口里出错抛出来就用throw否则你就用try catch自己处理。我们开发一般分为action business dao三层如果dao插入数据出错了你用try，catch处理完页面无法知道错在哪里，你可以抛给business，business再抛到action，action再跳到相应的处理页面。try，catch相当于错误止于我这，你们就不用理了。而throw是把错误抛给别人处理自己不管了。这是两种完全不同的作法。

您好，提问者： 这里一言半句说也不清楚，请看CSDN的详细说明吧。 链接地址：http://blog.csdn.net/cynhafa/article/details/6821657

你想要抛出异常的时候就是要用throws

你用try catch，当然throw没用了。两者的意义不同，throw是发现异常不进行任何处理，直接抛给上一级，在实际工作中开发项目这是不允许的！只要有可能发生异常的地方，都要用try catch捕获并对异常进行适当的处理，不可以把异常随便就往外抛。

异常捕获有三种 就像数据库的一样可以用throws Exception 和try{}

IO错误，文件读写错误

没毛病

代码中抛出异常，只要不是runtime的，方法上必须得throws啊

是不是数据库链接用完没释放 用了几天达到上限了

countomet类在吗？记不清了，对象数组是new 构造[]还是new 类名[](ー_ー)!!

环境变量，eclipse得开发环境都改成一致的

描述的不够详细，可能是强制终止平台导致后台进程未及时退出，过会再进平台就行了，或者启动任务管理器关闭的里面的第一个javaw.exe试试

这个信息，表示已经运行结束了

提示的是程序运行完成，已经退出了，报错会显示在console里面的

CBABBA

讲下LinkedHashSet，他的优点是按照插入顺序排列，速度略慢详细描述：LinkedHashMap和LinkedHashSet是JDK 1.4中引入的两个新的集合类。虽然已经过去5年了，但我敢打赌并不是很多人都用过（因为我就没有用过）。但这两个类在某些情况下还是非常有用的，过去没有用，现在没有用，都没有关系。但还是应该对这两个Collection框架的新成员有所了解，因为也许以后你会到，或者其实你现在就应该要用到。LinkedHashMap/LinkedHashSet 顾名思义，就是在Hash的实现上添加了Linked的支持。对于HashMap/HashSet的每个节点上通过一个链表串联起来，这样就可以保证确定的顺序。对于希望有常量复杂度的高效存取性能要求，同时有要求排序的情况下，现在可以直接使用LinkedHashMap/Set了。对于LinkedHashMap还有一点特别注意，LinkedHashMap支持两种排序：插入顺序、访问顺序。前者是指按照插入时的顺序排序，后者是指按照最旧使用到最近使用的顺序。即如果在一个LinkedHashMap中有5个节点，现在的顺序是e1, e2, e3, e4, e5. 如果是使用顺序的话，现在访问了一次e2, 那么e2节点将移至链表的尾部。现在顺序变为：e1, e3, e4, e5, e2. 这会造成严重的性能问题吗？答案当然是否定的。因为在这儿的链表操作是常量级的。这也是LinkedHashMap/Set在这儿比TreeMap/Set性能更高的原因。同样，LinkedHashMap/Set也不是thread-safe的。如果在多线程下访问，是需要进行外部同步，或者使用Collections.synchronizedMap()的方法包装成一个thread-safe的Map/Set。特别需要注意的是，在使用“访问顺序”时，读取节点操作也是“结构变化”的操作。因为，这会改变元素遍历的顺序。所以，在使用LinkedHashMap的iterator()方法，遍历元素时，如果其它线程有读取操作，也要进行同步。否则，也会抛出同其它fail-fast一样的由于删除或增加操作而引起的CurrentModificationException的例外。LinkedHashMap,HashMap等

CssSelectorNodeFilter alertFilter = new CssSelectorNodeFilter("div[class="ge_fl"]");NodeList divNodeList = parser.extractAllNodesThatMatch(divFilter);for (int i = 0; i < divNodeList.size(); i++) {Div oneDiv = (Div) divNodeList.elementAt(i);if(...){ //根据你具体去判断NodeList list = divNodeList.elementAt(i).getChildren();if(...){//根据你具体去判断}}}

jdk的问题吧。

哟 你们也用 springmvc啊 看样子 是你这个zip 包 损坏了 你用 winrar 能打开吗?

LinkedList 与 ArrayList 很相似。LinkedList 主要用来插入和删除ArrayList主要用来查询代码如下：import java.util.LinkedList;public class Test6 { public static void main(String[] args) { LinkedList<StudentGrade> studentGradeList = new LinkedList<StudentGrade>(); StudentGrade s1 = new StudentGrade(100, 99, 94, 90); StudentGrade s2 = new StudentGrade(70, 70, 84, 89); StudentGrade s3 = new StudentGrade(0, 87, 85, 90); StudentGrade s4 = new StudentGrade(100, 100, 99, 96); StudentGrade s5 = new StudentGrade(60, 68, 70, 65); studentGradeList.add(s1); studentGradeList.add(s2); studentGradeList.add(s3); studentGradeList.add(s4); studentGradeList.add(s5); System.out.println("Student # Grade 1 Grade 2 Grade 3 Grade 4 Average"); int number = 1; for(StudentGrade s : studentGradeList){ System.out.println(number+" "+s.grade1+" "+s.grade2+" "+s.grade3+" "+s.grade4+" "+s.getAverage()); number++; } }}class StudentGrade{ public int grade1; public int grade2; public int grade3; public int grade4; public StudentGrade(int grade1, int grade2, int grade3,int grade4) { this.grade1 = grade1; this.grade2 = grade2; this.grade3 = grade3; this.grade4 = grade4; } public double getAverage(){ return (grade1+grade2+grade3+grade4)/4.0 ; }}

讲下LinkedHashSet，他的优点是按照插入顺序排列，速度略慢x0dx0ax0dx0a详细描述：x0dx0aLinkedHashMap和LinkedHashSet是JDK 1.4中引入的两个新的集合类。虽然已经过去5年了，但我敢打赌并不是很多人都用过（因为我就没有用过）。但这两个类在某些情况下还是非常有用的，过去没有用，现在没有用，都没有关系。但还是应该对这两个Collection框架的新成员有所了解，因为也许以后你会到，或者其实你现在就应该要用到。x0dx0ax0dx0aLinkedHashMap/LinkedHashSet 顾名思义，就是在Hash的实现上添加了Linked的支持。对于HashMap/HashSet的每个节点上通过一个链表串联起来，这样就可以保证确定的顺序。对于希望有常量复杂度的高效存取性能要求，同时有要求排序的情况下，现在可以直接使用LinkedHashMap/Set了。x0dx0ax0dx0a对于LinkedHashMap还有一点特别注意，LinkedHashMap支持两种排序：插入顺序、访问顺序。前者是指按照插入时的顺序排序，后者是指按照最旧使用到最近使用的顺序。即如果在一个LinkedHashMap中有5个节点，现在的顺序是e1, e2, e3, e4, e5. 如果是使用顺序的话，现在访问了一次e2, 那么e2节点将移至链表的尾部。现在顺序变为：e1, e3, e4, e5, e2. x0dx0ax0dx0a这会造成严重的性能问题吗？答案当然是否定的。因为在这儿的链表操作是常量级的。这也是LinkedHashMap/Set在这儿比TreeMap/Set性能更高的原因。x0dx0ax0dx0a同样，LinkedHashMap/Set也不是thread-safe的。如果在多线程下访问，是需要进行外部同步，或者使用Collections.synchronizedMap()的方法包装成一个thread-safe的Map/Set。x0dx0ax0dx0a特别需要注意的是，在使用“访问顺序”时，读取节点操作也是“结构变化”的操作。因为，这会改变元素遍历的顺序。所以，在使用LinkedHashMap的iterator()方法，遍历元素时，如果其它线程有读取操作，也要进行同步。否则，也会抛出同其它fail-fast一样的由于删除或增加操作而引起的CurrentModificationException的例外。x0dx0ax0dx0aLinkedHashMap,HashMap等

我没有运行，但是我觉得你第5行已经把temp(此时等于head)的next置为null了，第9行还要进行curr.getNext()(注意curr的些前一直没变，也就是还等于head, 而head的next是null, ), 于是curr的值变成了null，而你在第10行还写 n = curr.getNext(), curr本身是null, 再通过curr引用来进行函数调用就会出现空指针异常；另外，你的程序逻辑上有问题，while的判断应用是while(n != null)

//包装List list = new ArrayList();for (Iterator iterator = queryList.iterator(); iterator.hasNext();) { GodownEntryItem entryItem = (GodownEntryItem) iterator.next(); GodownEntryInfoBean entryInfoBean = new GodownEntryInfoBeanentryItem.getGodownEntry(), entryItem); list.add(entryInfoBean);}

List<String> myNameCollect = new ArrayList<String>();myNameCollect .add("Bill");myNameCollect .add("Jonse");myNameCollect .add("Goupi");

import java.util.List;import java.util.ArrayList;public class test4 implements Serializable{ public static void main(String[] args) throws Exception, Exception{ String s = new String("eeee,rrr,tttt,yyy,uuu,,iii"); List<String> list = new ArrayList<String>(); String[] newstr = s.split(","); for(int i =0;i<newstr.length;i++){ list.add(newstr[i]); }System.out.println(list); }}是不是这样？

List接口对Collection进行了简单的扩充，它的具体实现类常用的有ArrayList和LinkedList。你可以将任何东西放到一个List容器中，并在需要时从中取出。ArrayList从其命名中可以看出它是一种类似数组的形式进行存储，因此它的随机访问速度极快，而LinkedList的内部实现是链表，它适合于在链表中间需要频繁进行插入和删除操作。在具体应用时可以根据需要自由选择。前面说的Iterator只能对容器进行向前遍历，而ListIterator则继承了Iterator的思想，并提供了对List进行双向遍历的方法。Set接口也是Collection的一种扩展，而与List不同的时，在Set中的对象元素不能重复，也就是说你不能把同样的东西两次放入同一个Set容器中。它的常用具体实现有HashSet和TreeSet类。HashSet能快速定位一个元素，但是你放到HashSet中的对象需要实现hashCode()方法，它使用了前面说过的哈希码的算法。而TreeSet则将放入其中的元素按序存放，这就要求你放入其中的对象是可排序的，这就用到了集合框架提供的另外两个实用类Comparable和Comparator。一个类是可排序的，它就应该实现Comparable接口。有时多个类具有相同的排序算法，那就不需要在每分别重复定义相同的排序算法，只要实现Comparator接口即可。集合框架中还有两个很实用的公用类：Collections和Arrays。Collections提供了对一个Collection容器进行诸如排序、复制、查找和填充等一些非常有用的方法，Arrays则是对一个数组进行类似的操作。Map是一种把键对象和值对象进行关联的容器，而一个值对象又可以是一个Map，依次类推，这样就可形成一个多级映射。对于键对象来说，像Set一样，一个Map容器中的键对象不允许重复，这是为了保持查找结果的一致性;如果有两个键对象一样，那你想得到那个键对象所对应的值对象时就有问题了，可能你得到的并不是你想的那个值对象，结果会造成混乱，所以键的唯一性很重要，也是符合集合的性质的。当然在使用过程中，某个键所对应的值对象可能会发生变化，这时会按照最后一次修改的值对象与键对应。对于值对象则没有唯一性的要求。你可以将任意多个键都映射到一个值对象上，这不会发生任何问题（不过对你的使用却可能会造成不便，你不知道你得到的到底是那一个键所对应的值对象）。Map有两种比较常用的实现：HashMap和TreeMap。HashMap也用到了哈希码的算法，以便快速查找一个键，TreeMap则是对键按序存放，因此它便有一些扩展的方法，比如firstKey(),lastKey()等，你还可以从TreeMap中指定一个范围以取得其子Map。键和值的关联很简单，用pub(Object key,Object value)方法即可将一个键与一个值对象相关联。用get(Object key)可得到与此key对象所对应的值对象。

list.add(ele);

List是接口List子类之一是AbstractList<E>，实现List中的部分方法ArryList继承抽象类AbstractList<E>

可以.list存放对象,list本身也是对象.

1、集合可以有List，vector等，其实map也是一个集合2、这些集合有啥用呢，就好比你有一堆数据要存：[name="张三",age=20,address="北京"][name="李四",age=15,address="湖南"][name="王五",age=18,address="甘肃"]等等，这样一条一条的数据你就能够用集合来保存起来，放到一条集合中去3、例如用list来保存，保存形式就如下：list={[name="张三",age=20,address="北京"]，[name="李四",age=15,address="湖南"]，[name="王五",age=18,address="甘肃"]};这样的形式了，然后取值的时候你就可以根据list.get(i)来分别取值了。4、如果要取到每一条里面的属性，那么可以配合map或者存储的是实体类对象，来分别取值就对了，非常的简单且实用

import java.util.ArrayList;import java.util.List;public class testAddAZ {public static void main(String[] args) { List list = new ArrayList(); char add = "A"; for(int i=0;i<26;i++){ list.add(add); add++; } for(int i=list.size()-1;i>=0;i--){ System.out.print(list.get(i)+" "); } }}晕直接剃增不就行了。。。。。。

推荐楼主试试ssh，非常经典

以下是一些常见的Java开源项目：1. Spring Framework：基于Java平台的应用开发框架。2. Hibernate ORM：Java持久化框架。3. Apache Tomcat：开源的Servlet容器，用于运行Java Web应用程序。4. Apache Struts：基于MVC架构的Web应用程序开发框架。5. Apache Maven：自动化构建工具，用于管理Java项目的构建、依赖和文档。6. Apache Lucene：全文搜索引擎库。7. Junit：Java单元测试框架。8. Log4j：Java日志框架。9. MyBatis：Java持久化框架，支持自定义SQL、存储过程或高级映射。10. Apache Kafka：分布式流处理平台。11. Elasticsearch：开源全文搜索和分析引擎。12. Apache Spark：一种快速、分布式大数据处理引擎。13. Netty：异步事件驱动的网络应用程序框架。14. Jakarta EE：Java企业级应用程序开发平台。15. Apache Cassandra：分布式数据库，无单点故障，可扩展性高。

java基础，三大主流数据库mysql，orcale，sql server；然后是j2ee的相关知识，也就是java开发框架。Spring Framework 【Java 开源JEE框架】 Spring是一个解决了许多在J2EE开发中常见的问题的强大框架。 Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯。Spring的架构基础是基于使用JavaBean属性的 Inversion of Control容器。然而，这仅仅是完整图景中的一部分：Spring在使用IoC容器作为构建完关注所有架构层的完整解决方案方面是独一无二的。 Spring提供了唯一的数据访问抽象，包括简单和有效率的JDBC框架，极大的改进了效率并且减少了可能的错误。Spring的数据访问架构还集成了 Hibernate和其他O/R mapping解决方案。Spring还提供了唯一的事务管理抽象，它能够在各种底层事务管理技术，例如JTA或者 JDBC事务提供一个一致的编程模型。Spring提供了一个用标准Java语言编写的AOP框架，它给POJOs提供了声明式的事务管理和其他企业事务 --如果你需要--还能实现你自己的aspects。这个框架足够强大，使得应用程序能够抛开EJB的复杂性，同时享受着和传统EJB相关的关键服务。 Spring还提供了可以和IoC容器集成的强大而灵活的MVC Web框架。【SpringIDE：Eclipse平台下一个辅助开发插件】. WebWork 【Java开源Web开发框架】 WebWork是由OpenSymphony组织开发的，致力于组件化和代码重用的拉出式MVC模式J2EE Web框架。WebWork目前最新版本是2.1，现在的WebWork2.x前身是Rickard Oberg开发的WebWork，但现在WebWork已经被拆分成了Xwork1和WebWork2两个项目。 Xwork简洁、灵活功能强大，它是一个标准的Command模式实现，并且完全从web层脱离出来。 Xwork提供了很多核心功能：前端拦截机(interceptor)，运行时表单属性验证，类型转换，强大的表达式语言(OGNL – the Object Graph Notation Language)，IoC(Inversion of Control倒置控制)容器等。 WebWork2建立在Xwork之上，处理HTTP的响应和请求。WebWork2使用ServletDispatcher将HTTP请求的变成 Action(业务层Action类), session(会话)application(应用程序)范围的映射，request请求参数映射。WebWork2支持多视图表示，视图部分可以使用 JSP, Velocity, FreeMarker, JasperReports，XML等。在WebWork2.2中添加了对AJAX的支持，这支持是构建在DWR与Dojo这两个框架的基础之上. 【EclipseWork：用于WebWork辅助开发的一个Eclipse插件】 Struts 【Java开源Web开发框架】 Struts是一个基于Sun J2EE平台的MVC框架，主要是采用Servlet和JSP技术来实现的。由于Struts能充分满足应用开发的需求，简单易用，敏捷迅速，在过去的一年中颇受关注。Struts把Servlet、JSP、自定义标签和信息资源(message resources)整合到一个统一的框架中，开发人员利用其进行开发时不用再自己编码实现全套MVC模式，极大的节省了时间，所以说Struts是一个非常不错的应用框架。【StrutsIDE：用于Struts辅助开发的一个Eclipse插件】 Hibernate 【Java开源持久层框架】 Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序实用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。Eclipse平台下的Hibernate辅助开发工具:【Hibernate Synchronizer】【MiddlegenIDE】 Quartz 【Java开源调度框架】 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的日程序表。Jobs可以做成标准的Java组件或 EJBs。Quartz的最新版本为Quartz 1.5.0。 Velocity 【Java开源模板引擎】 Velocity是一个基于java的模板引擎(template engine)。它允许任何人仅仅简单的使用模板语言(template language)来引用由java代码定义的对象。当Velocity应用于web开发时，界面设计人员可以和java程序开发人员同步开发一个遵循MVC架构的web站点，也就是说，页面设计人员可以只关注页面的显示效果，而由java程序开发人员关注业务逻辑编码。Velocity将java代码从web页面中分离出来，这样为web站点的长期维护提供了便利，同时也为我们在JSP和PHP之外又提供了一种可选的方案。 Velocity的能力远不止web站点开发这个领域，例如，它可以从模板(template)产生SQL和PostScript、XML，它也可以被当作一个独立工具来产生源代码和报告，或者作为其他系统的集成组件使用。Velocity也可以为Turbine web开发架构提供模板服务(template service)。Velocity+Turbine提供一个模板服务的方式允许一个web应用以一个真正的MVC模型进行开发。【VeloEclipse ：Velocity在Eclipse平台下的一个辅助开发插件】 IBATIS 【Java开源持久层框架】 使用ibatis 提供的ORM机制，对业务逻辑实现人员而言，面对的是纯粹的Java对象， 这一层与通过Hibernate 实现ORM 而言基本一致，而对于具体的数据操作，Hibernate 会自动生成SQL 语句，而ibatis 则要求开发者编写具体的SQL 语句。相对Hibernate等 “全自动”ORM机制而言，ibatis 以SQL开发的工作量和数据库移植性上的让步，为系统设计提供了更大的自由空间。作为“全自动”ORM 实现的一种有益补充，ibatis 的出现显 得别具意义。 Compiere ERP&CRM 【Java开源ERP与CRM系统】 Compiere ERP&CRM为全球范围内的中小型企业提供综合型解决方案，覆盖从客户管理、供应链到财务管理的全部领域，支持多组织、多币种、多会计模式、多成本计算、多语种、多税制等国际化特性。易于安装、易于实施、易于使用。只需要短短几个小时，您就可以使用申购-采购-发票-付款、报价-订单-发票-收款、产品与定价、资产管理、客户关系、供应商关系、员工关系、经营业绩分析等强大功能了。 Roller Weblogger 【Java开源Blog博客】 这个weblogging 设计得比较精巧，源代码是很好的学习资料。它支持weblogging应有的特性如：评论功能，所见即所得HTML编辑，TrackBack，提供页面模板，RSS syndication,blogroll管理和提供一个XML-RPC 接口。 Eclipse 【Java开源IDE】 Eclipse平台是IBM向开发源码社区捐赠的开发框架，它之所以出名并不是因为IBM宣称投入开发的资金总数 —4千万美元，而是因为如此巨大的投入所带来的成果：一个成熟的、精心设计的以及可扩展的体系结构。 XPlanner 【Java开源项目管理】 XPlanner 一个基于Web的XP团队计划和跟踪工具。XP独特的开发概念如iteration、user stories等，XPlanner都提供了相对应的的管理工具，XPlanner支持XP开发流程，并解决利用XP思想来开发项目所碰到的问题。 XPlanner特点包括：简单的模型规划，虚拟笔记卡(Virtual note cards),iterations、user stories与工作记录的追踪，未完成stories将自动迭代，工作时间追踪，生成团队效率，个人工时报表，SOAP界面支持。 HSQLDB 【Java开源开源数据库】 HSQLDB(Hypersonic SQL)是纯Java开发的关系型数据库,并提供JDBC驱动存取数据。支持ANSI-92 标准 SQL语法。而且他占的空间很小。大约只有160K,拥有快速的数据库引擎。Liferay 【Java开源门户系统】 代表了完整的J2EE应用，使用了Web、EJB以及JMS等技术，特别是其前台界面部分使用Struts 框架技术，基于XML的portlet配置文件可以自由地动态扩展，使用了Web Services来支持一些远程信息的获取，使用 Apahce Lucene实现全文检索功能。 主要特点： 提供单一登陆接口，多认证模式(LDAP或 SQL); 管理员能通过用户界面轻松管理用户，组，角色; 用户能可以根据需要定制个性化的portal layout; 能够在主流的J2EE应用服务器上运行，如JBoss+Jetty/Tomcat,JOnAS; 支 持主流的数据库，如PostgreSQL,MySQL; 使用了第三放的开源项目，如Hibernate, Lucene, Struts; 支持包括中文在内的多种语言; 采用最先进的技术 Java, EJB, JMS, SOAP, XML; JetSpeed 【Java开源门户系统】 Jetspeed是一个开放源代码的企业信息门户(EIP)的实现, 使用的技术是Java和XML. 用户可以使用浏览器, 支持WAP协议的手机或者其它的设备访问Jetspeed架设的信息门户获取信息. Jetspeed扮演着信息集中器的角色, 它能够把信息集中起来并且很容易地提供给用户. Jetspeed具有如下的特征: 即将成为标准化的Java Portlet API 基于模板的布局, 包括JSP和Velocity 通过开放的内容同步技术支持远程XML 内容交换 定制默认的主页 使用数据库进行用户认证 内存缓存技术, 加快页面的响应 通 过Rich Site Summary技术, 支持同步内容 和Cocoon, WebMacro, Velocity集成. Wireless Markup Language (WML) 支持 使用XML格式的配置文件注册portlet. 完整的 Web Application Archive (WAR) 支持 Web应用程序开发的基础设施 可以在本地缓 存远程内容 与Avantgo同步 可移植到所有支持JDK1.2和Servlet 2.2的平台 与 Turbine模块和服务集成 可以根据用户, 安装媒体类型和语言的不同设定, 产生不同的个性化服务 持续化服 务使得所由的portlet能够容易的存储每个用户的状态, 页面和portlet 使用皮肤技术使得用户可以选择portlet的颜 色和显示属性 自定义功能是的管理员可以选择portlet以及定义个人页面的布局 在数据库中存储PSML 通 过Jetspeed的安全portlets管理用户, 组,角色和权限 基于角色对访问portlet进行控制 JOnAS 【Java开源应用服务器】 JOnAS是一个开放源代码的J2EE实现，在ObjectWeb协会中开发。整合了Tomcat或Jetty成为它的Web容器，以确保符合Servlet 2.3和JSP 1.2规范。JOnAS服务器依赖或实现以下的Java API：JCA、JDBC、JTA 、JMS、JMX、JNDI、JAAS、JavaMail 。 JFox3.0 【Java开源应用服务器】 JFox 是 Open Source Java EE Application Server，致力于提供轻量级的Java EE应用服务器，从3.0开始，JFox提供了一个支持模块化的MVC框架，以简化EJB以及Web应用的开发! 如果您正在寻找一个简单、轻量、高效、完善的Java EE开发平台，那么JFox正是您需要的。 JFox 3.0 拥有以下特性： 重 新设计的 IoC 微内核，融入 OSGi 模块化思想 设计成嵌入式架构，能够和任何 Java Web Server集成部署 支 持 EJB3，JPA规范，支持容器内和容器外两种方式运行EJB和JPA组件 支持 EJB 发布成Web Service 采 用 JOTM(http://jotm.objectweb.org/)提供事务处理，支持两阶段提交 (2PC) 采用 XAPool(http://forge.objectweb.org/projects/xapool/) 提供 XA DataSource，支持智能连接池管理 内置 MVC 框架，实现自动Form Mapping,Validator,Uploading等功能，支持JSP/Velocity/Freemarker页面引擎，并支持直接在 Action中注入EJB 支持多应用模块部署，让中大型应用充分享受模块化开发带来的优势 提供 Manager 管理模块，可以查看和管理各种运行时参数 提供根据 JFox 特色重写的 Petstore 应用模块 EasyJWeb 【Java开源Web开发框架】 EasyJWeb是基于java技术，应用于WEB应用程序快速开发的MVC框架，框架设计构思来源于国内众多项目实践，框架充分借签了当前主要流行的开源Web框架(Struts、JSF、Tapestry 、Webwork)，吸取了其优点及精华，利用Velocity作为模板页面引擎，是一个实现了页面及代码完全分离的MVC开发框架。是一个能实现中小型 Web应用系统快速开发的简易Web框架。 通过EasyJWeb Tools提供的配套开发工具，可以实现基于EasyJWeb框架的Web应用快速开发，包括常用应用软件的代码自生成、数据库添删改查(CRUD)代码生成、自动页面模版生成、配置文件管理等。 框架特点： 零配文件置支持。以前我们每接触一个框架，开始总都要被 他的配置文件折腾一番。EasyJWeb实现零配置支持，可以不写一句配置文件就在框架基础上构建你的运用。(适合小型网站系统)。 简 易的模板页面设计支持：放弃使用jsp，使用简单Velocity脚本语言作为页面模板。 页面程序完全分离：实现显示页面与程序逻辑 的完全分离，克服了传统jsp页面难于维护的问题。 基于页面组件的框架。灵活的页面组件配置，可以直接通过配置文件设置字段级的事件 组件。 快速开发支持：通过EasyJWeb Tools，可以自动生成应用软件模板代码，定制并管理自己的J2EE代码模板，代码生成模板支持最流行的实用Java开发框架(如hibernate、 Spring等)实现快速开发。 Tapestry 【Java开源Web开发框架】 Tapestry是一个开源的基于servlet的应用程序框架，它使用组件对象模型来创建动态的，交互的web应用。一个组件就是任意一个带有 jwcid属性的html标记。其中jwc的意思是Java Web Component。Tapestry使得java代码与html完全分离，利用这个框架开发大型应用变得轻而易举。并且开发的应用很容易维护和升级。 Tapestry支持本地化，其错误报告也很详细。Tapestry主要利用javabean和xml技术进行开发。【Spindle:Tapestry 辅助开发Eclipse插件】. FreeMarker 【Java开源模板引擎】 FreeMarker允许Java servlet保持图形设计同应用程序逻辑的分离，这是通过在模板中密封HTML完成的。模板用servlet提供的数据动态地生成 HTML。模板语言是强大的直观的，编译器速度快，输出接近静态HTML页面的速度。 【FreeMarker Eclipse Plugin与FreeMarker IDE：Eclipse平台下的辅助开发工具】 Lucene 【Java开源搜索引擎】 Apache Lucene是一个基于Java全文搜索引擎，利用它可以轻易地为Java软件加入全文搜寻功能。Lucene的最主要工作是替文件的每一个字作索引，索引让搜寻的效率比传统的逐字比较大大提高，Lucen提供一组解读，过滤，分析文件，编排和使用索引的API，它的强大之处除了高效和简单外，是最重要的是使使用者可以随时应自已需要自订其功能。 iText 【Java开源PDF类库】 iText是一个能够快速产生PDF文件的java类库。iText的java类对于那些要产生包含文本，表格，图形的只读文档是很有用的。它的类库尤其与java Servlet有很好的给合。使用iText与PDF能够使你正确的控制Servlet的输出。 Groovy 【Java开源动态语言】 Groovy是一种基于JVM的敏捷开发语言，它结合了Python、Ruby和 Smalltalk的许多强大的特性。 Groovy已在WebWork2中的应用。它可以被编译为标准的Java Bytecode。 OpenCms 【Java开源CMS系统】 OpenCms是一个J2EE的产品，它是用 Java写成的。它和Tomcat捆绑在一起。但是也能够使用ATG Dynamo、WebLogic和WebSphere。OpenCms支持多种RDBMS来保存内容，包括Oracle、SQL Server、Sybase和mySQL。新版本提供了一个新的模板引擎，JSP支持，一种新的连接管理系统，提高了稳定性。 JUnit 【Java开源测试工具】 JUnit是由 Erich Gamma 和 Kent Beck 编写的一个回归测试框架(regression testing framework)。Junit测试是程序员测试，即所谓白盒测试，因为程序员知道被测试的软件如何(How)完成功能和完成什么样(What)的功能。Junit是一套框架，继承TestCase类，就可以用Junit进行自动测试了。 BlueJ 【Java开源IDE】 BlueJ是一个专门为入门级教学设计的JavaTM 开发环境。它是由澳大利亚墨尔本Monash大学BlueJ小组设计并开发的。 XWiki 【Java开源Wiki系统】 XWiki是一个强大的Java开源的Wiki引擎。它支持一些受欢迎的特性如： 内 容管理(浏览/编辑/预览/保存)， 支持附件， 版本控制， 全文本搜索， 权 限管理 使用Hibernate进行数据存储， RSS输出与显示外部的RSS feeds， 多 语言支持， 提供XML/RPC的API, WYSIWYG HTML编辑器, 导出为PDF Groovy 脚本支持等等....。 EJBCA 【Java开源网络服务器端组件】 EJBCA是一个全功能的CA系统软件，它基于J2EE技术，并提供了一个强大的、高性能并基于组件的CA。EJBCA兼具灵活性和平台独立性，能够独立使用，也能和任何J2EE应用程序集成。 JXTA 【Java开源其它项目】 Sun微系统公司公开了旨在建立P2P(Peer to Peer)通用技术基础的JXTA计划。JXTA技术是网络编程和计算的平台，用以解决现代分布计算尤其是点对点(P2P)计算中出现的问题。 JXTA将建立核心的网络计算技术，提供支持在任何平台、任何地方以及任何时间实现P2P计算的一整套简单、小巧和灵活的机制。JXTA首先将归纳目前 P2P的功能特别，而后建立核心的技术来表达目前的P2P计算的局限性。其重点是创建基本的机制，而具体的策略选择权则交给应用的开发者。JXTA将充分利用XML、Java等开放技术，使得UNIX操作系统更强大和灵活，比如利用管道(Pipes)传输Shell命令实现复杂的计算任务。JXTA支持 P2P应用的基本功能来建立一个P2P系统，还将努力证实这些可以成为建立更高层功能的基础构造模块。JXTA架构可以分为三个层面：JXTA核心层、 JXTA业务层和JXTA应用层。 DWR 【Java开源AJAX框架】 DWR(Direct Web Remoting)是一个WEB远程调用框架.利用这个框架可以让AJAX开发变得很简单.利用DWR可以在客户端利用JavaScript直接调用服务端的Java方法并返回值给JavaScript就好像直接本地客户端调用一样(DWR根据Java类来动态生成JavaScrip代码).它的最新版本 DWR0.6添加许多特性如:支持Dom Trees的自动配置,支持Spring(JavaScript远程调用spring bean),更好浏览器支持,还支持一个可选的commons-logging日记操作. ZK 【Java开源AJAX框架】 ZK是一个Ajax Java Web框架，利用少量代码就能够开发出拥有Rich UI的Web应用。ZK提供基于XUL的标记语言和事件驱动的组件，可以让你像开发桌面应用程序一样简单。支持EL表达式和脚本语言包括：JavaScript、Ruby和Groovy等。支持Annotation及数据绑定。集成Google Maps、FCKeditor、DOJO以及Timeline。

Spring Framework 【Java开源 J2EE框架】Spring是一个解决了许多在J2EE开发中常见的问题的强大框架。 Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯。Spring的架构基础是基于使用JavaBean属性的Inversion of Control容器。然而，这仅仅是完整图景中的一部分：Spring在使用IoC容器作为构建完关注所有架构层的完整解决方案方面是独一无二的。 Spring提供了唯一的数据访问抽象，包括简单和有效率的JDBC框架，极大的改进了效率并且减少了可能的错误。Spring的数据访问架构还集成了Hibernate和其他O/R mapping解决方案。Spring还提供了唯一的事务管理抽象，它能够在各种底层事务管理技术，例如JTA或者JDBC事务提供一个一致的编程模型。Spring提供了一个用标准Java语言编写的AOP框架，它给POJOs提供了声明式的事务管理和其他企业事务--如果你需要--还能实现你自己的aspects。这个框架足够强大，使得应用程序能够抛开EJB的复杂性，同时享受着和传统EJB相关的关键服务。Spring还提供了可以和IoC容器集成的强大而灵活的MVC Web框架。【SpringIDE：Eclipse平台下一个辅助开发插件】.WebWork 【Java开源 Web框架】 WebWork是由OpenSymphony组织开发的，致力于组件化和代码重用的拉出式MVC模式J2EEWeb框架。WebWork目前最新版本是2.1，现在的WebWork2.x前身是Rickard Oberg开发的WebWork，但现在WebWork已经被拆分成了Xwork1和WebWork2两个项目。 Xwork简洁、灵活功能强大，它是一个标准的Command模式实现，并且完全从web层脱离出来。 Xwork提供了很多核心功能：前端拦截机（interceptor），运行时表单属性验证，类型转换，强大的表达式语言（OGNL – the Object Graph Notation Language），IoC（Inversion of Control倒置控制）容器等。 WebWork2建立在Xwork之上，处理HTTP的响应和请求。WebWork2使用ServletDispatcher将HTTP请求的变成Action(业务层Action类), session（会话）application（应用程序）范围的映射，request请求参数映射。WebWork2支持多视图表示，视图部分可以使用JSP, Velocity, FreeMarker, JasperReports，XML等。在WebWork2.2中添加了对AJAX的支持，这支持是构建在DWR与Dojo这两个框架的基础之上.【EclipseWork：用于WebWork辅助开发的一个Eclipse插件】Apusic JSF 【Java开源 Web框架】 Apusic JSF-基于Ajax技术的JSF开源引擎。通过Apusic JSF的Ajax特性，我们能够只把发生变化的数据打包成Ajax请求发送给服务器端，而服务器端也只会将发生变化的数据打包成Ajax应答，从而大大提升系统的运行效率。并且，传统的JSF请求应答将刷新整个页面，而Apusic JSF将只更新发生变化的客户端组件，从而给客户带来更好的人机体验......Struts 【Java开源 Web框架】Struts是一个基于Sun J2EE平台的MVC框架，主要是采用Servlet和JSP技术来实现的。由于Struts能充分满足应用开发的需求，简单易用，敏捷迅速，在过去的一年中颇受关注。Struts把Servlet、JSP、自定义标签和信息资源(message resources)整合到一个统一的框架中，开发人员利用其进行开发时不用再自己编码实现全套MVC模式，极大的节省了时间，所以说Struts是一个非常不错的应用框架。【StrutsIDE：用于Struts辅助开发的一个Eclipse插件】Strecks 【Java开源 Web框架】 针对Java 5.0开发人员设计，扩展自Struts的一个Web框架。它的特点包括：POJO action,注释式校验，数据绑定和转换，依赖注入，拦截器等。jxyz 【Java开源 Web框架】 pojo的mvc框架，使用java注解，使用ognl传输上下文，使用hivemind做ioc容器，使用spring简化hibernate操作，使用泛型来减少重复代码。 有以下几个特点。1．Pojo。任何一个java类都可以做Action（logic），为了改造现在常用的ssh，tsh，wsh框架成sh，支持spring bean做Action（logic）2．0配置，根据命名规范来查找Action类和view3．和web环境松耦合，从理论上讲可以用在swing里4．支持tdd开发，框架本身就是以tdd开发方式开发5．代码少，一般mvc需要5个类，xyz只要3个，还可以通过GenericDAO，GenericLogic来减少重复代码6．对开发者来说，一切实现都可以自己定制，由于hivemind支持迭代开Hibernate 【Java开源 持久层框架】 Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序实用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。Eclipse平台下的Hibernate辅助开发工具:【Hibernate Synchronizer】【MiddlegenIDE】IBATIS 【Java开源 持久层框架】使用ibatis 提供的ORM机制，对业务逻辑实现人员而言，面对的是纯粹的Java对象， 这一层与通过Hibernate 实现ORM 而言基本一致，而对于具体的数据操作，Hibernate 会自动生成SQL 语句，而ibatis 则要求开发者编写具体的SQL 语句。相对Hibernate等 “全自动”ORM机制而言，ibatis 以SQL开发的工作量和数据库移植性上的让步，为系统 设计提供了更大的自由空间。作为“全自动”ORM 实现的一种有益补充，ibatis 的出现显 得别具意义。EasyJWeb 【Java开源 Web框架】EasyJWeb是基于java技术，应用于WEB应用程序快速开发的MVC框架，框架设计构思来源于国内众多项目实践，框架充分借签了当前主要流行的开源Web框架（Struts、JSF、Tapestry 、Webwork），吸取了其优点及精华，利用Velocity作为模板页面引擎，是一个实现了页面及代码完全分离的MVC开发框架。是一个能实现中小型Web应用系统快速开发的简易Web框架。Tapestry 【Java开源 Web框架】 Tapestry是一个开源的基于servlet的应用程序框架，它使用组件对象模型来创建动态的，交互的web应用。一个组件就是任意一个带有jwcid属性的html标记。其中jwc的意思是Java Web Component。Tapestry使得java代码与html完全分离，利用这个框架开发大型应用变得轻而易举。并且开发的应用很容易维护和升级。Tapestry支持本地化，其错误报告也很详细。Tapestry主要利用javabean和xml技术进行开发。【Spindle:Tapestry辅助开发Eclipse插件】．Turbine 【Java开源 Web框架】Turbine是基于Servlet的框架包，也是开放源代码Jakarta项目。目前还没有关于Turbine的大量文档。它类似于Struts，但是有一些主要区别。突出的一点就是它并没有与JSP耦合。Turbine的特点是它提供了大量可重用的组件。此框架包中包含了大量组件，但是这些组件是离散的。它似乎应该给出更多的组件库，但是由于它缺少文档，所以很难掌握完整的体系结构。Nuxeo5 【Java开源 J2EE框架】 Nuxeo5是一个用于ECM(Enterprise Content Management)应用程序开发的开源框架。基于组件和面向服务的架构使得它真正易于定制和扩展。Nuxeo5构建流行的Java5与Java EE5技术包括：Apache Jackrabbit ,JBoss应用服务器,JBoss Seam,jBPM,JBoss Rules,JSF,EJB3等，并运用OSGi与Nuxeo Core。Jt 【Java开源 J2EE框架】Jt是一个轻量级的,面向设计模式的J2EE框架。Jt已经被运用到一些大型的关键业务系统(mission critical system)。Jt实现了许多著名设计模式包括DAO(Data Access Object),GoF中的设计模式和J2EE模式。该框架支持的一些J2EE技术包括JSP,JDBC,EJB,JavaMail,XML和Web Services。Open-jACOB eMail 【Java开源 WebMail】Open-jACOB eMail是一个轻量级IMAP客户端，基于Javamail API与Open-jACOB框架开发。界面类似于Gmail，它提供的功能包括完整的folder list,message list和contact list。Open-jACOB 【Java开源 Web框架】 Open-jACOB是一个Web框架用于开发基于AJAX，数据库驱动,跨浏览器的Web应用程序。该框架设计成一个基于Eclipse的插件，可以利用该插件设计数据库，设计UI，部署/测试应用程序等。具体用法可查看其提供的一个Flash Demo。Ruby on Spring 【Java开源 Web框架】Ruby on Spring是一个采用Ruby on Rails的思想与优点，集成JRuby动态语言与Spring框架而开发的开源项目。基于MIT license发布。Ebean 【Java开源 持久层框架】Ebean是一个对象/关系映射持久层框架。它与EJB3相类似，但该框架简单易于学习和使用。它特点： 1.兼容EJB3 ORM映射。2.支持级联保存和删除。3.支持懒加载。4.事务管理和日记功能。5.Statement Batching 5.支持缓存。6.Clustering。7.集成Lucene文本搜索。

不是同一种东西，如何比啊，只有js是脚本语言

我粗看了一下，account是账户，它含有一个ArrayList,ArrayList可以理解成一个Transaction类型的数组，list.get(i)就是获得第i笔Transaction的记录。

URLClassLoader loader =new URLClassLoader(new URL[] { new URL("file:" + jarRoute) }); loader.close();

一楼是对的，注意是sscanf，非scanf。

这个急不得了

location对象用于访问当前页面的地址属性：hash 设置或获取 href 属性中在井号“#”后面的分段。 host 设置或获取 location 或 URL 的 hostname 和 port 号码。 hostname 设置或获取 location 或 URL 的主机名称部分。 href 设置或获取整个 URL 为字符串。 pathname 设置或获取对象指定的文件名或路径。 port 设置或获取与 URL 关联的端口号码。 protocol 设置或获取 URL 的协议部分。 search 设置或获取 href 属性中跟在问号后面的部分。 方法：assign 装入新的 HTML 文档。 reload 重新装入当前页面。 replace 装入指定 URL 的另外文档来替换当前文档。 常见用法：location.reload(); // 刷新页面location = "http://www.baidu.com"; //跳转到百度