public static void test_conversion_s()
{
    Formatter formatter=new Formatter();
    String name = "World";
    formatter.format("Hello %s !", name);
    System.out.println(formatter.toString());
}
public static void test_conversion_S()
{
    Formatter formatter=new Formatter();
    String name = "World";
    formatter.format("Hello %S !", name);
    System.out.println(formatter.toString());
}
public static void test_conversion_b()
{
    Formatter formatter=new Formatter();
    String name = "World";
    formatter.format("Hello %b !", name);
    System.out.println(formatter.toString());
}
public static void test_conversion_B()
{
    Formatter formatter=new Formatter();
    String name = "World";
    formatter.format("Hello %B !", name);
    System.out.println(formatter.toString());
}
public static void test_conversion_h()
{
    Formatter formatter=new Formatter();
    String name = "World";
    formatter.format("Hello %h !", name);
    System.out.println(formatter.toString());
}
public static void test_conversion_H()
{
    Formatter formatter=new Formatter();
    String name = "World";
    formatter.format("Hello %H !", name);
    System.out.println(formatter.toString());
}

Hello World !
Hello WORLD !
Hello true !
Hello TRUE !
Hello 4fe2b72 !
Hello 4FE2B72 !

public static void test_conversion_c(Formatter formatter)
{
    char[] chs={'\u4E2D','\u6587'};
    for (char c : chs)
    {
        formatter.format("%c", c);
    }
    System.out.println(formatter);
}

String str = "中文";
try
{
    String encodeStr = URLEncoder.encode(str, "utf-16be");
    encodeStr = encodeStr.replaceAll("%(.{2})%(.{2})", "\\\\u$1$2");
    System.out.println(encodeStr);
} catch (UnsupportedEncodingException e)
{
    // TODO Auto-generated catch block
    e.printStackTrace();
}

public static void testConsoleReader()
{
    Console console = System.console();
    if (console != null)
    {
        System.out.print("输入以#结束");
        Pattern endRegex = Pattern.compile("([^#]*)#");
        Matcher isEnd;
        // 获取控制台的字符输入流,这样可以读取到我们在控制台上打的字
        Scanner scan = new Scanner(console.reader());
        String str;
        StringBuilder builder = new StringBuilder();
        while (scan.hasNext())
        {
            str = scan.next();
            isEnd = endRegex.matcher(str);
            // matches()会匹配整个字符串匹配后匹配的下表
            if (isEnd.matches())
            {
                // 使用group()进行捕获的前提一定要是在匹配的情况下
                // 可以在matches(),find(),lonkingAt()返回true的时候调用
                builder.append(isEnd.group(1));
                break;
            }
            builder.append(str);
            // System.out.println(str);
        }
        System.out.println("接收到控制台输入：");
        System.out.println(builder.toString());
    }
}

public static void testConsoleReader2() throws IOException
{
    Console console = System.console();
    if (console != null)
    {
        System.out.print("输入以#结束");
        Pattern endRegex = Pattern.compile("([^#]*)#");
        Matcher isEnd;
        // 获取控制台的字符输入流,这样可以读取到我们在控制台上打的字
//            Scanner scan = new Scanner(console.reader());
        
        BufferedReader reader=new BufferedReader(console.reader());
        String line;
        //设置默认大小为100,面输入字符过多使得StringBuilder频繁扩容,每次扩容的长度是当前长度(length*2+2)
        StringBuilder builder = new StringBuilder(100);
        while ((line=reader.readLine())!=null)
        {
            isEnd = endRegex.matcher(line);
            // matches()会匹配整个字符串匹配后匹配的下表
            if (isEnd.matches())
            {
                // 使用group()进行捕获的前提一定要是在匹配的情况下
                // 可以在matches(),find(),lonkingAt()返回true的时候调用
                builder.append(isEnd.group(1));
                break;
            }
            builder.append(line);
        }
        System.out.println("接收到控制台输入：");
        System.out.println(builder.toString());
        reader.close();
    }
}

public static void testConsoleWriter()
{
    Console console = null;
    PrintWriter out = null;
    try
    {
        console = System.console();
        if (console != null)
        {
            // 获取控制台的PrintWriter实例，也就是对控制台的输出
            out = console.writer();
            out.println("这句话将输出到控制台中");
        }
    } catch (Exception ex)
    {
        ex.printStackTrace();
    }
}

public static void testReaderWriter()
{
    Console console =null;
    console=System.console();
    if(console!=null)
    {
        PrintWriter consoleOut=console.writer();
        BufferedReader consoleIn=new BufferedReader(console.reader());
        String line=null;
        try
        {
            while((line=consoleIn.readLine())!=null)
            {
                if(line.equals("exit"))
                    break;
                consoleOut.println("你输入了："+line);
            }
        } catch (IOException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

public Console printf(String format, Object ... args) 
{
    return format(format, args);
}

private Formatter formatter;
......
public Console format(String fmt, Object ...args) 
{
    formatter.format(fmt, args).flush();
    return this;
}

package test.before;

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

public class TestFile
{
        public static void main(String[] args) throws IOException
        {
                File file=new File("."+File.separator+"gbk.txt");
//              File file=new File(".\\gbk.txt");
                System.out.println(file.getAbsolutePath());
                System.out.println(file.isFile());
        }
}

File file=new File("file2.txt");
if(!file.exists())
{
    file.createNewFile();
}

File file=new File("file2.txt");
if(!file.exists())
{
    file. mkdir();
}

public static void main(String[] args) 
{
 
        //构造函数File（String pathname）
        File f1 = new File("D:\\a\\1.txt");
        System.out.println(f1);
        //File(String parent,String child)
        File f2 = new File("D:\\a", "2.txt");
        System.out.println(f2);
        //File(File parent,String child)
        //File.separactor:表示路径分割符，在Windows系统中是"\",在Linux系统中是"/"
        File f3 = new File("D:"+File.separator+"a");
        System.out.println(f3);
        File f4 = new File(f3,"3.txt");
        System.out.println(f4);
}

public class FileDemo1
{
    public static void main(String[] args) throws IOException
    {
        File file = new File("D:\\a\\file.txt");
        File directory = new File("D:\\a");
        File dir = new File("D:\\a\\test1\\test2");
        if (!directory.exists()) {
            //创建目录
            System.out.println("创建目录-"+directory);
            System.out.println(directory.mkdir());
        }
        else {
            System.out.println("删除目录-"+dir);
            System.out.println(directory.delete());//删除目录
            //删除此抽象路径名表示的文件或目录。如果此路径名表示一个目录，则该目录必须为空才能删除。
        }
        if (!dir.exists()) {
            //创建多级目录
            System.out.println("创建多级目录-"+dir);
            System.out.println(dir.mkdirs());
        }
        else {
            System.out.println("删除多级目录-"+dir);
            System.out.println(dir.delete());//
        }
        if (!file.exists()) {
            //创建文件
            System.out.println("创建文件-"+file);
            System.out.println(file.createNewFile());
        }
        else {
            System.out.println("删除文件-"+file);
            System.out.println(file.delete());//删除文件
        }
    }
}

public class FileDemo2
{
    public static void main(String[] args)
    {
        File file=new File("D:\\a\\file.txt");
        File noAbsolute=new File("我当然不是绝对路径啦");
        File dir=new File("D:\\a");
        System.out.println("file对象是否是文件："+file.isFile());
        System.out.println("dir对象是否是目录："+dir.isDirectory());
        System.out.println("file对象的路径是否是绝对路径: "+file.isAbsolute());
        System.out.println("noAbsolute对象的路径是否是绝对路径: "+noAbsolute.isAbsolute());
        System.out.println("file.txt是否存在："+file.exists());
        System.out.println("file.txt是否可读："+file.canRead());
        System.out.println("file.txt是否可写："+file.canWrite());
        System.out.println("file.txt是否是隐藏文件："+file.isHidden());
    }
}

public class FileAPIDemo1
{
    public static void main(String[] args)
    {
        File file=new File("D:\\a\\file.txt");
        System.out.println("file.txt最后一次修改的时间："+timeStampToDate(file.lastModified()));
        System.out.println("file.txt长度(字节)："+file.length()+"B");
        System.out.println("file的文件名："+file.getName());
        System.out.println("file.txt的父路径字符串："+file.getParent());
        File fileParent=file.getParentFile();//获取父路径的File对象。
        System.out.println("父路径File对象fileParent的目录名："+fileParent.getName());
        System.out.println("file对象的抽象路径字符串："+file.getPath());
        System.out.println("file对象的绝对路径字符串："+file.getAbsolutePath());
        File AbsolutePathFile=file.getAbsoluteFile();//获取绝对路径的File对象
        System.out.println("AbsolutePathFile的名字："+file.getName());
        System.out.println("file和AbsolutePathFile引用的是相同的文件？："+file.equals(AbsolutePathFile));
    }
    //把时间戳转换成格式化时间字符串
    static String timeStampToDate(long timeStamp)
    {
        Date date =new Date(timeStamp);
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return format.format(date);
    }
}

public class FileDemo3
{
    public static void main(String[] args) throws IOException
    {
        // 打印当前工程的父路径
        // System.out.println(System.getProperty("user.dir"));
        File file = new File("D:\\a\\file.txt");
        System.out.println("相对路径    :" + file.getPath());
        System.out.println("绝对路径    :" + file.getAbsolutePath());
        System.out.println("规范化路径    :" + file.getCanonicalPath());
        System.out.println("-----------------------------");
        File file2 = new File(".\\file.txt");
        System.out.println("user.dir:" + System.getProperty("user.dir"));
        System.out.println("相对路径    :" + file2.getPath());
        System.out.println("绝对路径    :" + file2.getAbsolutePath());
        System.out.println("规范化路径    :" + file2.getCanonicalPath());
 
        // 当输入为绝对路径时，3个方法返回的都是绝对路径。
        // 当输入为相对路径时：
        // getPath()返回的是File构造方法里的路径
        // getAbsolutePath()返回的其实是user.dir+getPath()的内容
        // getCanonicalPath()返回的就是标准的将符号完全解析的路径
    }
}

public class FileAPIDemo2
{
    public static void main(String[] args)
    {
        //工程路径
        File dir=new File(System.getProperty("user.dir"));
        String[] list=dir.list();//返回当前目录下的所有文件和目录的名字
        for (String string : list)
        {
            System.out.println(string);
        }
        System.out.println("--------------------");
        File[] fileList=dir.listFiles();//获取当前下所有目录和文件的File对象
        for (File file : fileList)
        {
            System.out.println(file.getName());
        }
        
    }
}

public class FileAPIDemo4
{
    // 递归遍历所有的子目录和文件
    static void forEachAllDir(File dir)
    {
        if (dir == null)
        {
            System.out.println(dir + " 不是File对象");
            return;
        }
        if (!dir.isDirectory())
        {
            System.out.println(dir + " 不是目录");
        }
 
        File[] lists = dir.listFiles();// 获取当前目录下子文件和子目录的File对象
        for (File file : lists)
        {
            if (file.isDirectory())// 如果是目录的话
            {
                System.out.println(file);//输出目录的绝对路径
                // 递归调用
                forEachAllDir(file);//继续显示子目录
            } 
                        else//如果是文件的话，就直接输出文件的绝对路径
            {
                System.out.println(file);
            }
        }
    }
    public static void main(String[] args)
    {
        File dir = new File(System.getProperty("user.dir"));
        forEachAllDir(dir);
    }
}

D:\dev\workspace\TestLearned\.classpath
D:\dev\workspace\TestLearned\.project
D:\dev\workspace\TestLearned\.settings
D:\dev\workspace\TestLearned\.settings\org.eclipse.jdt.core.prefs
D:\dev\workspace\TestLearned\bin
D:\dev\workspace\TestLearned\bin\lan
D:\dev\workspace\TestLearned\bin\lan\csdn
D:\dev\workspace\TestLearned\bin\lan\csdn\c
D:\dev\workspace\TestLearned\bin\lan\csdn\c\java
D:\dev\workspace\TestLearned\bin\lan\csdn\c\java\Myint.class
......
D:\dev\workspace\TestLearned\src\string
D:\dev\workspace\TestLearned\src\string\Test_IndexOf.java
D:\dev\workspace\TestLearned\src\string\Test_LastIndexOf.java
D:\dev\workspace\TestLearned\src\string\Test_Substring.java

public static void printAllFile(File dir,final String ends)
{
    String[] listStr=dir.list(new FilenameFilter()
    {
        @Override
        // dir表示文件的当前目录，name表示当前文件的文件名；
        public boolean accept(File dir, String name)
        {
            //该目录是文件，而且文件以.java结尾
            return new File(dir, name).isFile() && name.endsWith(ends);
        }
    });
    for (String string : listStr)
    {
        System.out.println(string);
    }
}

//静态内部类可以直接new不用加上外部类的类名
//实现FilenameFilter
static class MyFilenameFilter implements FilenameFilter
{
    String ends;
    public MyFilenameFilter(){}
    public MyFilenameFilter(String ends)
    {
        this.ends=ends;
    }
    @Override
    public boolean accept(File dir, String name)
    {
        return new File(dir, name).isFile() && name.endsWith(ends);
    }
}
public static void printAllFile2(File dir, String ends)
{
    String[] listStr=dir.list(new MyFilenameFilter(ends));
    for (String string : listStr)
    {
        System.out.println(string);
    }
}

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import com.lan.filepath.FilePath;
 
public class FilenameFilterTest
{
    public static void printAllFile(File dir, final String ends)
    {
        String[] listStr = dir.list(new FilenameFilter()
        {
            @Override
            // dir表示文件的当前目录，name表示当前文件的文件名；
            public boolean accept(File dir, String name)
            {
                // 该目录是文件，而且文件以.java结尾
                return new File(dir, name).isFile() && name.endsWith(ends);
            }
        });
        for (String string : listStr)
        {
            System.out.println(string);
        }
    }
    // 静态内部类可以直接new不用加上外部类的类名
    // 实现FilenameFilter
    static class MyFilenameFilter implements FilenameFilter
    {
        String ends;
        public MyFilenameFilter()
        {
        }
        public MyFilenameFilter(String ends)
        {
            this.ends = ends;
        }
        @Override
        public boolean accept(File dir, String name)
        {
            return new File(dir, name).isFile() && name.endsWith(ends);
        }
    }
    public static void printAllFile2(File dir, String ends)
    {
        String[] listStr = dir.list(new MyFilenameFilter(ends));
        for (String string : listStr)
        {
            System.out.println(string);
        }
    }
 
    public static void main(String[] args) throws IOException
    {
        // 获得当前的包路径
        String packagePath = FilePath
                .getSrcPackagePath(FilenameFilterTest.class);
        File dir = new File(packagePath);
        System.out.println("当前目录下的所有java文件：");
        printAllFile(dir, ".java");
        System.out.println("-----------------------------------------------");
        System.out.println("当前目录下的所有txt文件：");
        printAllFile(dir, ".txt");
        System.out.println("-----------------------------------------------");
        System.out.println("当前目录下的所有txt文件：");
        printAllFile2(dir, ".txt");
    }
}

当前目录下的所有java文件：
FileAPIDemo1.java
FileAPIDemo2.java
FileAPIDemo4.java
FileDemo.java
FileDemo1.java
FileDemo2.java
FileDemo3.java
FilenameFilterTest.java
TestFile.java
TestGBK.java
-----------------------------------------------
当前目录下的所有txt文件：
Test.txt
-----------------------------------------------
当前目录下的所有txt文件：
Test.txt

/**
 * 复制一个文件
 * @param srcFile 源文件
 * @param destFile 目的文件
 * @throws IOException
 */
public static void copyFile(String srcFile, String destFile)
        throws IOException
{
    FileInputStream in = new FileInputStream(srcFile);
    FileOutputStream out = new FileOutputStream(destFile);
    // 2097152(Byte)=2048(KB)=2M
    byte[] buffer = new byte[2097152];
    int size = 0;
    //每次读取一个字节数组
    while ((size = in.read(buffer)) != -1)
    {
        //读到多少写入多少
        out.write(buffer, 0, size);
    }
    in.close();
    out.close();
}

/**
 * 使用递归复制目录,
 * @param FromDir 源目录的路径名称
 * @param ToDir 目的目录的路径名称
 * @throws IOException
 */
public static void copyDir(String FromDir, String ToDir) throws IOException
{
    // 创建目录的File对象
    File srcDir = new File(FromDir);
    // 判断源目录是不是一个目录
    if (!srcDir.isDirectory())
    {
        //如果不是目录那就不复制
        return;
    }
    //创建目的目录的File对象
    File destDir = new File(ToDir);
    // 如果目的目录不存在
    if (!destDir.exists())
    {
        // 创建目的目录
        destDir.mkdir();
    }
    
    // 获取源目录下的File对象列表,每一个对象代表一个目录或者文件
    File[] srcDirList = srcDir.listFiles();
    // 遍历源目录File对象列表
    for (int i = 0; i < srcDirList.length; i++)
    {
        // 如果是目录的话
        if (srcDirList[i].isDirectory())
        {
            // 递归调用复制该目录
            copyDir(FromDir + File.separator + srcDirList[i].getName(),
                    ToDir + File.separator + srcDirList[i].getName());
        }
        // 如果是文件的话
        if (srcDirList[i].isFile())
        {
            // 调用复制文件的方法
            copyFile(FromDir + File.separator + srcDirList[i].getName(),
                    ToDir + File.separator + srcDirList[i].getName());
        }

    }
}

public static void main(String[] args) throws IOException
{
    copyDir("FromDir", "ToDir");//复制当前工程下的FromDir目录中的内容到ToDir目录中。
}

package copy.file;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyDir
{
    public static void main(String[] args) throws IOException
    {
        copyDir("FromDir", "ToDir");
    }
    /**
     * 使用递归复制目录,
     * 
     * @param FromDir
     *            源目录的路径名称
     * @param ToDir
     *            目的目录的路径名称
     * @throws IOException
     */
    public static void copyDir(String FromDir, String ToDir) throws IOException
    {
        // 创建目录的File对象
        File srcDir = new File(FromDir);
        // 判断源目录是不是一个目录
        if (!srcDir.isDirectory())
        {
            // 如果不是目录那就不复制
            return;
        }
        // 创建目的目录的File对象
        File destDir = new File(ToDir);
        // 如果目的目录不存在
        if (!destDir.exists())
        {
            // 创建目的目录
            destDir.mkdir();
        }

        // 获取源目录下的File对象列表,每一个对象代表一个目录或者文件
        File[] srcDirList = srcDir.listFiles();
        // 遍历源目录File对象列表
        for (int i = 0; i < srcDirList.length; i++)
        {
            // 如果是目录的话
            if (srcDirList[i].isDirectory())
            {
                // 递归调用复制该目录
                copyDir(FromDir + File.separator + srcDirList[i].getName(),
                        ToDir + File.separator + srcDirList[i].getName());
            }
            // 如果是文件的话
            if (srcDirList[i].isFile())
            {
                // 调用复制文件的方法
                copyFile(FromDir + File.separator + srcDirList[i].getName(),
                        ToDir + File.separator + srcDirList[i].getName());
            }

        }
    }
    /**
     * 复制一个文件
     * 
     * @param srcFile
     *            源文件
     * @param destFile
     *            目的文件
     * @throws IOException
     */
    public static void copyFile(String srcFile, String destFile)
            throws IOException
    {
        FileInputStream in = new FileInputStream(srcFile);
        FileOutputStream out = new FileOutputStream(destFile);
        // 2097152(Byte)=2048(KB)=2M
        byte[] buffer = new byte[2097152];
        int size = 0;
        // 每次读取一个字节数组
        while ((size = in.read(buffer)) != -1)
        {
            // 读到多少写入多少
            out.write(buffer, 0, size);
        }
        in.close();
        out.close();
    }

}

public static void main(String[] args) throws IOException
{
    BufferedWriter writer=new BufferedWriter(new FileWriter("静夜思.txt"));
    char ch='床';
    //写入一个字符
    writer.write(ch);
    String next="前明月光,";
    char[] nexts=next.toCharArray();
    //写入一个字符数组
    writer.write(nexts,0,nexts.length);
    //写入换行符
    writer.newLine();//写入换行符
    String nextLine="疑是地上霜。";
    //写入一个字符串。
    writer.write(nextLine);
    //关闭流
    writer.close();
}

static void copyByChar(String srcFile, String destFile) throws IOException
{
    BufferedReader reader = new BufferedReader(new FileReader(srcFile));
    BufferedWriter writer = new BufferedWriter(new FileWriter(destFile));
    int ch=0;
    //读取一个字符
    while ((ch = reader.read()) != -1)
    {
        //写入一个字符
        writer.write(ch);
    }
    reader.close();
    writer.close();
}

static void copyByCharArray(String srcFile, String destFile) throws IOException
{
    BufferedReader reader = new BufferedReader(new FileReader(srcFile));
    BufferedWriter writer = new BufferedWriter(new FileWriter(destFile));
    int size=0;
    char[] cbuf=new char[20];
    //读取一个字符数组
    while ((size = reader.read(cbuf)) != -1)
    {
        //读入多少写入多少
        writer.write(cbuf,0,size);
    }
    reader.close();
    writer.close();
}

static void copyByLine(String srcFile,String destFile) throws IOException
{
    BufferedReader reader=new BufferedReader(new FileReader(srcFile));
    BufferedWriter writer=new BufferedWriter(new FileWriter(destFile));
    String line;
    //BufferedReader读取一行的时候返回的字符串中不包括换行符
    //如果有一行字符就返回该行字符串，没有就返回null
    while((line=reader.readLine())!=null)
    {
        writer.write(line);
        writer.newLine();//写换行符
    }
    reader.close();
    writer.close();
}

static void copyByLine(String srcFile,String destFile) throws IOException
{
    BufferedReader reader=new BufferedReader(new FileReader(srcFile));
    BufferedWriter writer=new BufferedWriter(new FileWriter(destFile));
    String line;
    //BufferedReader读取一行的时候返回的字符串中不包括换行符
    //如果有一行字符就返回该行字符串，没有就返回null
    boolean flag=false;
    while((line=reader.readLine())!=null)
    {
        if(!flag)
        {
            flag=true;
            writer.write(line);
        }
        else
        {
            writer.newLine();//写换行符
            writer.write(line);
        }
        
    }
    reader.close();
    writer.close();
}

static void copyByLineEncoding(String srcFile, String srcEncoding, String destFile,
        String destEncoding)
{
    BufferedReader reader = null;
    BufferedWriter writer = null;
    try
    {
        reader = new BufferedReader(new InputStreamReader(
                new FileInputStream(srcFile), srcEncoding));
        writer = new BufferedWriter(new OutputStreamWriter(
                new FileOutputStream(destFile), destEncoding));
        char[] charArray = new char[512];
        int size;
        while ((size = reader.read(charArray, 0, charArray.length)) != -1)
        {
            writer.write(charArray, 0, size);
        }

    } catch (UnsupportedEncodingException | FileNotFoundException e)
    {
        e.printStackTrace();
    } catch (IOException e)
    {
        e.printStackTrace();
    } finally
    {
        if (writer != null)
        {
            try
            {
                writer.close();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
        }
        if (reader != null)
        {
            try
            {
                reader.close();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }
}