大家能否给出io流中println(),newLine(),write()等的使用场合和它们之间的异同？

楼主应该先自己总结总结，而不是让别人来总结，这样才能快速提升自己的技术。

楼主要看方法使用场合和异同，直接查API就好了

要是io流部分的总结，倒是可以发一个
流的操作规律：
        1，明确源和目的。
        数据源：就是需要读取，可以使用两个体系：InputStream、Reader；
        数据汇：就是需要写入，可以使用两个体系：OutputStream、Writer；
        2，操作的数据是否是纯文本数据？
        如果是：数据源：Reader
                    数据汇：Writer
        如果不是：数据源：InputStream
                      数据汇：OutputStream
        3，虽然确定了一个体系，但是该体系中有太多的对象，到底用哪个呢？
        明确操作的数据设备。
        数据源对应的设备：硬盘(File)，内存(数组)，键盘(System.in)
        数据汇对应的设备：硬盘(File)，内存(数组)，控制台(System.out)。
        4，需要在基本操作上附加其他功能吗？比如缓冲。
        如果需要就进行装饰。

转换流特有功能：转换流可以将字节转成字符，原因在于，将获取到的字节通过查编码表获取到指定对应字符。

转换流的最强功能就是基于 字节流 + 编码表 。没有转换，没有字符流。

发现转换流有一个子类就是操作文件的字符流对象：
InputStreamReader
        |--FileReader
OutputStreamWriter
        |--FileWrier

想要操作文本文件，必须要进行编码转换，而编码转换动作转换流都完成了。所以操作文件的流对象只要继承自转换流就可以读取一个字符了。

但是子类有一个局限性，就是子类中使用的编码是固定的，是本机默认的编码表，对于简体中文版的系统默认码表是GBK。
FileReader fr = new FileReader("a.txt");
InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"gbk");
以上两句代码功能一致，
如果仅仅使用平台默认码表，就使用FileReader fr = new FileReader("a.txt"); //因为简化。

如果需要制定码表，必须用转换流。
转换流 = 字节流+编码表。
转换流的子类File = 字节流 + 默认编码表。

凡是操作设备上的文本数据，涉及编码转换，必须使用转换流。

File类常见方法：
        1：创建。
        boolean createNewFile()：在指定目录下创建文件，如果该文件已存在，则不创建。而对操作文件的输出流而言，输出流对象已建立，就会创建文件，如果文件已存在，会覆盖。除非续写。
        boolean mkdir()：创建此抽象路径名指定的目录。
        boolean mkdirs()：创建多级目录。
        2：删除。
        boolean delete()：删除此抽象路径名表示的文件或目录。
        void deleteOnExit()：在虚拟机退出时删除。
        注意：在删除文件夹时，必须保证这个文件夹中没有任何内容，才可以将该文件夹用delete删除。
        window的删除动作，是从里往外删。注意：java删除文件不走回收站。要慎用。
        3：获取.
        long length()：获取文件大小。
        String getName()：返回由此抽象路径名表示的文件或目录的名称。
        String getPath()：将此抽象路径名转换为一个路径名字符串。
        String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。
        String getParent()：返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，则返回 null。
        long lastModified()：返回此抽象路径名表示的文件最后一次被修改的时间。
        File.pathSeparator：返回当前系统默认的路径分隔符，windows默认为 “；”。
        File.Separator：返回当前系统默认的目录分隔符，windows默认为 “\”。
        4：判断：
        boolean exists()：判断文件或者文件夹是否存在。
        boolean isDirectory()：测试此抽象路径名表示的文件是否是一个目录。
        boolean isFile()：测试此抽象路径名表示的文件是否是一个标准文件。
        boolean isHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。
        boolean isAbsolute()：测试此抽象路径名是否为绝对路径名。
        5：重命名。
         boolean renameTo(File dest)：可以实现移动的效果。剪切+重命名。

        String[] list()：列出指定目录下的当前的文件和文件夹的名称。包含隐藏文件。
        如果调用list方法的File 对象中封装的是一个文件，那么list方法返回数组为null。如果封装的对象不存在也会返回null。只有封装的对象存在并且是文件夹时，这个方法才有效。

递归：就是函数自身调用自身。
什么时候用递归呢？
        当一个功能被重复使用，而每一次使用该功能时的参数不确定，都由上次的功能元素结果来确定。
        简单说：功能内部又用到该功能，但是传递的参数值不确定。(每次功能参与运算的未知内容不确定)。

递归的注意事项：
        1：一定要定义递归的条件。
        2：递归的次数不要过多。容易出现 StackOverflowError 栈内存溢出错误。
        其实递归就是在栈内存中不断的加载同一个函数。
------------------------------------------------------------------------------------------------
Java.util.Properties：一个可以将键值进行持久化存储的对象。Map--Hashtable的子类。
Map
        |--Hashtable
                |--Properties：用于属性配置文件，键和值都是字符串类型。
特点：1：可以持久化存储数据。2：键值都是字符串。3：一般用于配置文件。

        |-- load()：将流中的数据加载进集合。
        原理：其实就是将读取流和指定文件相关联，并读取一行数据，因为数据是规则的key=value，所以获取一行后，通过 = 对该行数据进行切割，左边就是键，右边就是值，将键、值存储到properties集合中。
        |-- store()：写入各个项后，刷新输出流。
        |-- list()：将集合的键值数据列出到指定的目的地。
-------------------------------------------------------------------------------------------------
以下介绍IO包中扩展功能的流对象：基本都是装饰设计模式。
Java.io.outputstream.PrintStream：打印流
1：提供了更多的功能，比如打印方法。可以直接打印任意类型的数据。
2：它有一个自动刷新机制，创建该对象，指定参数，对于指定方法可以自动刷新。
3：它使用的本机默认的字符编码.
4：该流的print方法不抛出IOException。

该对象的构造函数。
PrintStream(File file)  ：创建具有指定文件且不带自动行刷新的新打印流。
PrintStream(File file, String csn) ：创建具有指定文件名称和字符集且不带自动行刷新的新打印流。
PrintStream(OutputStream out) ：创建新的打印流。
PrintStream(OutputStream out, boolean autoFlush) ：创建新的打印流。
PrintStream(OutputStream out, boolean autoFlush, String encoding) ：创建新的打印流。
PrintStream(String fileName) ：创建具有指定文件名称且不带自动行刷新的新打印流。
PrintStream(String fileName, String csn)

PrintStream可以操作目的：1：File对象。2：字符串路径。3：字节输出流。
前两个都JDK1.5版本才出现。而且在操作文本文件时，可指定字符编码了。

        当目的是一个字节输出流时，如果使用的println方法，可以在printStream对象上加入一个true参数。这样对于println方法可以进行自动的刷新，而不是等待缓冲区满了再刷新。最终print方法都将具体的数据转成字符串，而且都对IO异常进行了内部处理。

        既然操作的数据都转成了字符串，那么使用PrintWriter更好一些。因为PrintWrite是字符流的子类，可以直接操作字符数据，同时也可以指定具体的编码。
--------------------------------------------------------
PrintWriter：具备了PrintStream的特点同时，还有自身特点：
该对象的目的地有四个：1：File对象。2：字符串路径。3：字节输出流。4：字符输出流。

开发时尽量使用PrintWriter。

方法中直接操作文件的第二参数是编码表。
直接操作输出流的，第二参数是自动刷新。

//读取键盘录入将数据转成大写显示在控制台.
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));//源：键盘输入
//目的：把数据写到文件中，还想自动刷新。
PrintWriter out = new PrintWriter(new FileWriter("out.txt"),true);//设置true后自动刷新
String line = null;
while((line=bufr.readLine())!=null){
        if("over".equals(line))
                break;
        out.println(line.toUpperCase());//转大写输出
}
        //注意：System.in，System.out这两个标准的输入输出流，在jvm启动时已经存在了。随时可以使用。当jvm结束了，这两个流就结束了。但是，当使用了显示的close方法关闭时，这两个流在提前结束了。
out.close();
bufr.close();

其实，有一些楼上总结的都比我的好，楼主也可以拿过来借鉴一下
1、println()
        有两个类可以使用到println()。从API文档上看，第一个PrintWriter是Writer的一个子类，是向文本输出流打印对象的格式化表示形式，所以PrintWriter可以用来操作字符数据。

第二个是PrintStream该类是OutStream的一个子类，所以具备父类的功能。此外该类也添加了打印的方法也就是println()和print()。可以用来操作字节流。这两个都是打印流。
  

        public class PrintWriterDemo {
            public static void main(String[] args) throws IOException{
                BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));               
                PrintWriter pw = new PrintWriter(new FileWriter("E:\\a.txt"),true);               
                String len = null;
                while((len=buf.readLine())!=null){
                        pw.println(len);
                }
                pw.close();
                  buf.close();
           }
        }

        public class PrintStreamDemo {
            public static void main(String[] args) throws IOException{
                FileReader fr = new FileReader("E:\\a.txt");
                        BufferedReader buf = new BufferedReader(fr);
                        PrintStream ps = new PrintStream("E:\\aa.txt");
                               
                                String len = null;
                                while((len=buf.readLine())!=null){
                                        ps.println(len);
                                }
                                ps.close();
                                buf.close();
           }
        }




2、newLine()

        newLine()设置字符输出流，指定输出的缓冲区的时候可以用到，该类是BufferedWriter，该类也提供了写入一个行分隔符的方法：newLine()；而与之想对应的还有一个从字符输入  

  流中读取文本读取的缓冲区，该类是BufferedReader，该类也提供了读取一行的方法：readLine() 。下面我就举其中一个例子。


        public class BuffereWriteDemo {
                public static void main(String args[]) {
                        
                BufferedWriter buff=null;
                        try {
                                FileWriter write = new FileWriter("D:\\BuffereWriteDemo.txt");
                                buff = new BufferedWriter(write);
                                buff.write("为了提高字符写入流的效率，加入缓冲区");
                                buff.newLine();// 换行符
                                buff.flush();
                               
                       
                        } catch (IOException e) {
                                e.printStackTrace();
                        }finally{
                                if(buff!=null){
                                        try {
                                                buff.close();
                                        } catch (IOException e) {
                                                e.printStackTrace();
                                        }
                                }
                        }
       
                }
        }


3、write()

        write()字符流(Writer)跟字节流(OutputStream)都用到，但前提必须该操作必须是输出的。从字面可以了解到字符流的write()只能操作字符，字节流的write()只能操作字节。这里

我就介绍OutputStreamWriter这个子类，这个比较特效，它是字符流通向字节流的桥梁（可以查找API文档）。具体的操作可以看下面一小段程序：

public class OutputStreamWriterDemo {

        public static void main(String[] args) {
                BufferedReader buf = new BufferedReader(
                                new InputStreamReader(System.in));
                OutputStreamWriter out = null;
                String len = null;
                try {
                        out = new OutputStreamWriter(new FileOutputStream("E:\\a.txt"));
                        len = buf.readLine();
                        out.write(len);
                        out.flush();
                } catch (IOException e) {

                        e.printStackTrace();
                } finally {
                        try {
                                if (buf != null) {
                                        buf.close();
                                }
                                if (out != null) {
                                        out.close();
                                }
                        } catch (IOException e) {

                                e.printStackTrace();
                        }
                }

        }

}


至于楼主说它们的异同我这里就不解释了，楼主能把上面的看懂了估计也能明白。建议楼主充分理由API文档

1，newLine()实现中有一条out.write(lineSeparator)，同时newLine()是换行的意思；
2，println(str)方法比write方法中多输出了一个lineSeparator字符;
     例如：pringln("BeiJing");等价于 print("BeiJing");print('\n');
3，所有OutputStream和Writer的派生类都有一个基本的，能写入单个或byte数组的write( )方法；

Java基础IO流的简单总结 “实践是检验真理的唯一标准”，希望可以对大家有小小的帮助。

一 IO流的三种分类方式：
              1.按照流向来分：
                     输入流：只能从中读取字节数据，不能向其写出数据
                     输出流：只能向其写入字节数据，不能从中读取数据                  
              2.按照流所处理的数据类型划分：可分为：
                     字节流：用于处理字节数据。
                     字符流：用于处理Unicode字符数据。         
              3.按照格式可以分为：
                     节点流(低级流)可以从向一个特定的IO设备(如磁盘，网络)读写数据的流。
                     处理流(高级流)：可以对一个已存在的流的连接和封装，通过所封装的流的功能实现数据读写功能的流。

二 IO流的四大抽象类：               
             1.常见InputStream类（读数据）
                     -低级
                            InputStream
                             FileInputStream
                             ByteArrayInputStream
                             PipedInputStream
                     -高级
                            DataInputStream
                            BufferedInputStream
             2.常见OutputStream（写数据）
                     -低级
                            OutputStream
                            FileOutputStream
                            ByteArrayOutputStream
                            PipedOutputStream
                     -高级
                            DataOutputStream
                            BufferedOutputStream         
             3.常见的Reader类
                     -低级
                            CharArrayReader
                            StringReader
                            PipedReader
                            FileReader
                     -高级
                            BufferedReader
                            InputStreamReader
                            LineNumberReader     
             4.常见的Writer相关类
                     -低级
                            CharArrayWriter
                            StringWriter
                            PipedWriter
                            FileWriter
                     -高级
                            BufferedWriter
                            OutputStreamWriter
                            PrintWriter         
              注意：所有高级流都不能直接IO设备（磁盘或网络等）进行直接的交互，必须建立在低级流的基础之上。
三 缓冲流：
       BufferedReader   -Reader
       BufferedWriter
       BufferedInputStream  -InputStream
       BufferedOutputStream
      
      缓冲流输入流 支持其父类的mark()和reset()方法。
       mark()方法用于“标记”当前位置，就像加入了一个书签，可以使reset()方法返回这个标记重新读取数据。
       BufferedReader  -readLine()  --以r或n分隔
       BufferedWriter  -newLine()  --写入一个行分隔符
       BufferInputStream和BufferedOutputStream平时很少用到。
四 InputStream的基本方法
       1.int read() throws IOException  读取一个字节以整数形式返回，如果返回-1证明读到文件的末尾。
            int read(byte[] buffer) throws IOException 将数据读入一个字节数组，同时返回读取的字节数。
            int read(byte[] buffer,int offset,int length) throws IOException 将数据读入一个字节数组，放到数组的offset指定的位置开始，并用length来制定读取的最大字节数。
       2.void close() throws IOException 关闭流释放内存资源
       3.int available()返回可以ong种读取的字节数。
       4.long skip(long n)在输入流中跳过n个字节，将实际跳过的字节数返回
       5.boolean markSupported() 判断流是否支持标记功能。
       6.void mark(int readlimit)在支持标记的输入流的当前位置设置一个标记。
       7.void reset() 返回到流的上一个标记。注意必须支持标记功能。
五 OutputStream的基本方法
       1.viod write(int b)throws IOException向输出流写入一个字节数据。
          void write(byte[] buffer)
          void write(byte[] buffer,int offset,int length)
       2.viod flush() 将输出流中缓冲的数据全部写出到目的地。
       3.void close() 关闭流
六 Writer的基本方法
       1.void write(int c) throws IOException 向输出流中写入一个字符数据。
          void write(char[] buffer) 将字符数组buffer中的字符写入到流中
          void write(char[] buffer,int offset,int length) 将字符数组buffer中从offset开始的length个字符写入到流中
          void write(String str) throws IOException 将一个字符串中的字符写入到输出流
          void write(String str,int offset,int length)将一个字符串从offset开始的length个字符写入到输出流
       4.void flush() 将输出流中缓冲的数据全部写出到目的地。
七 Reader的基本方法
       1.int read() 读取一个字符以整数形式返回，如果返回-1证明已到流的末尾。
          int read(char[] buffer)将从流中读出的字符放到字符数组buffer中，返回读出的字符数。
          int read(char[] buffer,int offset,int length) 将读出的字符放到字符数组的指定offset开始的空间，每次最多读出length个字符。
       2.void close();
       3.skip(long n)
       4.void mark(int readlimit)
       5.void reset()
八 访问文件类
       1.FileInputStream和FileOutputStream继承基类用于向文件中输入输出字节
       2.FileReader和FileWriter继承基类用于向文件中输入输出字符。
              注意：a.输出流在构造函数第二个参数可以设置true，表示在文件的末尾进行追加写入。

                       b.此类流会抛出FileNotFoundException异常。
九 转换流：主要作用是将字节流转换为字符流。
       1.InputStreamReader需要和InputStream套接
       2.OutputStreamWriter需要和OutputStream套接
十 数据流与字节数组流：
       1.数据流主要为实现可以存取java原始数据类型，如long，boolean等
              数据流是字节流
       2.DataInputStream需要和InputStream套接
          DataOutputStream需要和OutputStream套接
       3.DataInputStream的方法：
              -readBoolean();readInt();read...
              -readUTF()网络传输常用方法，读一个Unicode字符串
       4.DataOutputStream方法与DataInputStream中的方法对应
       5.此构造函数等于已可以往一个字节数组里输入内容
              ByteArrayOutputStream baos = new ByteArrayOutputStream();
              此方法为获取一个字节数组方法返回字节数组
              baos.toByteArray();
              此方法获取字节数组占了多少字节
              new ByteArrayInputStream(byte[]).available()
十一 Print流
       1.Print流只有输出流没有输入流，PrintWriter和PrintStream分别针对字符和字节
       2.提供print和println方法，用于多种数据类型的输出。
       3.输出操作不会抛出异常。
       4.PrintWriter和PrintStream可设置自动刷新功能。
十二 Object流
       1.序列化，用于直接将Object写入或者读出。
       2.static和transient关键字修饰的属性是不能被序列化的。
       3.需要序列化的类必须实现Serializable接口或者Externalizable
       4.方法：
              -writeObject(Object obj)
              -Object readObject();
              若想得到Object的原始类型，需要通过强制转型。               
十三 特殊的文件流(RandomAccessFile)
       1.RandomAccessFile是一种特殊的文件流，可以用它在文件的任何地方查找或插入数据
       2.RandomAccessFile同时实现了DataInput和DataOutput接口，所以可以用它来读写文件
       3.构造器
              -RandomAccessFile(File file,String mode)
              -RandomAccessFile(String file,String mode)
       4.利用RandomAccessFile来追加文件内容：
              RandomAccessFile rf1 = new RandomAccessFile(c1.txt,rw);
              rf1.seek(rf1.length());
              rf1.writeBytes(str + n);  此处若想输入的文本看起来是换行的，需加nr
              rf1.close();           
              随机文件这块同学们可以自己试试。
十四 读取文件匹配流
1.       FileInputStreamFileOutputStream
2.       FileReaderFileWriter
3.       BufferedReaderPrintWriter
......资料还在进一步整理，请期待......