为了处理PL/SQL应用程序的各种错误，开发人员可以使用各种类型的异常。
Oracle提供了
１：预定义异常
用于处理常见的Oracle错误
２：非预定义异常
用于处理预定义异常所不能处理的Oracle错误
３：自定义异常
用于处理于Oracle错误无关的其他情况
异常处理部分是以关键字EXCEPTION开始的，语法如下：
  EXCEPTION
    WHEN  exception_Name THEN  --exception_Name为异常的名字
      statement1;
    WHEN OTHERS THEN
  statement1;
   


异常处理部分从关键字EXCEPTION开始，在异常处理部分使用WHEN字句捕捉各种异常，如果有其他未预定义到的异常，使用WHEN OTHERS THEN字句进行捕捉和处理。
1、 处理预定义异常，这是系统预定的21种类型
  错误代码是负整数，如-51
     

   
  Access_info_null（ora-06530）
     当访问没有初始化的对象时触发。
   
  Case_not_found(ora-06592)
     case过程中when后没有包含必要的条件分支并且没有else子句，则会触发本异常。
   
  Collection_is_null(06531)
     访问未初始化的集合元素（嵌套表或者varray）。
   
  Cursor_already_open(ora-06511)
     重新打开已经打开的游标。
   
  Dup_val_on_index(ora-00001)
     当中唯一索引所对应的列上键入重复值时。
   
  Invalid_cursor(ora-01001)
     试图在不合法的游标上执行操作时，譬如没打开游标就提取内容
   
  Invalid_number(ora-01722)
     当试图将非法的字符串转换为数字类型时。
   
  No_data_found(ora-01403)
     执行select into未返回行，或者引用了索引表未初始化的元素时。
   
  Too_many_rows(ora-01422)
     执行select into返回超过一行数据时。
   
  Zero_divide(ora-01476)
     0作为被除数时。
   
  Subscript_beyond_count(ora-06533)
     使用嵌套表或者varray集合时，如果引用下标超过last。
   
  Subscript_outside_limit(ora-06532)
     使用嵌套表或varray集合时，如果引用下标小于first。
   
  Value_error(ora-06502)
     在执行赋值操作时，如果变量长度不足以容纳实际数据。
   
  Login_denied(ora-01017)
     连接数据库时提供了不正确的用户名或口令。
   
  Not_logged_on(ora-01012)
     在程序没有连接到oracle数据库时执行plsql代码则会触发。
   
  Program_error(ora-06501)
     plsql内部问题。
   
  Rowtype_mismatch(ora-06504)
     执行赋值操作时，如果宿主游标变量和PLSQL游标变量返回类型不兼容时。
   
  Self_is_null(ora-30625)
     使用对象类型时，如果在null实例上调用成员方法。
   
  Storage_error(ora-06500)
     超出内存空间或者内存被损坏。
   
  Sys_invalid_rowid（ora-01410）
     无效字符串企图转换为rowid类型时。
   
  Timeout_on_resource(ora-00051)
     等待资源时出现超时错误。
   


2、处理非预定义异常
使用非预定义异常包括三步：
一：在定义部分定义异常名，
二：在异常和Oracle错误之间建立关联，
三：在异常处理部分捕捉并处理异常。


当定义Oracle错误和异常之间的关联关系时，需要使用伪过程EXCEPTION_INIT。


一：首先的定义部分定义异常；
二：使用progmaexception_init(exception_name,exception_number) 在异常和oracle错误之间建立关联，
    这时要求用户知道可能出现的错误号（异常函数sqlcode、sqlerrm和raise_application_error）；
三：最终在异常处理部分捕捉并处理异常。

 


下面以更新特定雇员的部门号，并处理ORA-02291错误为例，说明使用非预定义异常的方法。示例如下：


  DECLARE
    e_integrity EXCEPTION;  --1、定义部分
    PRAGMA EXCEPTION_INIT (e_integrity, -2291);  --2、建立关联关系
  BEGIN
    UPDATE  emp SET deptno=  &dno WHERE  empno = &eno;
  EXCEPTION
    WHEN  e_integrity THEN  --3、捕捉处理
      DBMS_OUTPUT.PUT_LINE(‘该部门不存在’);
  END;
  

   
--3、处理自定义异常
预定义异常和非预定义异常都与Oracle错误有关，并且当出现Oracle错误时会隐含触发相应异常；
而自定义异常与Oracle错误没有任何关联，它是由开发人员为特定情况所定义的异常。


当使用自定义异常时，
一：需要在定义部分（DECLARE）定义异常，
二：再执行部分（BEGIN）触发异常（使用RAISE语句），
三：在异常处理部分（EXCEPTION）捕捉并处理异常。


  declare
   myexception exception;
  begin
  
if
1=0
then
  
raise myexception;
  
endif; 
  exception
  
when

myexception 
then
       dbms_output.put_line('asdf');
  end;
   
注意：不能在同一个block中描述EXCEPTION两次，但是可以描述一个exception在两个不同的block中。异常（exception）是有作用域的，子块的异常不能被当前块所捕捉，

 

--４、使用异常函数：
Oracle内置函数sqlcode和sqlerrm主要用在others处理器中，分别用来返回oracle的错误代码和错误消息。
一般情况下sqlcode返回负数标识的oracle错误代码，除非错误
为‘ora-01403：no data found’，此时对应的sqlcode为+100，
对于用户自定义的异常，sqlcode返回+1，如果没有异常被触发，sqlcode返回0。
  Begin
  Exception
   When  others then
      Dbms_output.put_line(sqlcode||sqlerrm(sqlcode));
  End;
   

 


Oracle过程raise_application_error用于在plsql应用程序中自定义错误消息。
注意该过程只能在数据库端的子程序（过程、函数、包、触发器）中使用，而不能在匿名块和客户端的子程序中使用。
语法为raise_application_error(error_number,message[,[true|false]]);
其中

error_number用于定义错误号，该错误号必须在-20000到-20999之间的负整数；
message用于指定错误消息，并且该消息的长度不
能超过2048字节；
第三个参数如果为true，则该错误会被放在先前错误堆栈中，如果为false（默认值）则会替代先前所有错误。
  IF product_not_found THEN
               RAISE_APPLICATION_ERROR(-20123,'Invald product code'  TRUE);
  END IF;
   

 


--５、plsql编译警告：
plsql警告可以分为四类：
severe：用于
检查可能出现的不可预料或者错误结果，例如参数的别名问题；
performance：用于检查可能引起的性能问题，例如执行insert操作时为 number列提供了varchar2类型数据；
informational：用于检查子程序中的死代码；
all：用于检查所有警告。


为了数据库可以在编
译plsql子程序时发出警告信息，需要设置初始化参数plsql_warnings。这个参数不仅可以在系统级或者会话级设置，也可以在alter procedure命令中设置。
  Alter {system|session|procedure} 
  set plsql_warnings=
  
’{enable|disable:{all |performance|severe|informational}}’;
   


为了检查是否存在对应警告信息，必须先激活警告检查，然后重新编译子程序，
最后使用show errors命令显示警告错误。
  create or  replace procedure  my_test
  is
  begin
   if  1=0 then
      dbms_output.put_line('test');
   endif; 
  end;
  SQL>  alter procedure  my_test compile plsql_warnings = 'enable:all';
  

  Procedure altered
   SQL>  show errors;
  Errors for  PROCEDURE SYS.MY_TEST:
   LINE/COL ERROR
  --------  -------------------------
  10/5      PLW-06002: 无法执行的代码
   


--6、定义Exception时要注意的一些事项
当异常发生时，在块的内部没有该异常处理器时，控制将转到或传播到上一层块的异常处理部分。
没有处理的异常将沿检测异常调用程序传播到外层，当异常被处理并解决或到达程序最外层传播停止。在声明部分抛出的异常将控制转到上一层的异常部分。


用户必须在独立的WHEN子串中为每个异常设计异常处理代码，WHEN OTHERS子串必须放置在最后面作为缺省处理器处理没有显式处理的异常。当异常发生时，控制转到异常部分，ORACLE查找当前异常相应的WHEN..THEN语句，捕捉异常，THEN之后的代码被执行，如果错误陷阱代码只是退出相应的嵌套块，那么程序将继续执行内部块END后面的语句。如果没有找到相应的异常陷阱，那么将执行WHEN OTHERS。在异常部分WHEN 子串没有数量限制。
  EXCEPTION
  
WHEN inventory_too_low THEN
  
      ......
  
WHEN discontinued_item THEN
  
      ......
  
WHEN zero_divide THEN
  
      ......
  
WHEN OTHERS THEN
  
      ...... 


oracle预定义的异常列表
2008-10-30 16:06
命名的系统异常         产生原因 
ACCESS_INTO_NULL         未定义对象 
CASE_NOT_FOUND         CASE 中若未包含相应的 WHEN ，并且没有设置 ELSE 时 
COLLECTION_IS_NULL         集合元素未初始化 
CURSER_ALREADY_OPEN         游标已经打开 
DUP_VAL_ON_INDEX         唯一索引对应的列上有重复的值 
INVALID_CURSOR         在不合法的游标上进行操作 
INVALID_NUMBER         内嵌的 SQL 语句不能将字符转换为数字 
NO_DATA_FOUND         使用 select into 未返回行，或应用索引表未初始化的元素时 
TOO_MANY_ROWS         执行 select into 时，结果集超过一行 
ZERO_DIVIDE         除数为 0 
SUBSCRIPT_BEYOND_COUNT         元素下标超过嵌套表或 VARRAY 的最大值 
SUBSCRIPT_OUTSIDE_LIMIT         使用嵌套表或 VARRAY 时，将下标指定为负数 
VALUE_ERROR         赋值时，变量长度不足以容纳实际数据 
LOGIN_DENIED         PL/SQL 应用程序连接到 oracle 数据库时，提供了不正确的用户名或密码 
NOT_LOGGED_ON         PL/SQL 应用程序在没有连接 oralce 数据库的情况下访问数据 
PROGRAM_ERROR         PL/SQL 内部问题，可能需要重装数据字典＆ pl./SQL 系统包 
ROWTYPE_MISMATCH         宿主游标变量与 PL/SQL 游标变量的返回类型不兼容 
SELF_IS_NULL         使用对象类型时，在 null 对象上调用对象方法 
STORAGE_ERROR         运行 PL/SQL 时，超出内存空间 
SYS_INVALID_ID         无效的 ROWID 字符串 
TIMEOUT_ON_RESOURCE         Oracle 在等待资源时超时

=============================================================

BEGIN
《PL/SQL块》;
Exception
when no_data_found then --没有找到数据
《响应命令》;
when too_many_rows then --返回多行，隐式光标每次只能检索一行数据
《响应命令》;
when invalid_number then --字符向数字转换失败
《响应命令》;
when zero_divide then --被零除
《响应命令》;
when dup_val_on_index then --向唯一索引中插入重复数据
《响应命令》;
when invalid_cursor then --非法游标操作
《响应命令》;
when value_error then --数字的,数据转换,截字符串或强制性的错误
《响应命令》;
when others then --发生其它任何错误
null; --选择一：什么也不做，就当错误没发生
raise form_trigger_failure; --选择二：挂起当前程序
END;


常用预定义例外
EXCEPTION
WHEN CURSOR_ALREADY_OPEN THEN -- ORA-06511 SQLCODE = -6511 游标已经打开
..WHEN DUP_VAL_ON_INDEX THEN -- ORA-00001 SQLCODE = -1 向唯一索引中插入重复数据
..WHEN INVALID_CURSOR THEN -- ORA-01001 SQLCODE = -1001 非法游标操作
..WHEN INVALID_NUMBER THEN -- ORA-01722 SQLCODE = -1722 字符向数字转换失败
..WHEN LOGIN_DENIED THEN -- ORA-01017 SQLCODE = -1017 

..WHEN NO_DATA_FOUND THEN -- ORA-01403 SQLCODE = +100 没有找到数据
..WHEN NOT_LOGGED_ON THEN -- ORA-01012 SQLCODE = -1012 
..WHEN PROGRAM_ERROR THEN -- ORA-06501 SQLCODE = -6501 程序错误
..WHEN STORAGE_ERROR THEN -- ORA-06500 SQLCODE = -6500
..WHEN TIMEOUT_ON_RESOURCE THEN -- ORA-00051 SQLCODE = -51

..WHEN TOO_MANY_ROWS THEN -- ORA-01422 SQLCODE = -1422 返回多行
..WHEN TRANSACTION_BACKED_OUT THEN -- ORA-00061 SQLCODE = -61

..WHEN VALUE_ERROR THEN -- ORA-06502 SQLCODE = -6502 数值转换错误
..WHEN ZERO_DIVIDE THEN -- ORA-01476 SQLCODE = -1476 被零除
..WHEN OTHERS THEN -- 其它任何错误的处理
..END; 

package com.dsh.javaexcel.util;

import java.io.File;
import java.io.IOException;

import jxl.Cell;
import jxl.Sheet;
import jxl.Workbook;
import jxl.read.biff.BiffException;
import jxl.write.Label;
import jxl.write.WritableSheet;
import jxl.write.WritableWorkbook;
import jxl.write.WriteException;
import jxl.write.biff.RowsExceededException;

public class ReadWriteExcelUtil {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String fileName = "d:" + File.separator + "test.xls";
		System.out.println(ReadWriteExcelUtil.readExcel(fileName));
		String fileName1 = "d:" + File.separator + "abc.xls";
		ReadWriteExcelUtil.writeExcel(fileName1);
	}

	/**
	 * 從excel文件中讀取所有的內容
	 * 
	 * @param file
	 *            excel文件
	 * @return excel文件的內容
	 */
	public static String readExcel(String fileName) {
		StringBuffer sb = new StringBuffer();
		Workbook wb = null;
		try {
			// 构造Workbook（工作薄）对象
			wb = Workbook.getWorkbook(new File(fileName));
		} catch (BiffException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}

		if (wb == null)
			return null;

		// 获得了Workbook对象之后，就可以通过它得到Sheet（工作表）对象了
		Sheet[] sheet = wb.getSheets();

		if (sheet != null && sheet.length > 0) {
			// 对每个工作表进行循环
			for (int i = 0; i < sheet.length; i++) {
				// 得到当前工作表的行数
				int rowNum = sheet[i].getRows();
				for (int j = 0; j < rowNum; j++) {
					// 得到当前行的所有单元格
					Cell[] cells = sheet[i].getRow(j);
					if (cells != null && cells.length > 0) {
						// 对每个单元格进行循环
						for (int k = 0; k < cells.length; k++) {
							// 读取当前单元格的值
							String cellValue = cells[k].getContents();
							sb.append(cellValue + "\t");
						}
					}
					sb.append("\r\n");
				}
				sb.append("\r\n");
			}
		}
		// 最后关闭资源，释放内存
		wb.close();
		return sb.toString();
	}

	/**
	 * 把內容寫入excel文件中
	 * 
	 * @param fileName
	 *            要寫入的文件的名稱
	 */
	public static void writeExcel(String fileName) {
		WritableWorkbook wwb = null;
		try {
			// 首先要使用Workbook类的工厂方法创建一个可写入的工作薄(Workbook)对象
			wwb = Workbook.createWorkbook(new File(fileName));
		} catch (IOException e) {
			e.printStackTrace();
		}
		if (wwb != null) {
			// 创建一个可写入的工作表
			// Workbook的createSheet方法有两个参数，第一个是工作表的名称，第二个是工作表在工作薄中的位置
			WritableSheet ws = wwb.createSheet("sheet1", 0);

			// 下面开始添加单元格
			for (int i = 0; i < 10; i++) {
				for (int j = 0; j < 5; j++) {
					// 这里需要注意的是，在Excel中，第一个参数表示列，第二个表示行
					Label labelC = new Label(j, i, "这是第" + (i + 1) + "行，第"
							+ (j + 1) + "列");
					try {
						// 将生成的单元格添加到工作表中
						ws.addCell(labelC);
					} catch (RowsExceededException e) {
						e.printStackTrace();
					} catch (WriteException e) {
						e.printStackTrace();
					}

				}
			}

			try {
				// 从内存中写入文件中
				wwb.write();
				// 关闭资源，释放内存
				wwb.close();
			} catch (IOException e) {
				e.printStackTrace();
			} catch (WriteException e) {
				e.printStackTrace();
			}
		}
	}

}

select Table1.Item1,Table2.Item2 from Table1,Table2

select 表名.字段名 from 表名,表名

select b.bm from kk.kkyh a,kk.kkbm b where a.dw = '北京市振隆科技发展公司'  and a.id=b.id

package com.brit.os.util;

import java.util.ArrayList;
import java.util.List;

/**
 * 通用分页工具类，该工具类分页指定泛型的List对集合
 * 
 * @author evan
 * @time 2010-01-12
 * @param <E>
 *            指定的泛型
 */
public class Page<E>
{
	/**
	 * 每页显示的记录数
	 */
	private int pageRecords = 20;

	/**
	 * 总记录数
	 */
	private int totalRecord;

	/**
	 * 分页切割的启始点
	 */
	private int startIndex;

	/**
	 * 分页切割的结束点
	 */
	private int endIndex;

	/**
	 * 总页数
	 */
	private int totalPage;

	/**
	 * 当前页数
	 */
	private int currentPage = 1;

	/**
	 * 总记录集合
	 */
	private List<E> totalList;

	public Page(List<E> totalList)
	{
		super();

		this.totalList = totalList;

		innit();
	}

	/**
	 * 初始化该分页对象
	 */
	private void innit()
	{
		if (null != totalList)
		{
			totalRecord = totalList.size();

			if (totalRecord % this.pageRecords == 0)
			{
				this.totalPage = totalRecord / this.pageRecords;
			}
			else
			{
				this.totalPage = totalRecord / this.pageRecords + 1;
			}
		}
	}

	/**
	 * 得到分页后的数据
	 * 
	 * @return 分页数据
	 */
	public List<E> getPage(int currentPage)
	{
		this.currentPage = currentPage;

		if (currentPage <= 0)
		{
			this.currentPage = 1;
		}
		if (currentPage >= this.totalPage)
		{
			this.currentPage = this.totalPage;
		}

		List<E> subList = new ArrayList<E>();

		if (null != this.totalList)
		{
			subList.addAll(this.totalList.subList(getStartIndex(), getEndIndex()));
		}

		return subList;
	}

	/**
	 * 设置每页显示的记录条数,如果不设置则默认为每页显示30条记录
	 * 
	 * @param pageRecords
	 *            每页显示的记录条数(值必需介于10~100之间)
	 */
	public void setPageRecords(int pageRecords)
	{
		if (pageRecords >= 10 && pageRecords <= 100)
		{
			this.pageRecords = pageRecords;

			innit();
		}
	}

	public int getStartIndex()
	{
		if (null == this.totalList)
		{
			return 0;
		}

		this.startIndex = (getCurrentPage() - 1) * this.pageRecords;

		if (startIndex > totalRecord)
		{
			startIndex = totalRecord;
		}

		if (startIndex < 0)
		{
			startIndex = 0;
		}

		return startIndex;
	}

	public int getEndIndex()
	{
		if (null == this.totalList)
		{
			return 0;
		}

		endIndex = getStartIndex() + this.pageRecords;

		if (endIndex < 0)
		{
			endIndex = 0;
		}

		if (endIndex < getStartIndex())
		{
			endIndex = getStartIndex();
		}

		if (endIndex > this.totalRecord)
		{
			endIndex = this.totalRecord;
		}

		return endIndex;
	}
	
	/***
	 * 获取总页数
	 * @return
	 */
	public int getTotalPage()
	{
		return totalPage;
	}
	
	/**
	 * 获取List集合中的总条数
	 * @return
	 */
	public int getTotalRecord()
	{
		return totalRecord;
	}

	public boolean isEndPage()
	{
		return this.currentPage == this.totalPage;
	}

	/**
	 * 获取下一页的页数
	 * 
	 * @return 下一页的页数
	 */
	public int getNextPage()
	{
		int nextPage = this.currentPage + 1;

		if (nextPage > this.totalPage)
		{
			nextPage = this.totalPage;
		}
		if (nextPage <= 0)
		{
			nextPage = 1;
		}

		return nextPage;
	}

	/**
	 * 获取上一页的页数
	 * 
	 * @return 上一页的页数
	 */
	public int getPrivyPage()
	{
		int privyPage = this.currentPage - 1;

		if (privyPage > this.totalPage)
		{
			privyPage = this.totalPage;
		}

		if (privyPage <= 0)
		{
			privyPage = 1;
		}

		return privyPage;
	}
	
	/**
	 * 获取当前页页数
	 * @return
	 */
	public int getCurrentPage()
	{
		return currentPage;
	}
}

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

class ConvertVideo {

	private List<String> pathRight = new ArrayList<String>();// 经处理后，得到的有效地址
	private List<String> path1 = new ArrayList<String>();// ffmpeg能处理的文件的地址集
	private List<String> path2 = new ArrayList<String>();// ffmpeg不能处理的文件的地址集
	public static int fileNum = 0;// 所有经过验证合法，并需要转换的视频数量

	public static void main(String[] args) {
		Date start = new Date();
		ConvertVideo conver = new ConvertVideo();
		String fileFolder = "e:\\input";
		List<String> listFile = conver.getFilesInPath(fileFolder);
		List<String> listVideo = conver.filter(listFile);
		int fileNumMax = listVideo.size(); // 所有视频数量
		conver.checkfile(listVideo);
		conver.process();

		if (fileNum == fileNumMax) {
			Date end = new Date();
			System.out.println("耗时：" + (end.getTime() - start.getTime()) / 1000
					+ "秒");
		}
	}

	/**
	 * 过滤avi|wmv|rmvb|rm|asx|asf|mpg|3gp|mp4|mov|flv)$格式的视频
	 */
	private List<String> filter(List<String> list) {
		List<String> fileList = new ArrayList<String>();
		for (String str : list) {
			if (str.matches(".+\\.(avi|wmv|rmvb|rm|asx|mkv|asf|mpg|swf|3gp|mp4|mov|vob|flv)$")) {
				fileList.add(str);
			}
		}
		return fileList;
	}

	/**
	 * 
	 * 获取e:\\input下所有文件路径
	 */
	public List<String> getFilesInPath(String path) {
		List<String> fileList = new ArrayList<String>();

		if (path == null || "".equals(path))
			return fileList;

		File file = new File(path);

		if (!file.exists()) {
			return fileList;
		}

		File[] childFiles = file.listFiles();

		try {
			for (int i = 0; i < childFiles.length; i++) {
				String filePath = childFiles[i].getAbsolutePath();
				if (childFiles[i].isDirectory()) {
					fileList.addAll(getFilesInPath(filePath));
				} else {
					fileList.add(filePath);
				}
			}
		} catch (Exception e) {
			return fileList;
		}

		return fileList;
	}

	/**
	 * 
	 * 避免文件重名，在文件尾部加唯一标识，主要是以获取当前时间，以字符串格式hhmmssSSSSSS
	 */
	public String transform(Date date) {
		SimpleDateFormat sdFormat = new SimpleDateFormat("hhmmssSSSSSS");
		String myTime = sdFormat.format(date);
		return myTime;
	}

	/**
	 * 核心处理函数
	 */
	public void process() {
		checkContentType(pathRight);
		pathRight.clear();
		if (path1.size() > 0) { // 地址集中的文件全部是ffmpeg所能解析的文件
			processFLV(path1); // 直接将文件转为flv文件
		}
		if (path2.size() > 0) {
			processAVI(path2); // 得到ffmpeg不能解析的文件所转换成avi文件的地址集
		}
	}

	/**
	 * 将传过来的地址集分类，ffmpeg能解析的分到path1中，ffmpeg不能解析的分到path2中
	 */
	public void checkContentType(List<String> list) {
		for (String str : list) {
			if (str.matches(".+\\.(avi|wmv|mkv|asx|swf|asf|vob|mpg|mp4|mov|flv)$")) {
				path1.add(str);
			} else {
				path2.add(str);
			}
		}
	}

	/**
	 * . 处理用户传递过来的地址集 有效的放到pathRight中 无效的放到pathWrong中
	 */
	public void checkfile(List<String> path) {
		for (int i = 0; i < path.size(); i++) {
			File file = new File((String) path.get(i));
			if (file.isFile()) {
				pathRight.add(path.get(i));
			}
		}
	}

	/**
	 * 对ffmpeg无法解析的文件格式(wmv9，rm，rmvb等), 可以先用别的工具（mencoder）转换为avi(ffmpeg能解析的)格式.
	 */
	public void processAVI(List<String> list) {
		List<String> finish = new ArrayList<String>();
		for (String str : list) {
			List<String> commend = new java.util.ArrayList<String>();
			commend.add("\"e:\\mencoder\"");
			commend.add("\"" + str + "\"");
			commend.add("-oac");
			commend.add("mp3lame");
			commend.add("-lameopts");
			commend.add("preset=64");
			commend.add("-ovc");
			commend.add("xvid");
			commend.add("-xvidencopts");
			commend.add("bitrate=600");
			commend.add("-of");
			commend.add("avi");
			commend.add("-o");
			String file = str.substring(str.lastIndexOf("\\") + 1,
					str.lastIndexOf("."));
			file = (file + transform(new Date())).trim();
			commend.add("\"e:\\System\\" + file + ".avi\""); // 最后输出出来的avi，尽量不要出现二义性，否则会覆盖掉原有的视频
			try {
				ProcessBuilder builder = new ProcessBuilder();
				builder.command(commend);
				Process p = builder.start();
				int exitValue = doWaitFor(p);
				if (exitValue != -1) {
					processFLV1("e:\\System\\" + file + ".avi");
				}
			} catch (Exception e) {
				// e.printStackTrace();
				System.out.println("********avi转换出错********");
			}
			finish.add(str);
		}
		path2.removeAll(finish);
	}

	/**
	 * ffmpeg能解析的格式：（asx，asf，mpg，wmv，3gp，mp4，mov，avi，flv等）
	 */
	public boolean processFLV1(String str) {

		List<String> commend = new java.util.ArrayList<String>();
		commend.add("\"e:\\ffmpeg\"");
		commend.add("-i");
		commend.add("\"" + str + "\"");
		commend.add("-ab");
		commend.add("64");
		commend.add("-ac");
		commend.add("2");
		commend.add("-ar");
		commend.add("22050");
		commend.add("-b");
		commend.add("230");
		commend.add("-r");
		commend.add("29.97");
		commend.add("-y");
		String file = str.substring(str.lastIndexOf("\\") + 1,
				str.lastIndexOf("."));
		String fileName = "e:\\output\\" + file + ".flv";
		commend.add("\"" + fileName + "\"");
		try {
			ProcessBuilder builder = new ProcessBuilder();
			builder.command(commend);
			Process p = builder.start();
			int exitValue = doWaitFor(p);
			if (exitValue != -1) {
				fileNum++;
			}
			processImg(fileName);
		} catch (Exception e) {
			System.out.println("*********转换为FLV格式出错*********");
			// e.printStackTrace();
			return false;
		}
		deleteFile(str);
		return true;
	}

	public void processFLV(List<String> list) {
		List<String> finish = new ArrayList<String>();
		for (String str : list) {
			List<String> commend = new java.util.ArrayList<String>();
			commend.add("\"e:\\ffmpeg\"");
			commend.add("-i");
			commend.add("\"" + str + "\"");
			commend.add("-ab");
			commend.add("64");
			commend.add("-ac");
			commend.add("2");
			commend.add("-ar");
			commend.add("22050");
			commend.add("-b");
			commend.add("230");
			commend.add("-r");
			commend.add("29.97");
			commend.add("-y");
			String file = str.substring(str.lastIndexOf("\\") + 1,
					str.lastIndexOf("."));
			String fileName = "e:\\output\\" + file + transform(new Date())
					+ ".flv";
			commend.add("\"" + fileName + "\"");
			try {
				ProcessBuilder builder = new ProcessBuilder();
				builder.command(commend);
				Process p = builder.start();
				int exitValue = doWaitFor(p);
				if (exitValue != -1) {
					fileNum++;
					processImg(fileName);
				}
			} catch (Exception e) {
				// System.out.println("*********转换为FLV格式出错*********");
				e.printStackTrace();
			}
			finish.add(str);
		}
		path1.removeAll(finish);
	}

	/**
	 * 生成图片 参数String newfilename, String newimg
	 */
	public boolean processImg(String str) {
		List<String> commend = new java.util.ArrayList<String>();
		commend.add("\"e:\\ffmpeg\"");
		commend.add("-i");
		commend.add("\"" + str + "\"");
		commend.add("-y");
		commend.add("-f");
		commend.add("image2");
		commend.add("-ss");
		commend.add("5");
		commend.add("-t");
		commend.add("0.001");
		commend.add("-s");
		commend.add("320x240");
		commend.add("\"e:\\img\\"
				+ str.substring(10, str.lastIndexOf(".")) + ".jpg\"");
		try {
			ProcessBuilder builder = new ProcessBuilder();
			builder.command(commend);
			builder.start();
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

	public void deleteFile(String str) {
		File file = new File(str);
		file.delete();
	}

	/**
	 * ffmpeg不能转换的格式要先转换成avi的格式，才转化为flv格式，doWaitFor方法保证，原视频完全转化为avi后，
	 * 才转化成flv，避免avi,flv同时转换出错
	 */
	public int doWaitFor(Process p)

	{
		InputStream in = null;
		InputStream err = null;
		int exitValue = -1; // returned to caller when p is finished
		try {
			System.out.println("comeing");
			in = p.getInputStream();
			err = p.getErrorStream();
			boolean finished = false; // Set to true when p is finished

			while (!finished) {
				try {
					while (in.available() > 0) {
						// Print the output of our system call
						Character c = new Character((char) in.read());
						System.out.print(c);
					}
					while (err.available() > 0) {
						// Print the output of our system call
						Character c = new Character((char) err.read());
						System.out.print(c);
					}

					// Ask the process for its exitValue. If the process
					// is not finished, an IllegalThreadStateException
					// is thrown. If it is finished, we fall through and
					// the variable finished is set to true.
					exitValue = p.exitValue();
					finished = true;

				} catch (IllegalThreadStateException e) {
					// Process is not finished yet;
					// Sleep a little to save on CPU cycles
					Thread.currentThread().sleep(500);
				}
			}
		} catch (Exception e) {
			// unexpected exception! print it out for debugging...
			System.err.println("doWaitFor();: unexpected exception - "
					+ e.getMessage());
		} finally {
			try {
				if (in != null) {
					in.close();
				}

			} catch (IOException e) {
				System.out.println(e.getMessage());
			}
			if (err != null) {
				try {
					err.close();
				} catch (IOException e) {
					System.out.println(e.getMessage());
				}
			}
		}
		// return completion status to caller
		return exitValue;
	}

}