public static void main(String[] args) throws IOException
{
    BufferedWriter writer=new BufferedWriter(new FileWriter("xiaoming.txt"));
    writer.write("小明");
}

public static void main(String[] args) throws IOException
{
       //自动刷新到文件xiaoming.txt中
    PrintWriter writer=new PrintWriter(new FileWriter("xiaoming.txt"),true);
       //使用下面三个方法会自动刷新
    writer.println("小明");
    writer.printf("%-10s#\n","小明");
    writer.format("%-10d#", 12345);
}

public static void main(String[] args) throws IOException
{
    PrintWriter writer=new PrintWriter(new FileWriter("xiaoming.txt"),true);
    writer.println("小明");
    writer.printf("%-10s#\n","小明");
    writer.format("%-10d#\n", 12345);
    writer.write("我是不会写到文件中去的");
    writer.print("我也不会自动写到文件中去的");
    writer.append("我也一样不会写到文件中去的");
}

public static void main(String[] args) throws IOException
{
    PrintWriter writer=new PrintWriter(new FileWriter("xiaoming.txt"),true);
    writer.println("小明");
    writer.printf("%-10s#\n","小明");
    writer.format("%-10d#\n", 12345);
    writer.write("我是不会写到文件中去的\n");
    writer.print("我也不会自动写到文件中去的\n");
    writer.append("我也一样不会写到文件中去的\n");
    writer.close();
}

protected Writer out;//字符输出流
private final boolean autoFlush;//自动刷新
private boolean trouble = false;
private Formatter formatter;
private PrintStream psOut = null;
private final String lineSeparator;//换行符

public PrintWriter (Writer out) {
    //调用另一个:PrintWriter(Writer out, boolean autoFlush)
    this(out, false);
}
public PrintWriter(Writer out, boolean autoFlush) {
    super(out);
    //设置字符输出流
    this.out = out;
    //设置自动刷新标志
    this.autoFlush = autoFlush;
    //设置换行符
    lineSeparator = java.security.AccessController.doPrivileged(
        new sun.security.action.GetPropertyAction("line.separator"));
}
public PrintWriter(OutputStream out) {
    //调用另一个构造方法:PrintWriter(OutputStream out, boolean autoFlush) 
    this(out, false);
}
public PrintWriter(OutputStream out, boolean autoFlush) {
    //把字节流封装成字符流：BufferedWriter后,
    //调用:PrintWriter(OutputStream out, boolean autoFlush)
    this(new BufferedWriter(new OutputStreamWriter(out)), autoFlush);

    // save print stream for error propagation
    if (out instanceof java.io.PrintStream) {
        psOut = (PrintStream) out;
    }
}
public PrintWriter(String fileName) throws FileNotFoundException {
    //包装后调用：PrintWriter(OutputStream out, boolean autoFlush)
    this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName))),
            false);
}
//搞不懂为什么这里要颠倒一下参数的顺序?
private PrintWriter(Charset charset, File file)
    throws FileNotFoundException
{
    //包装后调用:PrintWriter(OutputStream out, boolean autoFlush)
    this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), charset)),
            false);
}
public PrintWriter(String fileName, String csn)
    throws FileNotFoundException, UnsupportedEncodingException
{
    //调用:PrintWriter(Charset charset, File file)
    this(toCharset(csn), new File(fileName));
}
public PrintWriter(File file) throws FileNotFoundException {
    //调用：PrintWriter(OutputStream out, boolean autoFlush)
    this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file))),
            false);
}
public PrintWriter(File file, String csn)
    throws FileNotFoundException, UnsupportedEncodingException
{
    //调用：PrintWriter(Charset charset, File file)
    this(toCharset(csn), file);
}

public void print(boolean b) {
    write(b ? "true" : "false");
}
public void print(char c) {
    write(c);
}
public void print(int i) {
    write(String.valueOf(i));
}
public void print(long l) {
    write(String.valueOf(l));
}
public void print(float f) {
    write(String.valueOf(f));
}
public void print(double d) {
    write(String.valueOf(d));
}
public void print(char s[]) {
    write(s);
}
public void print(String s) {
    if (s == null) {
        s = "null";
    }
    write(s);
}
public void print(Object obj) {
    write(String.valueOf(obj));
}

protected Writer out;
public void write(int c) {
    try {
        synchronized (lock) {
            ensureOpen();
            //调用低层Writer的write(int)方法
            out.write(c);
        }
    }
    catch (InterruptedIOException x) {
        Thread.currentThread().interrupt();
    }
    catch (IOException x) {
        trouble = true;
    }
}
public void write(char buf[], int off, int len) {
    try {
        synchronized (lock) {
            ensureOpen();
            //调用低层writer的写字符数组方法
            out.write(buf, off, len);
        }
    }
    catch (InterruptedIOException x) {
        Thread.currentThread().interrupt();
    }
    catch (IOException x) {
        trouble = true;
    }
}
public void write(char buf[]) {
    //调用自己的write(char buf[], int off, int len)
    write(buf, 0, buf.length);
}
public void write(String s, int off, int len) {
    try {
        synchronized (lock) {
            ensureOpen();
            //调用低层得写字符串方法
            out.write(s, off, len);
        }
    }
    catch (InterruptedIOException x) {
        Thread.currentThread().interrupt();
    }
    catch (IOException x) {
        trouble = true;
    }
}
public void write(String s) {
    //调用自己的写字符串方法
    write(s, 0, s.length());
}

public PrintWriter append(CharSequence csq) {
    if (csq == null)
        write("null");
    else
        write(csq.toString());
    return this;
}
public PrintWriter append(CharSequence csq, int start, int end) {
    CharSequence cs = (csq == null ? "null" : csq);
    write(cs.subSequence(start, end).toString());
    return this;
}
public PrintWriter append(char c) {
    write(c);
    return this;
}

private void newLine() {
    try {
        synchronized (lock) {
            ensureOpen();
            out.write(lineSeparator);
            if (autoFlush)
                out.flush();
        }
    }
    catch (InterruptedIOException x) {
        Thread.currentThread().interrupt();
    }
    catch (IOException x) {
        trouble = true;
    }
}
public void println() {
    newLine();
}
public void println(boolean x) {
    synchronized (lock) {
        print(x);
        println();
    }
}
public void println(char x) {
    synchronized (lock) {
        print(x);
        println();
    }
}
public void println(int x) {
    synchronized (lock) {
        print(x);
        println();
    }
}
public void println(long x) {
    synchronized (lock) {
        print(x);
        println();
    }
}
public void println(float x) {
    synchronized (lock) {
        print(x);
        println();
    }
}
public void println(double x) {
    synchronized (lock) {
        print(x);
        println();
    }
}
public void println(char x[]) {
    synchronized (lock) {
        print(x);
        println();
    }
}
public void println(String x) {
    synchronized (lock) {
        print(x);
        println();
    }
}
public void println(Object x) {
    String s = String.valueOf(x);
    synchronized (lock) {
        print(s);
        println();
    }
}

private void newLine() {
    try {
        synchronized (lock) {
            ensureOpen();
            //写换行符
            out.write(lineSeparator);
            if (autoFlush)
                out.flush();//刷新缓存
        }
    }
    catch (InterruptedIOException x) {
        Thread.currentThread().interrupt();
    }
    catch (IOException x) {
        trouble = true;
    }
}

//格式化类：java.util.Formatter
private Formatter formatter;
......
public PrintWriter format(String format, Object ... args) {
    try {
        synchronized (lock) {
            ensureOpen();
            if ((formatter == null)
                || (formatter.locale() != Locale.getDefault()))
                formatter = new Formatter(this);
            formatter.format(Locale.getDefault(), format, args);
            if (autoFlush)
                out.flush();
        }
    } catch (InterruptedIOException x) {
        Thread.currentThread().interrupt();
    } catch (IOException x) {
        trouble = true;
    }
    return this;
}
public PrintWriter format(Locale l, String format, Object ... args) {
    try {
        synchronized (lock) {
            ensureOpen();
            if ((formatter == null) || (formatter.locale() != l))
                formatter = new Formatter(this, l);
            formatter.format(l, format, args);
            if (autoFlush)
                out.flush();
        }
    } catch (InterruptedIOException x) {
        Thread.currentThread().interrupt();
    } catch (IOException x) {
        trouble = true;
    }
    return this;
}

public PrintWriter printf(String format, Object ... args) {
    return format(format, args);
}
public PrintWriter printf(Locale l, String format, Object ... args) {
    return format(l, format, args);
}

......
            if (autoFlush)
                out.flush();//刷新缓存
......

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");
    }
}