1.0 File

a:构造方法

package d8;

import java.io.File;

public class FileGouZao {

    public static void main(String[] args) {

        //方式一:根据一个路径得到一个一个file对象

        //File(String pathName)

        File fe = new File("D:\\aaa\\a.txt");

        //方式二,通过父路径的名字 + 子文件/目录得到一个File对象

        //File(String parent,String child)

        File fe2 = new File("D:\\aaa","a.txt");

        //方式三,通过父File对象 + 子文件/目录得到一个File对象

        //File(File parent,String child)

        File fe3 = new File("D:\\aaa");

        File fe4 = new File(fe3,"D:\\aaa");

    }

}

1.0

b:创建方法

package d8;

import java.io.File;

import java.io.IOException;

public class FileGouAdd {

    public static void main(String[] args) throws IOException {

        //方式一:创建文件

        //boolean createNewFile()

        File fe = new File("D:\\aaa\\a.txt");

        fe.createNewFile();

        //方式二,创建文件夹

        //boolean mkdir()

        File fe2 = new File("D:\\aaa","aa");

        fe2.mkdir();

        //方式三, 创建文件夹们,如果父文件夹不存在就创建

        //boolean mkdirs()

        File fe3 = new File("D:\\aaa");

        File fe4 = new File(fe3,"aa\\a");

        fe4.mkdirs();

        //注意如果没有写盘符,默认为项目路径

        File fe5 = new File("a.txt");

        fe5.createNewFile();

        //如果用方式一创建时,如果父目录不存在,会出现"系统找不到指定的路径"的错误

        //如果用方式二创建时,如果父目录不存在,返回false

        //如果用方式三创建时,如果父目录不存在,就创建上级目录

    }

}

1.0

c:删除方法

package d8;

import java.io.File;

import java.io.IOException;

public class FileDelete {

    public static void main(String[] args) throws IOException {

        //方式一:创建文件

        //boolean createNewFile()

        File fe = new File("D:\\aaa\\a.txt");

        fe.createNewFile();

        fe.delete();

        File fe2 = new File("D:\\aaa");

        System.out.println(fe2.delete());

        //--------false---------//

        //注意:删除不走回收站

        //如果是删除目录,则该目录必须为空才能删除

    }

}

1.0

package d8;

import java.io.File;

import java.io.IOException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class Filedelete2 {

    public static void main(String[] args) throws IOException {

        //获取F盘所有的.exe文件

        File fe = new File("D:\\aaa");

        deleteAllFile(fe);

         /* */

    }

    public static void deleteAllFile(File fe) {

        if( fe.isFile()|| fe==null ) {

            System.out.println(fe.getPath());

            fe.delete();

        }else if(fe.isDirectory()&& fe.list().length<){

            System.out.println(fe.getPath());

            fe.delete();

        }else {

            File [] files = fe.listFiles();

            if (files!=null) {

                for (File file : files) {

                    deleteAllFile(file);

                }

                deleteAllFile(fe);

            }

        }

    }

}

/*D:\aaa\a.txt

D:\aaa\aa\a

D:\aaa\aa

D:\aaa\b.txt

D:\aaa\d.txt

D:\aaa*/

2.0级联删除

d:修改方法

package d8;

import java.io.File;

import java.io.IOException;

public class FileRenameTo {

    public static void main(String[] args) throws IOException {

        //方式一:路径相同重命名

        File fe = new File("D:\\aaa\\a.txt");

        fe.createNewFile();

        File f2 = new File("D:\\aaa\\b.txt");

        fe.renameTo(f2);

        //方式二:路径不同,相当于剪切功能

        File fe3 = new File("a.txt");//默认路径,也就是项目路径

        fe3.createNewFile();

        File f4 = new File("D:\\aaa\\d.txt");

        fe3.renameTo(f4);

        //方式一:路径相同重命名

        //方式二:路径不同,相当于剪切功能

    }

}

1.0

e:判断功能

package d8;

import java.io.File;

import java.io.IOException;

public class FileJudge {

    public static void main(String[] args) throws IOException {

        File fe = new File("D:\\aaa\\a.txt");

        boolean existsB = fe.exists();// 判断文件是否是存在

        boolean isFileB = fe.isFile();// 判断文件是否是一个标准文件

        boolean isDirectoryB = fe.isDirectory();// 判断文件是否是一个目录

        boolean isHiddenB = fe.isHidden();// 判断文件是否是隐藏

        boolean canReadB = fe.canRead();// 判断文件是否可读

        boolean canWriteB = fe.canWrite();// 判断文件是否是可写

        System.out.println(existsB);        //---true---/

        System.out.println(isFileB);        //---true---/

        System.out.println(isDirectoryB);    //---false---/

        System.out.println(isHiddenB);        //---false---/

        System.out.println(canReadB);        //---true---/

        System.out.println(canWriteB);        //---true---/

    }

}

1.0

f:获取功能

package d8;

import java.io.File;

import java.io.IOException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class FileGet {

    public static void main(String[] args) throws IOException {

        File fe = new File("D:\\aaa\\a.txt");

        String strAbsolutePath = fe.getAbsolutePath();// 获取文件绝对路径

        String strPath = fe.getPath();// 获取文件路径

        String strName = fe.getName();// 获取文件名

        Long length = fe.length();// 获取文件大小

        Long strLastModified = fe.lastModified();// 获取文件最后的修改时间

        Date d = new Date(strLastModified);

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        String s = sdf.format(d);

        System.out.println(strAbsolutePath); // ---D:\aaa\a.txt----/

        System.out.println(strPath); // ---D:\aaa\a.txt----/

        System.out.println(strName); // ---a.txt-----/

        System.out.println(length); // ---12-----/

        System.out.println(strLastModified); // ---1517184516189---/

        System.out.println(s); // ---2018-01-29 20:10:41----/

    }

}

1.0

package d8;

import java.io.File;

import java.io.IOException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class FileGet2 {

    public static void main(String[] args) throws IOException {

        File fe = new File("D:\\");

         String [] nameArray = fe.list();

         for (String s : nameArray) {

            System.out.println(s);

        }

         File [] fileArray = fe.listFiles();

         for (File f : fileArray) {

            System.out.println(f.getName());

        }

         /*

$RECYCLE.BIN

00002109030000000000000000F01FEC.reg

aaa

API文档

BaiduNetdiskDownload

Config.Msi

Develop

java(1)

JavaWorkspace

LuceneNet测试文件

midnds

MyDrivers

pagefile.sys

Program Files

Program Files (x86)

StormMedia

System Volume Information

Unity3D5.0

Users

博客资料

迅雷下载

黑马JavaEE32*/

    }

}

2.0

package d8;

import java.io.File;

import java.io.FileFilter;

import java.io.FilenameFilter;

import java.io.IOException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class FileTest {

    public static void main(String[] args) throws IOException {

        //找出D盘下所有以.reg结尾的文件

        File fe = new File("D:\\");

        //方法一:取出所有文件然后筛选

        File [] files = fe.listFiles();

        for (File f : files) {

            if (f.isFile()&&f.getName().endsWith(".reg")) {

                System.out.println(f.getName());

            }

        }

        //-----------00002109030000000000000000F01FEC.reg----------//

        //方法二: 通过过滤器先过滤一下 listFiles(FileFilter filter)

        File [] files2 = fe.listFiles(new FileFilter() {

            @Override

            public boolean accept(File pathname) {

                // TODO Auto-generated method stub

                return pathname.isFile()&&pathname.getName().endsWith(".reg");

            }

        });

        for (File f : files2) {

                System.out.println(f.getName());

        }

        //-----------00002109030000000000000000F01FEC.reg----------//

        //方法三:方法二可能消耗的资源有点大 list(FilenameFilter filter)

        String [] files3 =  fe.list(new FilenameFilter() {

            @Override

            public boolean accept(File dir, String name) {

                if (name.endsWith(".reg")) {

                    File fnew = new File(dir, name);

                    return fnew.isFile();

                }

                return false;

            }

        });

        for (String f : files3) {

                System.out.println(f);

        }

        //-----------00002109030000000000000000F01FEC.reg----------//

    }

}

3.0

递归获取4.0

2.0 IO

2.1　InputStream

　　2.1.1 FileInputStream

　　a:构造方法　　

package d8;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

public class FileInputStreamGouZao {

    public static void main(String[] args) throws FileNotFoundException {

        // 方式一:根据一个路径得到一个读取数据的写入文件流对象

        // FileOutputStream(String name)

        FileInputStream fos = new FileInputStream("D:\\aaa\\a.txt");

        // 方式二,通过File对象 得到一个读取数据的写入文件流对象

        // FileOutputStream(File file)

        File fe = new File("D:\\aaa", "a.txt");

        FileInputStream fos2 = new FileInputStream(fe);

    }

}

1.0

　　b:读取方法

package d8;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class FileInputStreamRead {

    public static void main(String[] args) throws IOException {

        // 方式一:

        // read()  从此输入流中读取一个数据字节。

        FileInputStream fis = new FileInputStream("D:\\aaa\\a.txt");

        int b = ;

        while((b=fis.read())!=-) {

            System.out.println((char)b);

        }

        fis.close();

        // 方式二

        //read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。

        FileInputStream fis2 = new FileInputStream("D:\\aaa\\a.txt");

        byte[] bs = new byte[];

        while(( fis2.read(bs))!=-) {

            System.out.println(new String(bs));

        }

        fis2.close();

        // read(byte[] b, int off, int len)

        // 从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。

        FileInputStream fis3 = new FileInputStream("D:\\aaa\\a.txt");

        byte[] bs2 = new byte[];

        int len = ;

        while(( len = fis3.read(bs2))!=-) {

            System.out.println(new String(bs2,,len));

        }

        fis3.close();

    }

}

/* 方式一

H

e

l

l

o

W

o

r

l

d

j

a

v

a    */

/* 方式二

Hello

Wor

ld 

java 

va

*/

/* 方式三

Hello

Wor

ld 

java

*/

1.0

　　2.1.2 BufferedInputStream

a:构造方法

package d8;

import java.io.BufferedInputStream;

import java.io.FileInputStream;

import java.io.IOException;

public class BufferedInputStreamGouZao {

    public static void main(String[] args) throws IOException   {

        // 方式一:根据一个路径得到一个写入数据的输出文件流对象

        //BufferedInputStream(InputStream out)

        BufferedInputStream fis = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.txt"));

        // 方式二,通过Buffered对象 得到一个写入数据的输出文件流对象

        // BufferedInputStream(InputStream out, int size)

        BufferedInputStream fis2 = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.txt"),);

    }

}

1.0

b:读取方法

package d8;

import java.io.BufferedInputStream;

import java.io.FileInputStream;

import java.io.IOException;

public class BufferedInputStreamReade{

    public static void main(String[] args) throws IOException {

        // 方式一

        // read(int b) 将指定字节写入此文件输出流。

        BufferedInputStream fis = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.txt"));

         int b =;

         while ((b=fis.read())!=-) {

             System.out.println(b);

        }

         /*

97

32

119

111*/

        // read(byte[] b, int off, int len)

        // 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。

        BufferedInputStream fis2 = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.txt"), );

         byte [] by = new byte[];

         int len =;

         while ((len = fis2.read(by,,))!=-) {

             System.out.println(new String(by,,len));

        }

         //------------a -----------//

        //------------wo-----------//

    }

}

1.0

2.2 OutPutStream

　　2.2.1 FileOutputStream

　　a:构造方法

package d8;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

public class FileOutputStreamGouZao {

    public static void main(String[] args) throws FileNotFoundException {

        //创建字节输出流对象做了3件事情

        //01 调用系统功能创建文件

        //02 创建fos对象

        //03 将字节输出流对象指向对应的文件

        // 方式一:根据一个路径得到一个写入数据的输出文件流对象

        // FileOutputStream(String name)

        FileOutputStream fos = new FileOutputStream("D:\\aaa\\a.txt");

        // 方式二,通过File对象 得到一个写入数据的输出文件流对象

        // FileOutputStream(File file)

        File fe = new File("D:\\aaa", "a.txt");

        FileOutputStream fos2 = new FileOutputStream(fe);

        // 方式三:根据一个路径得到一个写入数据的输出文件流对象,如为 true，则将字节写入文件末尾处

        // FileOutputStream(String name,boolean append)

        FileOutputStream fos3 = new FileOutputStream("D:\\aaa\\a.txt", true);

        // 方式四,通过File对象 得到一个写入数据的输出文件流对象,如为 true，则将字节写入文件末尾处

        // FileOutputStream((File file,boolean append)

        File fe2 = new File("D:\\aaa", "a.txt");

        FileOutputStream fos4 = new FileOutputStream(fe2, true);

    }

}

1.0

　　b:写入方法

package d8;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

public class FileOutputStreamWrite {

    public static void main(String[] args) throws IOException {

        // 创建字节输出流对象做了3件事情

        // 01 调用系统功能创建文件

        // 02 创建fos对象

        // 03 将字节输出流对象指向对应的文件

        // close()方法的作用

        // 1:让流对象变成垃圾,方便被垃圾回收站回收

        // 2:通知系统去释放掉该文件相关的资源

        // 方式一:

        // write(byte[] b) 根据一个路径将指定 byte 数组写入此文件输出流中

        FileOutputStream fos = new FileOutputStream("D:\\aaa\\a.txt");

        fos.write("Hello World !".getBytes());

        fos.close();

        // -------Hello World !---------//

        // 方式二

        // write(int b) 将指定字节写入此文件输出流。

        FileOutputStream fos2 = new FileOutputStream("D:\\aaa\\b.txt");

        fos2.write();

        fos2.close();

        // -------a---------//

        // write(byte[] b, int off, int len)

        // 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。

        FileOutputStream fos3 = new FileOutputStream("D:\\aaa\\c.txt");

        fos3.write("Hello World !".getBytes(), , );

        fos3.close();

        // -------Hello---------//

    }

}

1.0

package d8;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

public class FileOutputStreamWrite2 {

    public static void main(String[] args) throws IOException {

        // 创建字节输出流对象做了3件事情

        // 01 调用系统功能创建文件

        // 02 创建fos对象

        // 03 将字节输出流对象指向对应的文件

        // 方式一:

        // write(byte[] b) 根据一个路径将指定 byte 数组写入此文件输出流中

        FileOutputStream fos = new FileOutputStream("D:\\aaa\\a.txt",true);

        fos.write('\r');

        fos.write('\n');

        fos.write("Hello World !".getBytes());

        fos.close();

        //-------Hello World !---------//

        //--------Hello World ! ---------//

        // 方式二

        // write(int b) 将指定字节写入此文件输出流。

        File fe2 = new File("D:\\aaa", "b.txt");

        FileOutputStream fos2 = new FileOutputStream(fe2, true);

        fos2.write();

        fos2.close();

        //-------aa---------//

    }

}

2.0

　　2.2.2 BufferedOutputStream

　　a:构造方法

package d8;

import java.io.BufferedOutputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

public class BufferedOutputStreamGouZao {

    public static void main(String[] args) throws IOException   {

        // 方式一:根据一个路径得到一个写入数据的输出文件流对象

        //BufferedOutputStream(OutputStream out)

        BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a.txt"));

        // 方式二,通过Buffered对象 得到一个写入数据的输出文件流对象

        // BufferedOutputStream(OutputStream out, int size)

        BufferedOutputStream fos2 = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a.txt"),);

    }

}

1.0

　　b:写入方法

package d8;

import java.io.BufferedOutputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class BufferedOutputStreamWrite {

    public static void main(String[] args) throws IOException {

        // 方式一

        // write(int b) 将指定字节写入此文件输出流。

        BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a.txt"));

        fos.write();

        fos.close();

        // -------a---------//

        // write(byte[] b, int off, int len)

        // 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。

        BufferedOutputStream fos2 = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a.txt",true), );

        fos2.write("hello world java".getBytes(), , );

        fos2.close();

         //------------a wo-----------//

    }

}

1.0

练习：4钟操作的复制文件

package d8;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStream;

public class CopyTest {

    public static void main(String[] args) throws IOException {

        Long start = System.currentTimeMillis();

        method1();

        Long end = System.currentTimeMillis();

        System.out.println("方法一：耗时"+(end-start));

        Long start2 = System.currentTimeMillis();

        method2();

        Long end2 = System.currentTimeMillis();

        System.out.println("方法二：耗时"+(end2-start2));

        Long start3 = System.currentTimeMillis();

        method3();

        Long end3 = System.currentTimeMillis();

        System.out.println("方法三：耗时"+(end3-start3));

        Long start4 = System.currentTimeMillis();

        method4();

        Long end4 = System.currentTimeMillis();

        System.out.println("方法四：耗时"+(end4-start4));

    }

    private static void method4() throws IOException {

        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.avi"));

        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a4.avi"));

        byte [] by = new byte[];

        int len =;

        while ((len=bis.read(by))!=-) {

            bos.write(by,,len);

            bos.flush();

        }

        bis.close();

        bos.close();

    }

    //高效字节流，一次读写一个字节

    private static void method3() throws IOException {

        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.avi"));

        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a3.avi"));

        int b =;

        while ((b=bis.read())!=-) {

            bos.write(b);

        }

        bis.close();

        bos.close();

    }

    //基本字节流，一次读写一个数组长度

    private static void method2() throws IOException {

        FileInputStream fi2 = new FileInputStream("D:\\aaa\\a.avi");

        FileOutputStream fo2 = new FileOutputStream("D:\\aaa\\a2.avi");

        byte [] by = new byte[];

        int len =;

        while ((len=fi2.read(by))!=-) {

            fo2.write(by,,len);

        }

        fi2.close();

        fo2.close();

    }

    //基本字节流，一次读写一个字节

    private static void method1() throws IOException {

        FileInputStream fi = new FileInputStream("D:\\aaa\\a.avi");

        FileOutputStream fo = new FileOutputStream("D:\\aaa\\a1.avi");

        int b =;

        while ((b=fi.read())!=-) {

            fo.write(b);

        }

        fi.close();

        fo.close();

    }

}

/*

 方法一：耗时243369

方法二：耗时302

方法三：耗时416

方法四：耗时270

*/

1.0

字符流 = 字节流+编码表

3.1 Reader

　　3.1.1 InputStreamReader

　　a:构造方法　　

package d8;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.UnsupportedEncodingException;

public class InputStreamReaderGouZao {

    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 字符输入流：字节输入流+编码

        // 方式一:根据一个字节输入流 + 默认编码 得到一个字符输入对象

        // InputStreamReader(InputStream In)

        InputStreamReader isw = new InputStreamReader(new FileInputStream("D:\\aaa\\a.txt"));

        // 方式二：根据一个字节输入流 + 指定编码 得到一个字符输入对象

        // InputStreamReader(InputStream In, String charsetName)

        InputStreamReader isw2 = new InputStreamReader(new FileInputStream("D:\\aaa\\a.txt"), "utf-8");

    }

}

1.0

　　b:read方法

package d8;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.UnsupportedEncodingException;

public class InputStreamReaderRead {

    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 字符输入流：字节输入流+编码

        // 方式一:根据一个字节输入流 + 默认编码 得到一个字符输入对象

        // InputStreamReader(InputStream In)

        InputStreamReader osw = new InputStreamReader(new FileInputStream("D:\\aaa\\b.txt"));

        int b = ;

        while ((b=osw.read())!=-) {

            System.out.print((char)b);

        }

        // 方式二：根据一个字节输入流 + 指定编码 得到一个字符输入对象

        // InputStreamReader(InputStream In, String charsetName)

        InputStreamReader osw2 = new InputStreamReader(new FileInputStream("D:\\aaa\\b.txt"), "utf-8");

        char [] by =new char[];

        int len=;

        while ((len=osw2.read(by, , ))!=-) {

            System.out.println(new String(by,,len));

        }

    }

}

/*浣犲ソ涓栫晫你好世

界*/

1.0

3.1.2 FileReader

a：构造方法

package d8;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.FileReader;

import java.io.UnsupportedEncodingException;

public class FileReaderGouZao {

    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 方式一:根据一个字节输入流 + 默认编码 得到一个字符输入对象

        // FileReader(File file)

        FileReader isw = new FileReader("D:\\aaa\\a.txt");

        // 方式二：在给定从中读取数据的文件名的情况下创建一个新 FileReader。

        // FileReader( String fileName)

        FileReader isw2 = new FileReader(new File("D:\\aaa\\a.txt"));

    }

}

1.0

b:read方法

package d8;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.UnsupportedEncodingException;

public class FileReaderRead {

    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 方式一:根据一个字节输入流 + 默认编码 得到一个字符输入对象

        // FileReader(File file)

        FileReader fr = new FileReader("D:\\aaa\\a.txt");

        int b = ;

        while ((b = fr.read()) != -) {

            System.out.print((char) b);

        }

        // 方式二：在给定从中读取数据的文件名的情况下创建一个新 FileReader。

        // FileReader( String fileName)

        FileReader fr2 = new FileReader(new File("D:\\aaa\\a.txt"));

        char[] by = new char[];

        int len = ;

        while ((len = fr2.read(by, , )) != -) {

            System.out.println(new String(by, , len));

        }

    }

}

/*

 * aaabcdefaaa

bcd

ef

 */

1.0

3.1.3 BufferedReader

a：构造方法

package d8;

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

public class BufferedReaderGouZao {

    public static void main(String[] args) throws  IOException {

        // 方式一:根据一个字节输入流 + 默认编码 得到一个字符输入对象

        // BufferedReader(Reader in)

        BufferedReader br = new BufferedReader(new FileReader("D:\\aaa\\a.txt"));

        // 方式二：BufferedReader(Reader in, int sz)

        // 创建一个使用指定大小输入缓冲区的缓冲字符输入流。

        BufferedReader br2 = new BufferedReader(new FileReader("D:\\aaa\\a.txt"),);

    }

}

1.0

b：read方法

package d8;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.UnsupportedEncodingException;

public class BufferedReaderRead {

    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 方式一：BufferedReader(Reader in)

        // 创建一个使用指定大小输入缓冲区的缓冲字符输入流。

        BufferedReader br = new BufferedReader(new FileReader("D:\\aaa\\a.txt"));

        int b = ;

        while ((b = br.read()) != -) {

            System.out.print((char) b);

        }

        // 方式二：BufferedReader(Reader in, int sz)

        // 创建一个使用指定大小输入缓冲区的缓冲字符输入流。

        BufferedReader br2 = new BufferedReader(new FileReader("D:\\aaa\\a.txt"), );

        char[] by = new char[];

        int len = ;

        while ((len = br2.read(by, , )) != -) {

            System.out.println(new String(by, , len));

        }

    }

}

/*

 * aaaa

 */

1.0

2.0 写入一个文本行

3.2 Writer

　　3.2.1 OutputStreamWriter

a：构造方法

package d8;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.io.UnsupportedEncodingException;

public class OutputStreamWriterGouZao {

    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 字符输出流：字节输出流+编码

        // 方式一:根据一个字节输出流 + 默认编码 得到一个字符输出对象

        // OutputStreamWriter(OutputStream out)

        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\a.txt"));

        // 方式二：根据一个字节输出流 + 指定编码 得到一个字符输出对象

        // OutputStreamWriter(OutputStream out, String charsetName)

        OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\a.txt"), "utf-8");

    }

}

1.0

b: Write方法

package d8;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.io.UnsupportedEncodingException;

public class OutputStreamWriterWrite {

    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 方式一： 写入单个字符 write(int c)

        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\a.txt"));

        osw.write();

        osw.write('a');

        osw.close();

        // 方式二：写入字符数组。 write(char[] cbuf)

        OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\b.txt"), "utf-8");

        char[] che = { 'a', 'b', 'c', 'd', 'e', 'f' };

        osw2.write(che);

        osw2.flush();

        osw2.close();

        // 方式三：写入字符数组的某一部分。 write(char[] cbuf, int off, int len)

        OutputStreamWriter osw3 = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\c.txt"));

        char[] che2 = { 'a', 'b', 'c', 'd', 'e', 'f' };

        osw3.write(che2, , );

        osw3.write("Hello world".toCharArray());

        osw3.close();

        // 方式四： 写入字符串 。 write(String str)

        OutputStreamWriter osw4 = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\d.txt"), "utf-8");

        String str = "Hello World Java";

        osw4.write(str);

        osw4.flush();

        osw4.close();

        // 方式五： 写入字符串的某一部分。 write(String str, int off, int len)

        OutputStreamWriter osw5 = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\e.txt"), "utf-8");

        String str2 = "Hello World Java";

        osw5.write(str2,,);

        osw5.flush();

        osw5.close();

    }

}

/*

 * aa

 * abcdef

 * cdeHello world

 * Hello World Java

 * lo W

 */

1.0

3.2.2 FileWriter

a:构造方法

package d8;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.FileWriter;

import java.io.UnsupportedEncodingException;

public class FileWriterGouZao {

    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 方式一: 根据给定的文件名值来构造 FileWriter 对象

        // FileWriter(String fileName)

        FileWriter fw = new FileWriter("D:\\aaa\\a.txt");

        // 方式二： 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象

        // FileWriter(String fileName, boolean append)

        FileWriter fw2 = new FileWriter(("D:\\aaa\\a.txt"),true);

        // 方式三: 根据给定的文件名值来构造 FileWriter 对象

        // FileWriter(File file)

        FileWriter fw3 = new FileWriter(new File("D:\\aaa\\a.txt") );

        // 方式四： 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象

        //FileWriter(File file, boolean append)

        FileWriter fw4 = new FileWriter(new File("D:\\aaa","a.txt"),true);

    }

}

1.0

b: Write方法

package d8;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.FileWriter;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.io.UnsupportedEncodingException;

public class FileWriterWrite {

    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 方式一: 根据给定的文件名值来构造 FileWriter 对象

        // FileWriter(String fileName)

        FileWriter fw = new FileWriter("D:\\aaa\\a.txt");

        // 方式一： 写入单个字符 write(int c)

        fw.write();

        fw.write('a');

        fw.close();

        // 方式二： 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象

        // FileWriter(String fileName, boolean append)

        FileWriter fw2 = new FileWriter(("D:\\aaa\\a.txt"), true);

        // 方式二：写入字符数组。 write(char[] cbuf)

        char[] che = { 'a', 'b', 'c', 'd', 'e', 'f' };

        fw2.write(che);

        fw2.flush();

        fw2.close();

        // 方式三: 根据给定的文件名值来构造 FileWriter 对象

        // FileWriter(File file)

        FileWriter fw3 = new FileWriter(new File("D:\\aaa\\b.txt"));

        // 方式三：写入字符数组的某一部分。 write(char[] cbuf, int off, int len)

        char[] che2 = { 'a', 'b', 'c', 'd', 'e', 'f' };

        fw3.write(che2, , );

        fw3.close();

        // 方式四： 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象

        // FileWriter(File file, boolean append)

        FileWriter fw4 = new FileWriter(new File("D:\\aaa", "b.txt"), true);

        // 方式四： 写入字符串 。 write(String str)

        String str = "Hello World Java";

        fw4.write(str);

        fw4.flush();

        fw4.close();

        // 方式一: 根据给定的文件名值来构造 FileWriter 对象

        // FileWriter(String fileName)

        FileWriter fw5 = new FileWriter("D:\\aaa\\c.txt");

        // 方式五： 写入字符串的某一部分。 write(String str, int off, int len)

        String str2 = "Hello World Java";

        fw5.write(str2, , );

        fw5.flush();

        fw5.close();

    }

}

/*

 *aaabcdef

 *cdeHello World Java

 *lo W

 */

1.0

3.2.3 BufferedWwriter

a:构造方法

package d8;

import java.io.BufferedWriter;

import java.io.FileWriter;

import java.io.IOException;

public class BufferedWriterGouZao {

    public static void main(String[] args) throws  IOException {

        // 方式一:  创建一个使用默认大小输出缓冲区的新缓冲字符输出流。

        // BufferedWriter(Writer out)

        BufferedWriter bw = new BufferedWriter( new FileWriter("D:\\aaa\\a.txt"));

        // 方式二：  创建一个使用给定大小输出缓冲区的新缓冲字符输出流。

        // BufferedWriter(Writer out, int sz)

        BufferedWriter bw2 = new BufferedWriter( new FileWriter("D:\\aaa\\a.txt"),);

    }

}

1.0

b: Write方法

package d8;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.FileWriter;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.io.UnsupportedEncodingException;

public class BufferedWriterWrite {

    public static void main(String[] args) throws FileNotFoundException, IOException {

        // 方式一:  创建一个使用默认大小输出缓冲区的新缓冲字符输出流。

        // BufferedWriter(Writer out)

        BufferedWriter bw = new BufferedWriter( new FileWriter("D:\\aaa\\a.txt"));

        // 方式一： 写入单个字符 write(int c)

        bw.write();

        bw.write('a');

        bw.close();

        // 方式二：  创建一个使用给定大小输出缓冲区的新缓冲字符输出流。

        // BufferedWriter(Writer out, int sz)

        BufferedWriter bw2 = new BufferedWriter( new FileWriter("D:\\aaa\\b.txt"),);

        // 方式二：写入字符数组。 write(char[] cbuf)

        char[] che = { 'a', 'b', 'c', 'd', 'e', 'f' };

        bw2.write(che);

        bw2.flush();

        bw2.close();

        // 方式一:  创建一个使用默认大小输出缓冲区的新缓冲字符输出流。

        // BufferedWriter(Writer out)

        BufferedWriter bw3 = new BufferedWriter( new FileWriter("D:\\aaa\\c.txt"));

        // 方式三：写入字符数组的某一部分。 write(char[] cbuf, int off, int len)

        char[] che2 = { 'a', 'b', 'c', 'd', 'e', 'f' };

        bw3.write(che2, , );

        bw3.close();

        // 方式一:  创建一个使用默认大小输出缓冲区的新缓冲字符输出流。

        // BufferedWriter(Writer out)

        BufferedWriter bw4 = new BufferedWriter( new FileWriter("D:\\aaa\\d.txt"));

        // 方式四： 写入字符串 。 write(String str)

        String str = "Hello World Java";

        bw4.write(str);

        bw4.flush();

        bw4.close();

        // 方式一:  创建一个使用默认大小输出缓冲区的新缓冲字符输出流。

        // BufferedWriter(Writer out)

        BufferedWriter bw5 = new BufferedWriter( new FileWriter("D:\\aaa\\e.txt"));

        // 方式五： 写入字符串的某一部分。 write(String str, int off, int len)

        String str2 = "Hello World Java";

        bw5.write(str2, , );

        bw5.flush();

        bw5.close();

    }

}

/*

 *aa

 *abcdef

 *cde

 *Hello World Java

 *lo W

 */

1.0

2.0 写入一个行分隔符

3.3 练习

练习1:5中方法复制文本文件

package d8;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

public class CopyTxt {

    public static void main(String[] args) throws IOException {

        Long start = System.currentTimeMillis();

        method1();

        Long end = System.currentTimeMillis();

        System.out.println("方法一：耗时"+(end-start));

        Long start2 = System.currentTimeMillis();

        method2();

        Long end2 = System.currentTimeMillis();

        System.out.println("方法二：耗时"+(end2-start2));

        Long start3 = System.currentTimeMillis();

        method3();

        Long end3 = System.currentTimeMillis();

        System.out.println("方法三：耗时"+(end3-start3));

        Long start4 = System.currentTimeMillis();

        method4();

        Long end4 = System.currentTimeMillis();

        System.out.println("方法四：耗时"+(end4-start4));

        Long start5 = System.currentTimeMillis();

        method5();

        Long end5 = System.currentTimeMillis();

        System.out.println("方法五：耗时"+(end5-start5));

    }

    private static void method5() throws IOException {

        // Buffered 一次读取一个字符数组

        FileReader fr = new FileReader("D:\\aaa\\a.txt");

        FileWriter fw = new FileWriter("D:\\aaa\\b.txt", true);

        BufferedReader br = new BufferedReader(fr);

        BufferedWriter bw = new BufferedWriter(fw);

        bw.write("--方法五，FileXXX 开始");

        bw.newLine();

        String line;

        while ((line = br.readLine()) != null) {

            bw.write(line);;

        }

        bw.newLine();

        bw.write("--方法五，FileXXX 结束");

        bw.newLine();

        // 释放资源

        br.close();

        bw.close();

    }

    private static void method4() throws IOException {

        // Buffered 一次读取一个字符数组

        FileReader fr = new FileReader("D:\\aaa\\a.txt");

        FileWriter fw = new FileWriter("D:\\aaa\\b.txt", true);

        BufferedReader br = new BufferedReader(fr);

        BufferedWriter bw = new BufferedWriter(fw);

        bw.write("--方法四，FileXXX 开始");

        bw.newLine();

        int len = ;

        char[] ch = new char[];

        while ((len = br.read(ch)) != -) {

            bw.write(ch, , len);

        }

        bw.newLine();

        bw.write("--方法四，FileXXX 结束");

        bw.newLine();

        // 释放资源

        br.close();

        bw.close();

    }

    private static void method3() throws IOException {

        // Buffered 一次读取一个字符

        FileReader fr = new FileReader("D:\\aaa\\a.txt");

        FileWriter fw = new FileWriter("D:\\aaa\\b.txt", true);

        BufferedReader br = new BufferedReader(fr);

        BufferedWriter bw = new BufferedWriter(fw);

        bw.write("--方法三，FileXXX 开始");

        bw.newLine();

        int i = ;

        while ((i = br.read()) != -) {

            bw.write((i));

        }

        bw.newLine();

        bw.write("--方法三，FileXXX 结束");

        bw.newLine();

        // 释放资源

        br.close();

        bw.close();

    }

    private static void method2() throws IOException {

        // File 一次读取一个字符数组

        FileReader fr = new FileReader("D:\\aaa\\a.txt");

        FileWriter fw = new FileWriter("D:\\aaa\\b.txt", true);

        fw.write("--方法二，FileXXX 开始");

        fw.write("\r\n");

        int len = ;

        char[] ch = new char[];

        while ((len = fr.read(ch)) != -) {

            fw.write(ch, , len);

        }

        fw.write("\r\n");

        fw.write("--方法二，FileXXX 结束");

        fw.write("\r\n");

        // 释放资源

        fr.close();

        fw.close();

    }

    private static void method1() throws IOException {

        // File 一次读取一个字符

        FileReader fr = new FileReader("D:\\aaa\\a.txt");

        FileWriter fw = new FileWriter("D:\\aaa\\b.txt");

        fw.write("--方法一，FileXXX 开始");

        fw.write("\r\n");

        int i = ;

        while ((i = fr.read()) != -) {

            fw.write((i));

        }

        fw.write("\r\n");

        fw.write("--方法一，FileXXX 结束");

        fw.write("\r\n");

        // 释放资源

        fr.close();

        fw.close();

    }

/*

 * 方法一：耗时3

方法二：耗时2

方法三：耗时2

方法四：耗时1

方法五：耗时1

*

*

*

*--方法一，FileXXX 开始

aa

bb

cc

dd

ee

ff

gg

--方法一，FileXXX 结束

--方法二，FileXXX 开始

aa

bb

cc

dd

ee

ff

gg

--方法二，FileXXX 结束

--方法三，FileXXX 开始

aa

bb

cc

dd

ee

ff

gg

--方法三，FileXXX 结束

--方法四，FileXXX 开始

aa

bb

cc

dd

ee

ff

gg

--方法四，FileXXX 结束

--方法五，FileXXX 开始

aabbccddeeffgg

--方法五，FileXXX 结束

*/

}

1.0

4:综合练习

1:复制单级文件夹

package d8;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class CopySingeFolder {

    public static void main(String[] args) throws IOException {

        // 需求：将单层文件夹例如：aaa文件下内容（只有文件）复制到bbb文件

        // 根据文件路径获取文件集合

        File srcFolder = new File("D:\\aaa");// 源文件

        File destFolder = new File("D:\\bbb");// 目标文件

        // 如果目标路径不存在,就创建,如果存在,就清空

        if (destFolder.exists()) {

            //清空文件夹

            clearFolder(destFolder);

        }

        destFolder.mkdir();

        // 获取源文件夹中的文件

        CopyFolder(srcFolder,destFolder);

    }

    //复制文件

    private static void CopyFolder(File srcFolder, File destFolder) throws IOException {

        File[] srcFiles = srcFolder.listFiles();

        if (srcFiles.length > ) {

            for (File file : srcFiles) {

                CopyFile(file,destFolder);

            }

        }

    }

    private static void CopyFile(File file, File destFolder) throws IOException {

        BufferedInputStream bis= new BufferedInputStream(new FileInputStream(file));

        String destName = file.getName();

        BufferedOutputStream bos= new BufferedOutputStream(new FileOutputStream(new File(destFolder,destName)));

        int len=;

        byte [] by=new byte[];

        while ((len=bis.read(by))!=-) {

            bos.write(by,,len);

        }

        bos.close();

        bis.close();

    }

    //清空目标文件夹

    private static void clearFolder(File destFolder) {

        // TODO Auto-generated method stub

        File [] destFiles =destFolder.listFiles();

        if (destFiles!=null&&destFiles.length>) {

            for (File file : destFiles) {

                file.delete();

            }

        }

        destFolder.delete();

    }

}

1.0

2:复制文件

package d8;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class CopyMultistageFolder {

    public static void main(String[] args) throws IOException {

        // 需求：文件夹复制

        // 根据文件路径获取文件集合

        File srcFolder = new File("D:\\aaa");// 源文件

        File destFolder = new File("D:\\bbb");// 目标文件

        // 如果目标路径不存在,就创建,如果存在,就清空

        if (destFolder.exists()) {

            //清空文件夹

            clearFolder(destFolder);

        }

        destFolder.mkdir();

        // 获取源文件夹中的文件

        CopyFolder(srcFolder,destFolder);

    }

    //复制文件

    private static void CopyFolder(File srcFolder, File destFolder) throws IOException {

        File[] srcFiles = srcFolder.listFiles();

        if (srcFiles.length > ) {

            for (File file : srcFiles) {

                if (file.isFile()) {

                    CopyFile(file,destFolder);

                }

                else if (file.isDirectory()) {

                    //创建一个文件夹

                    File newFolder = new File(destFolder.getAbsolutePath(),file.getName());// 目标文件

                    newFolder.mkdir();

                    CopyFolder(file,newFolder);

                }

            }

        }

    }

    private static void CopyFile(File file, File destFolder) throws IOException {

        BufferedInputStream bis= new BufferedInputStream(new FileInputStream(file));

        String destName = file.getName();

        BufferedOutputStream bos= new BufferedOutputStream(new FileOutputStream(new File(destFolder,destName)));

        int len=;

        byte [] by=new byte[];

        while ((len=bis.read(by))!=-) {

            bos.write(by,,len);

        }

        bos.close();

        bis.close();

    }

    //清空目标文件夹

    private static void clearFolder(File destFolder) {

        //级联删除

        if (destFolder.isFile()||destFolder == null ) {

            destFolder.delete();

        }else if(destFolder.isDirectory()&&destFolder.listFiles().length<) {

            destFolder.delete();

        }else {

            File [] destFiles =destFolder.listFiles();

            if (destFiles!=null&&destFiles.length>) {

                for (File file : destFiles) {

                    clearFolder(file);

                }

            }

            destFolder.delete();

        }

        destFolder.delete();

    }

}

1.0

3:模拟BufferedReader的readLine()+ BufferedWriter的newLine()+LineNumberReader的getLineNumber()和setLineNumber()

package d8;

import java.io.IOException;

import java.io.Reader;

public class MyBufferedReader {

    private Reader r;

    public MyBufferedReader(Reader r) {

         this.r =r;

    }

    public String readLine() throws IOException {

        StringBuilder sb = new StringBuilder();

        int i = ;

        while ((i = r.read()) != -) {

            if (i == '\r') {

                continue;

            }

            if (i == '\n') {

                return sb.toString();

            }else {

                sb.append((char)i);

            }

        }

        if (sb.toString().length()>) {

            return sb.toString();

        }

        return null;

    }

    // close方法

    public void close() throws IOException {

        r.close();

    }

}

MyBufferedReader

package d8;

import java.io.IOException;

import java.io.Writer;

public class MyBufferedWriter {

    //首先需要一個屬性Writer

    private Writer w;

     //創建一個構造方法

    public MyBufferedWriter( Writer w) {

        this.w =w;

    }

    public void newLine () throws IOException {

        w.write('\r');

        w.write('\n');

    }

    public void write (String str) throws IOException {

        w.write(str);

    }

    public void close() throws IOException {

        w.close();

    }

}

MyBufferedWriter

package d8;

import java.io.IOException;

import java.io.Reader;

public class MyLineNumberReader {

    private Reader r;

    private int lineNumber;

    public MyLineNumberReader(Reader r) {

         this.r =r;

    }

    public String readLine() throws IOException {

        lineNumber++;

        StringBuilder sb = new StringBuilder();

        int i = ;

        while ((i = r.read()) != -) {

            if (i == '\r') {

                continue;

            }

            if (i == '\n') {

                return sb.toString();

            }else {

                sb.append((char)i);

            }

        }

        if (sb.toString().length()>) {

            return sb.toString();

        }

        return null;

    }

    public int getLineNumber() {

        return lineNumber;

    }

    public void setLineNumber(int lineNumber) {

        this.lineNumber = lineNumber;

    }

    // close方法

    public void close() throws IOException {

        r.close();

    }

}

MyLineNumberReader 1.0

package d8;

import java.io.IOException;

import java.io.Reader;

public class MyLineNumberReader2 extends MyLineNumberReader {

    private Reader r;

    private int lineNumber;

    public MyLineNumberReader2(Reader r) {

        super(r);

    }

    public String readLine() throws IOException {

        lineNumber++;

        return super.readLine();

    }

    public int getLineNumber() {

        return lineNumber;

    }

    public void setLineNumber(int lineNumber) {

        this.lineNumber = lineNumber;

    }

}

MyLineNumberReader2

package d8;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

public class MyBufferedTest {

     public static void main(String[] args) throws IOException {

        MyBufferedReader mbr = new MyBufferedReader(new FileReader("D:\\aaa\\a.txt"));

        MyBufferedWriter mbw = new MyBufferedWriter(new FileWriter("D:\\aaa\\b.txt"));

        String line = "";

        while ((line = mbr.readLine())!=null) {

            System.out.println(line);

            mbw.write(line);

            mbw.newLine();

            mbw.write("哈哈");

            mbw.newLine();

        }

        mbr.close();

        mbw.close();

        MyLineNumberReader mlnr = new MyLineNumberReader(new FileReader("D:\\aaa\\a.txt"));

        mlnr.setLineNumber();

        while ((line = mlnr.readLine())!=null) {

            System.out.println(mlnr.getLineNumber()+":"+line);

            }

        mlnr.close();

        MyLineNumberReader2 mlnr2 = new MyLineNumberReader2(new FileReader("D:\\aaa\\a.txt"));

        mlnr2.setLineNumber();

        while ((line = mlnr2.readLine())!=null) {

            System.out.println(mlnr2.getLineNumber()+":"+line);

            }

        mlnr2.close();

    }

}

MyBufferedTest

滴水穿石-08IO的更多相关文章

  1. 熬之滴水穿石:Spring--精简的J2EE(5)

                                   47--Spring的MVC 在Spring的框架中也存在MVC这样的模式,在Spring下有2个这样的控制器一个叫Controller, ...

  2. 熬之滴水穿石：JSP--HTML中的JAVA代码(6)

                                                                       39--JSTL 在JSP编码中需考虑的一种方法,因为这种方法可以 ...

  3. 熬之滴水穿石:Spring--精简的J2EE(6)

                                           48--曾用过的View 在Spring MVC架构中View实际上是有多种选择的.JSP是首选的view,实际上在J2E ...

  4. 滴水穿石-10GUI

    GUI 图形用户界面 1 Frame 窗体 package d10; //第一导入包 import java.awt.Frame; import java.awt.event.WindowAdapte ...

  5. 滴水穿石-07Java开发中常见的错误

    1:使用工具Eclipse 1.1 "语法错误" 仅当源级别为 1.5 时已参数化的类型才可用 设置eclipse,窗口—>java—>编译器—>JDK一致性调到 ...

  6. 滴水穿石-04Eclipse中常用的快捷键

    一:常用快捷键 1:内容辅助键  :Alt+/ :main + 该快捷键 :自动生成main方法 :syso + 该快捷键 :自动生成System.out.println();语句 :提示作用 :内容 ...

  7. 滴水穿石-01JAVA和C#的区别

    排名不分先后,想到哪写到哪 1:数组的定义格式不同 java定义: 方式1: ] ; 方式2: ] ; C#中只有方式1 java有两种,C#只有一种 2:继承的实现关键字不同,同时java中实现接口 ...

  8. 滴水穿石 C#中多线程 委托的使用

    什么是多线程?我们在建立以个C#项目时,往往会在Form1上添加控件,然后写代码,初 学者都是在重复这个过程,其实这个过程是单线程的,可以理解为只有“main”主线程,有 的时候往往需要同时测量多个东 ...

  9. F5负载均衡的初识和基本配置

    目前全球范围内应用比较广泛的负载均衡设备为美国的F5.F5于2000年底进驻中国,在国内业界,F5负载均衡产品已经成为了主流负载均衡技术的代名词.下面我们对F5负载均衡设备做一个基本介绍,方便大家去认 ...

随机推荐

  1. 20165234 《Java程序设计》第一周学习总结

    第一周学习总结 教材学习内容总结 java的特点 语法简单,面向对象,稳定,与平台无关,多线程,动态. 平台是由操作系统和处理器(CPU)所构成,每个平台都会形成自己独特的机器指令,相同的CPU和不同 ...

  2. OGG-01168

    https://blog.csdn.net/zhrzhl/article/details/21698659

  3. Configuring Automatic Restart of an Oracle Database

    https://docs.oracle.com/cd/E11882_01/server.112/e25494/restart.htm#ADMIN12708

  4. 高效的多维空间点索引算法 — Geohash 和 Google S2

    原文地址:https://www.jianshu.com/p/7332dcb978b2   引子 每天我们晚上加班回家,可能都会用到滴滴或者共享单车.打开 app 会看到如下的界面:     app ...

  5. Codeforces 914D - Bash and a Tough Math Puzzle 线段树,区间GCD

    题意: 两个操作, 单点修改 询问一段区间是否能在至多一次修改后,使得区间$GCD$等于$X$ 题解: 正确思路; 线段树维护区间$GCD$,查询$GCD$的时候记录一共访问了多少个$GCD$不被X整 ...

  6. python操作三大主流数据库(14)python操作redis之新闻项目实战②新闻数据的展示及修改、删除操作

    python操作三大主流数据库(14)python操作redis之新闻项目实战②新闻数据的展示及修改.删除操作 项目目录: ├── flask_redis_news.py ├── forms.py ├ ...

  7. PHP程序守护进程化

    一般Server程序都是运行在系统后台,这与普通的交互式命令行程序有很大的区别.glibc里有一个函数daemon.调用此函数,就可使当前进程脱离终端变成一个守护进程,具体内容参见man daemon ...

  8. 运输层TCP/UDP

    UDP:用户数据报协议 客户不与服务器建立连接,它只管用函数sendto给服务器发送数据报,此函数要求目的地址(服务器)作为其参数.类似的,服务器不从客户接受连接,它只管调用函数recvfrom,等待 ...

  9. pyhon 前面补充和set

    一, 主要内容. 补充一个字符串的基本操作 li = ["李嘉诚", "麻花藤", "黄海峰", "刘嘉玲"] s = ...

  10. [转]Java微服务框架选型（Dubbo 和 Spring Cloud？）

    转载于 http://www.cnblogs.com/xishuai/p/dubbo-and-spring-cloud.html 微服务(Microservices)是一种架构风格,一个大型复杂软件应 ...