// 缓存数组
byte[] buffer = new byte[2048];
// 每次读入的字节数量
int inSize = -1;
// 批量读入字节到buffer缓存中,并返回读入的自己数量给inSize
// 这里的in为输入流对象
while ((inSize = in.read(buffer)) != -1)
{
    // 把buffer缓存中的字节写入输出流(也就是目标文件)
      // 这里的out为输出流对象  
    out.write(buffer, 0, inSize);
}

/**
 * 合并文件ArrayList中的多个源文件为一个文件.
 * 
 * @param targetFilePath
 *            目标文件路径名称字符串.
 * @param sourceFilePathList
 *            存放源文件的路径名称字符串的ArrayList集合.
 */
public static void merge2TargetFileDeleteSourceFile(String targetFilePath,
        ArrayList<String> sourceFilePathList)
{
    // 如果ArrayList中有东西
    if (sourceFilePathList.size() > 0)
    {
        BufferedInputStream in;
        try (BufferedOutputStream out = new BufferedOutputStream(
                new FileOutputStream(new File(targetFilePath)));)
        {
            System.out.println("源文件列表:");
            for (Iterator<String> iterator = sourceFilePathList
                    .iterator(); iterator.hasNext();)
            {
                String sourceFilePath = iterator.next();
                System.out.println("    " + sourceFilePath);
                File sourceFile = new File(sourceFilePath);
                in = new BufferedInputStream(
                        new FileInputStream(sourceFile));
                // 缓存数组
                byte[] buffer = new byte[2048];
                // 每次读入的字节数量
                int inSize = -1;
                // 批量读入字节到buffer缓存中,并返回读入的自己数量给inSize
                while ((inSize = in.read(buffer)) != -1)
                {
                    // 把buffer缓存中的字节写入输出流(也就是目标文件)
                    out.write(buffer, 0, inSize);
                }
                // 关闭源文件
                in.close();
                // 删除这个源文件
                sourceFile.delete();
            }
        } catch (FileNotFoundException e)
        {
            e.printStackTrace();
        } catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

package tools;
public class Tools {
    String name;
    String sex;
    /**
     * @param name
     * @param sex
     */
    public Tools(String name, String sex)
    {
        super();
        this.name = name;
        this.sex = sex;
    }
    public static void publicStaticMethod()
    {
        System.out.println("公有 无参 静态 方法 被调用...");
    }
    public static void publicStaticMethod(String arg1, String arg2)
    {
        System.out.println("公有 带参 静态 方法 被调用...");
        System.out.println("    参数1:" + arg1 + ",参数2:" + arg2);
    }
    public void puablicInstanceMethod()
    {
        System.out.println("公有 无参 实例 方法 被调用...");
        System.out.println("Tools [name=" + name + ", sex=" + sex + "]");
    }
    public void puablicInstanceMethod(String arg1, String arg2)
    {
        System.out.println("公有 带参 实例 方法 被调用...");
        System.out.println("    参数1:" + arg1 + ",参数2:" + arg2);
    }
}

package test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class Test {
    public static void main(String[] args) throws Exception
    {
//         callPublicStaticMethod();
//         callPublicStaticMethod("Hello", "World");
//         callPublicInstanceMethod();
        callPublicInstanceMethod("Hello", "World");
    }
    private static void callPublicStaticMethod() throws Exception
    {
        Class<?> classIns = Class.forName("tools.Tools");
        // 获取不带参数的方法,
        // getMethod第一个参数是方法名称,后面是方法的形参列表
        Method method = classIns.getMethod("publicStaticMethod");
        // invoke方法的第一个参数是该方法的调用者,
        // 如果是静态方法,则设置调用者为类,
        // 如果是实例方法,则调用者为实例
        // invoke后面的参数是方法的实参列表,不需要参数可以省略.
        // 调用类classIns的无参静态方法
        method.invoke(classIns);
    }
    private static void callPublicStaticMethod(String arg1, String age2) throws Exception
    {
        Class<?> classIns = Class.forName("tools.Tools");
        // 获取不带参数的方法,
        // getMethod第一个参数是方法名称,后面是方法的形参列表
        Method method = classIns.getMethod("publicStaticMethod", String.class, String.class);
        // invoke方法的第一个参数是该方法的调用者,如果是静态方法,则设置调用者为类,如果是实例方法,则调用者为实例
        // invoke后面的参数是方法的实参列表,不需要参数可以不写
        // 调用类classIns的带参静态方法
        method.invoke(classIns, arg1, age2);
    }
    private static void callPublicInstanceMethod() throws Exception
    {
        // 获取类
        Class<?> class1 = Class.forName("tools.Tools");
        // 根据参数列表获取构造器
        Constructor<?> constructor = class1.getConstructor(String.class, String.class);
        // 创建对象
        Object object = constructor.newInstance("小明", "男");
        // 获取不带参数的方法,
        // getMethod第一个参数是方法名称,后面的参数是方法的形参列表,没有参数可以不写
        Method method = class1.getMethod("puablicInstanceMethod");
        // 调用实例object的puablicInstanceMethod方法.
        method.invoke(object);
    }
    private static void callPublicInstanceMethod(String arg1, String arg2) throws Exception
    {
        // 获取类
        Class<?> class1 = Class.forName("tools.Tools");
        // 根据参数列表获取构造器
        Constructor<?> constructor = class1.getConstructor(String.class, String.class);
        // 创建对象
        Object object = constructor.newInstance("小明", "男");
        // 获取不带参数的方法,
        // getMethod第一个参数是方法名称,后面的参数是方法的形参列表,没有参数可以不写
        Method method = class1.getMethod("puablicInstanceMethod", String.class, String.class);
        // invoke方法的第一个参数是该方法的调用者,
        // 如果是静态方法,则设置调用者为类,
        // 如果是实例方法,则调用者为实例
        // invoke后面的参数是方法的实参列表,
        // 调用实例object的puablicInstanceMethod方法.
        method.invoke(object, arg1, arg2);
    }
}

private static void callPublicStaticMethod() throws Exception
{
    Class<?> classIns = Class.forName("tools.Tools");
    // 获取不带参数的方法,
    // getMethod第一个参数是方法名称,后面是方法的形参列表
    Method method = classIns.getMethod("publicStaticMethod");
    // invoke方法的第一个参数是该方法的调用者,如果是静态方法,则设置调用者为类,如果是实例方法,则调用者为实例
    // invoke后面的参数是方法的实参列表,不需要参数可以不写
    // 调用类classIns的无参静态方法
    method.invoke(classIns);
}

private static void callPublicStaticMethod(String arg1, String age2) throws Exception
{
    Class<?> classIns = Class.forName("tools.Tools");
    // 获取不带参数的方法,
    // getMethod第一个参数是方法名称,后面是方法的形参列表
    Method method = classIns.getMethod("publicStaticMethod", String.class, String.class);
    // invoke方法的第一个参数是该方法的调用者,如果是静态方法,则设置调用者为类,如果是实例方法,则调用者为实例
    // invoke后面的参数是方法的实参列表,不需要参数可以不写
    // 调用类classIns的带参静态方法
    method.invoke(classIns, arg1, age2);
}

private static void callPublicInstanceMethod() throws Exception
{
    // 获取类
    Class<?> class1 = Class.forName("tools.Tools");
    // 根据参数列表获取构造器
    Constructor<?> constructor = class1.getConstructor(String.class, String.class);
    // 创建对象
    Object object = constructor.newInstance("小明", "男");
    // 获取不带参数的方法,
    // getMethod第一个参数是方法名称,后面的参数是方法的形参列表,没有参数可以不写
    Method method = class1.getMethod("puablicInstanceMethod");
    // 调用实例object的puablicInstanceMethod方法.
    method.invoke(object);
}

private static void callPublicInstanceMethod(String arg1, String arg2) throws Exception
{
    // 获取类
    Class<?> class1 = Class.forName("tools.Tools");
    // 根据参数列表获取构造器
    Constructor<?> constructor = class1.getConstructor(String.class, String.class);
    // 创建对象
    Object object = constructor.newInstance("小明", "男");
    // 获取不带参数的方法,
    // getMethod第一个参数是方法名称,后面的参数是方法的形参列表,没有参数可以不写
    Method method = class1.getMethod("puablicInstanceMethod", String.class, String.class);
    // invoke方法的第一个参数是要调用方法的拥有者,后面剩下的参数是该方法的实参列表
    method.invoke(object, arg1, arg2);
}

/**
 * 这个类专门用来读取资源文件
 */
public class ResourceFileReader
{
     public static void main(String[] args)
     {
     System.out.println(getResourceFileContent("/AudioPlay.html", "utf-8"));
     }
    /**
     * 
     * /** 读入资源目录下的path文件中的内容.会以UTF-8编码来读取,所以该文件必须要保存为UTF-8编码格式.
     * 
     * @param path
     *            资源文件的路径,必须以<code>/</code>开头.<br>
     *            例如项目资源目录res下的的<code>AudioPlay.html</code>的路径为:
     *            <code>"/AudioPlay.html"</code>
     * @return 资源目录下的path文件的内容
     */
    public static String getResourceFileContent(String path, String charset)
    {
        if (path.startsWith("/"))
        {
            String content = null;
            // TODO Auto-generated method stub
            InputStream inputStream = ResourceFileReader.class
                    .getResourceAsStream(path);
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(inputStream, charset));)
            {
                StringBuilder builder = new StringBuilder();
                char[] charArray = new char[200];
                int number = -1;
                while ((number = reader.read(charArray)) != -1)
                {
                    builder.append(charArray, 0, number);
                }
                content = builder.toString();
                // System.out.println(builder.toString());
            } catch (FileNotFoundException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return content;
        }
        return null;
    }
}

public static void main(String[] args)
{
    System.out.println(
        ResourceFileReader.getResourceFileContent("/res/MybatisMapperTemplete.xml", "utf-8"));
}