Java基础——IO流File类-Properties-PrinWriter-合并流-切割文件

最新推荐文章于 2023-02-03 10:11:48 发布
最新推荐文章于 2023-02-03 10:11:48 发布
阅读量934 收藏 1
点赞数
分类专栏： java笔记 文章标签： IO流File类 Properties PrinWriter 合并流 切割文件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mr_yangxianfa__/article/details/45629663
版权


1.   IO流File类

概述

用来将文件或者文件夹封装成对象,方便对文件与文件夹的属性信息进行操作。

File对象可以作为参数传递给流的构造函数。

弥补了流对象的不足，流对象能操作文件，不能操作文件夹，文件属性信息，只能操作数据，File能操作文件夹，文件属性信息

File常见方法

1，创建。

    boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。

    和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。

 

    boolean mkdir():创建文件夹。只能创建一级

    boolean mkdirs():创建多级文件夹。

2，删除。

    boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回false。

    void deleteOnExit();在程序退出时删除指定文件。

 

 

3，判断。

    canExecute():文件是否执行

    boolean exists() :文件是否存在.

    isFile():是否是文件

    isDirectory();文件是否是目录

    isHidden();文件是否是隐藏文件

    isAbsolute();是否为绝对路径，对象存在即可判断，文件不存在也能判断。

 

4，获取信息。

    getName():返回由此抽象路径名表示的文件或目录的名称。

    getPath():将此抽象路径名转换为一个路径名字符串；对象存在即可判断，文件不存在也能判断

    getParent():返回此抽象路径名父目录的路径名字符串；

 

    getAbsolutePath() ：返回此抽象路径名的绝对路径名字符串。对象存在即可判断，文件不存在也能判断。

    long lastModified() ：返回此抽象路径名表示的文件最后一次被修改的时间。

    long length() ：返回由此抽象路径名表示的文件的长度。

 

renameTo(File dest):重新命名此抽象路径名表示的文件。

File方法运用实例：

class FileDemo 

{

    publicstaticvoid main(String[] args) throws IOException

    {

       method_5();

    }

 

    publicstaticvoid method_5()

    {

       File f1 = new File("c:\\Test.java");

       File f2 = new File("d:\\hahah.java");

 

       sop("rename:"+f2.renameTo(f1));

    }

 

    publicstaticvoid method_4()

    {

       File f = new File("file.txt");

 

       sop("path:"+f.getPath());

       sop("abspath:"+f.getAbsolutePath());

       sop("parent:"+f.getParent());//该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。

                                //如果相对路径中有上一层目录那么该目录就是返回结果。

    }

    

    publicstaticvoid method_3()throws IOException

    {

       File f = new File("d:\\java1223\\day20\\file2.txt");

 

       //f.createNewFile();

 

       //f.mkdir();

 

 

       //记住在判断文件对象是否是文件或者目录时，必须要先判断该文件对象封装的内容是否存在。

       //通过exists判断。

       sop("dir:"+f.isDirectory());//只有对象还没有文件生成时，返回为false

       sop("file:"+f.isFile());//只有对象还没有文件生成时，返回为false

 

       sop(f.isAbsolute());

    }

 

 

    publicstaticvoid method_2()

    {

       File f = new File("file.txt");

 

       //sop("exists:"+f.exists());

 

       //sop("execute:"+f.canExecute());//是否能执行

 

       //创建文件夹

       File dir = new File("abc\\kkk\\a\\a\\dd\\ee\\qq\\aaa");

 

       sop("mkdir:"+dir.mkdirs());

    }

    

    publicstaticvoid method_1()throws IOException

    {

       File f = new File("file.txt");

//     sop("create:"+f.createNewFile());

       //sop("delete:"+f.delete());

       

    }

 

    //创建File对象

    publicstaticvoid consMethod()

    {

       //将a.txt封装成file对象。可以将已有的和未出现的文件或者文件夹封装成对象。此时还不会生成文件

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

 

       //File f2 = new File("c:\\abc\\b.txt");

       //将目录，文件分成两个参数传递，文件可变化

       File f2 = new File("c:\\abc","b.txt");

 

 

       File d = new File("c:\\abc");

       File f3 = new File(d,"c.txt");

 

       sop("f1:"+f1);//封装什么，打印的就是什么

       sop("f2:"+f2);

       sop("f3:"+f3);

 

       File f4 = new File("c:"+File.separator+"abc"+File.separator

 

+"zzz"+File.separator+"a.txt");//separator:与系统有关的默认名称分隔符（跨平台分隔符），为了方便，它被表示为一个字符串。

 

 

    }

 

    publicstaticvoid sop(Object obj)

    {

       System.out.println(obj);

    }

} 

 

File方法运用实例(文件列表)：

listRoots():列出可用的文件系统根。

 

String[] list() :返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录（包含隐藏的），对象不能封装指定文件。只返回名称(开发中不常用)

 

String[] list(FilenameFilter filter) ：返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。

 

boolean endsWith(String suffix) ：测试此字符串是否以指定的后缀结束。

 

File[] listFiles()：返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。返回对象，可以有更多的操作(但只能返回当前目录中的文件，子目录的不可以)

 请看下面示例：

 

<span style="color:#000000;">import java.io.*;

 

class  FileDemo2

{

    publicstaticvoid main(String[] args) 

    {

       File dir = new File("c:\\");

       File[] files = dir.listFiles();

 

       for(File f : files)

       {

           System.out.println(f.getName()+"::"+f.length());

       }      

    }

 

    //返回指定后缀名的文件

    publicstaticvoid listDemo_2()

    {

       File dir = new File("d:\\java1223\\day18");

 

       //FilenameFilter类只有一个方法，用匿名内部类

       String[] arr = dir.list(new FilenameFilter()

       {

           publicboolean accept(File dir,String name)

           {

 

//            /System.out.println("dir:"+dir+"....name::"+name);

              /*

              if(name.endsWith(".bmp"))

                  return true;

              else

              return false;

              */

            return name.endsWith(".bmp");

           }

       });

 

 

       System.out.println("len:"+arr.length);

       for(String name : arr)

       {

           System.out.println(name);

       }

    }

 

    publicstaticvoid listDemo()

    {

       File f = new File("c:\\abc.txt");//对象不能封装指定文件

 

       String[] names = f.list();//调用list方法的file对象必须是封装了一个目录。该目录还必须存在。

       for(String name : names)

       {

           System.out.println(name);

       }

    }

    publicstaticvoid listRootsDemo()

    {

       File[] files = File.listRoots();

 

       for(File f : files)

       {

           System.out.println(f);

       }

    }

}

</span>

 

File运用实例(利用递归方法列出目录下所有内容)：

列出指定目录下文件或者文件夹，包含子目录中的内容。

也就是列出指定目录下所有内容。

 

因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。

在列出过程中出现的还是目录的话，还可以再次调用本功能。

也就是函数自身调用自身。

这种表现形式，或者编程手法，称为递归。

 

递归执行过程(无返回值)：

 

递归执行过程(有返回值)：

 

递归要注意：

1，限定条件。

 

2，要注意递归的次数。尽量避免内存溢出。

 如：

 

import java.io.*;

 

class test

{

    publicstaticvoid main(String[] args) 

    {

       File dir = new File("d:\\testdir");

       //showDir(dir,0);

 

       //toBin(6);

       //int n = getSum(8000);

       //System.out.println("n="+n);

 

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

       //method();

    }

    publicstatic String getLevel(int level)

    {

       StringBuilder sb = new StringBuilder();

       sb.append("|--");

       for(int x=0; x<level; x++)

       {

           //sb.append("|--");

           sb.insert(0,"|  ");

 

       }

       return sb.toString();

    }

 

    publicstaticvoid showDir(File dir,int level)

    {

       

       System.out.println(getLevel(level)+dir.getName());

 

       level++;

       File[] files = dir.listFiles();

       for(int x=0; x<files.length; x++)

       {

           if(files[x].isDirectory())//判断是否为目录

              showDir(files[x],level);

           else

              System.out.println(getLevel(level)+files[x]);

       }

    }

 

 

    publicstaticint getSum(int n)//利用递归求和，当递归次数太大，会出现内存(栈内存)溢出

    {

       if(n==1)

           return 1;

       return n+getSum(n-1);

    }

 

    publicstaticvoid toBin(int num)//利用递归求二进制数

    {

       if(num>0)

       {

           toBin(num/2);

           System.out.println(num%2);

       }

    }

 

    publicstaticvoid method()//内存溢出

    {

       method();

    }   

}

File运用实例(利用递归方法删除带内容的目录)：

/*

删除一个带内容的目录。

删除原理：

在window中，删除目录从里面往外删除的。

 

既然是从里往外删除。就需要用到递归。

 

在java中删除的文件是不走回收站的

 

*/

import java.io.*;

class  RemoveDir

{

    publicstaticvoid main(String[] args) 

    {

       

       File dir = new File("d:\\testdir");

       removeDir(dir);

    }

 

    publicstaticvoid removeDir(File dir)

    {

       File[] files = dir.listFiles();

       

       for(int x=0; x<files.length; x++)//循环结束后，只剩下空目录

       {

           if(files[x].isDirectory())

              removeDir(files[x]);

           else

              System.out.println(files[x].toString()+":-file-:"+files

 

[x].delete());//删除文件

       }

 

       System.out.println(dir+"::dir::"+dir.delete());//删除文件夹

    }

 

} 

File运用实例(创建java文件列表)

/*

练习

将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。

建立一个java文件列表文件。

 

思路：

1，对指定的目录进行递归。

2，获取递归过程所有的java文件的路径。

3，将这些路径存储到集合中。可打印，可写出

4，将集合中的数据写入到一个文件中。

 

*/

publicclass  test

{

    publicstaticvoid main(String[] args)throws IOException

    {

       

       //将文件路径存储到集合中

       File file = new File("D:/myjava_workspace/test_heima");

       List<File> list=new ArrayList<File>();

       filetolist(file,list);

       System.out.println(list.size());

       

       //写出数据

       File f = new File(file,"path.txt");//将文件写到读取的目录中

       writetofile(list,f.toString());

       

    }

    //将路径存储到集合中

    publicstaticvoid filetolist(File dir,List<File> list)

    {

       File f[]=dir.listFiles();

       for(File files:f)

       {

           if(files.isDirectory())

              filetolist(files,list);

           else

           {

              if(files.getName().endsWith(".java"))

              {

                  list.add(files);

              }

           }

              

       }

    }

    //将集合中的数据写到文件中

    publicstaticvoid writetofile(List<File> list,String s)throws IOException

    {

       BufferedWriter buf = null;

       try

       {

           buf=new BufferedWriter(new FileWriter(s));

           //取出集合中的数据

           for(File file:list)

           {

              String str=file.getAbsolutePath();

              buf.write(str);

              buf.newLine();

              buf.flush();             

           }

       }catch(IOException e)

       {

           thrownew RuntimeException("写出异常");

       }

       finally

       {

           try

           {

              if(buf!=null)

                  buf.close();

           }

           catch(IOException e2)

           {

              thrownew RuntimeException("写出关闭异常");

           }

       }

       

    }

} 

2.   IO流Properties

1.   概念

Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。

 

Properties是hashtable的子类。

也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。

 

是集合中和IO技术相结合的集合容器。

 

Set<String> stringPropertyNames():返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。

 

getProperty(String key) :用指定的键在此属性列表中搜索属性。

void load(InputStream inStream) :从输入流中读取属性列表（键和元素对）。void store(OutputStream out, String comments): 以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。Comments是注释信息，不会被properties加载，开头用#标识；

 

2.   特点

可以用于键值对形式的配置文件。

那么在加载数据时，需要数据有固定格式：键=值。

 

3.   怎么使用?

class PropertiesDemo 

{

    publicstaticvoid main(String[] args) throws IOException

    {

       //method_1();

       loadDemo();

    }

 

    publicstaticvoid loadDemo()throws IOException

    {

       Properties prop = new Properties();

       FileInputStream fis = new FileInputStream("info.txt");

 

       //将流中的数据加载进集合。

       prop.load(fis);

 

       prop.setProperty("wangwu","39");//只是将数据加到属性集中，没有写入流中

 

       FileOutputStream fos = new FileOutputStream("info.txt");

 

       prop.store(fos,"haha");

 

    //  System.out.println(prop);

       prop.list(System.out);//将属性列表输出到指定的输出流。

 

       fos.close();

       fis.close();

    }

    //演示，如何将流中的数据存储到集合中。

    //想要将info.txt中键值数据存到集合中进行操作。

    /*

       1,用一个流和info.txt文件关联。

       2，读取一行数据，将该行数据用"="进行切割。

       3，等号左边作为键，右边作为值。存入到Properties集合中即可。

 

    */

    publicstaticvoid method_1()throws IOException//此方法每读取一行就要去硬盘读取，效率低，用load()

    {

       BufferedReader bufr = new BufferedReader(new FileReader("info.txt"));

 

       String line = null;

       Properties prop = new Properties();

 

       while((line=bufr.readLine())!=null)

       {

           String[] arr = line.split("=");

           ///System.out.println(arr[0]+"...."+arr[1]);

           prop.setProperty(arr[0],arr[1]);

       }

       bufr.close();

 

       System.out.println(prop);

    }

 

//  设置和获取元素。

    publicstaticvoid setAndGet()

    {

       Properties prop = new Properties();

 

       prop.setProperty("zhangsan","30");

       prop.setProperty("lisi","39");

 

//     System.out.println(prop);

       String value = prop.getProperty("lisi");

       //System.out.println(value);

           

       prop.setProperty("lisi",89+"");

 

       Set<String> names = prop.stringPropertyNames();

       for(String s : names)

       {

           System.out.println(s+":"+prop.getProperty(s));

       }

    }

}

 

4.   什么时候使用?

将流中的数据存储到集合中时；

记录软件运行次数时，用到的配置文件需要键值对的形式存在(map+io -->properties.)；

 

3.   IO流Properties练习-记录程序运行次数

用于记录应用程序运行次数。

如果使用次数已到，那么给出注册提示。

 

很容易想到的是:计数器。

可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。

可是随着该应用程序的退出，该计数器也在内存中消失了。

 

下一次在启动该程序，又重新开始从0计数。

这样不是我们想要的。

 

程序即使结束，该计数器的值也存在。

下次程序启动在会先加载该计数器的值并加1后在重新存储起来。

 

所以要建立一个配置文件。用于记录该软件的使用次数。

 

该配置文件使用键值对的形式。

这样便于阅读数据，并操作数据。

 

键值对数据是map集合。

数据是以文件形式存储，使用io技术。

那么map+io -->properties.

 

配置文件可以实现应用程序数据的共享。

请看如下程序：

import java.io.*;

import java.util.*;

class  RunCount

{

    publicstaticvoid main(String[] args) throws IOException

    {

       Properties prop = new Properties();

 

       File file = new File("count.ini");//先把文件封装成对象

       if(!file.exists())

           file.createNewFile();

       

       FileInputStream fis = new FileInputStream(file);

 

       prop.load(fis);

       

 

       int count = 0;

       String value = prop.getProperty("time");

       

       if(value!=null)

       {

           count = Integer.parseInt(value);

           if(count>=5)

           {

              System.out.println("您好，使用次数已到，拿钱!");

              return ;//结束程序

           }

 

       }

 

       count++;

 

       prop.setProperty("time",count+"");

 

       FileOutputStream fos = new FileOutputStream(file);

 

       prop.store(fos,"");

 

       fos.close();

       fis.close();

       

    }

}

 

properties和XML的区别？

properties：

name=zhangsan

age=20

 

xml:

<persons>

    <person id="001">

       <name>zhagnsan</name>

       <age>30</age>

       <address>bj</address>

    </person>

    <person>

       <name

    </person>

</persons>

用工具dom4j:dom for java

4.   IO流PrintWriter

 

1.   概念

打印流：

该流提供了打印方法，可以将各种数据类型的数据都原样打印。

 

PrintWriter(OutputStream out, boolean autoFlush):通过现有的 OutputStream 创建新的PrintWriter。autoFlush- boolean 变量；如果为 true，则 println、printf 或 format 方法将刷新输出缓冲区

 

2.   特点

字节打印流：

PrintStream

构造函数可以接收的参数类型：

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

 

字符打印流：

PrintWriter

构造函数可以接收的参数类型：

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

4，字符输出流，Writer。

3.   怎么使用？

class  test

{

    publicstaticvoid main(String[] args) throws IOException

    {

       BufferedReader bufr = 

           new BufferedReader(new InputStreamReader(System.in));

       

       //用PrintWriter代替BufferedWriter

       PrintWriter out = new PrintWriter(new FileWriter("c:/a.txt"),true);//将文件封装成流，就可以刷新缓冲区。如果直接写到文件中，则要等打印流关闭才能写入文件

 

       String line = null;

 

       while((line=bufr.readLine())!=null)

       {

           if("over".equals(line))

              break;

           out.println(line.toUpperCase());

           //out.flush();

       }

 

       out.close();

       bufr.close();

    }

4.   什么时候使用？

 

将键盘输入数据直接利用打印流保存到文件中

 

5.   IO流SequenceInputStream-合并流

publicclass  test

{

    publicstaticvoid main(String[] args) throws IOException

    {

       Vector<FileInputStream> v = new Vector<FileInputStream>();

       

       v.add(new FileInputStream("c:/1.txt"));

       v.add(new FileInputStream("c:/2.txt"));

       v.add(new FileInputStream("c:/3.txt"));

       

       Enumeration<FileInputStream> en = v.elements();  

       //将多个流合并成一个大流

       SequenceInputStream se = new SequenceInputStream(en);//传进多个流，需传进Enumeration对象

       //将大流的数据写出到文件

       FileOutputStream fos = new FileOutputStream("c:/4.txt");

       byte by[] = newbyte[1024];

       int len=0;

       while((len=se.read(by))!=-1)

       {

           fos.write(by,0,len);

       }

       fos.close();

       se.close();

    }

} 

6.   IO流切割，合并文件

 

1.   概念

将一个读取流切割成多个读取流

 

2.   怎么使用？

 

class SplitFile 

{

    publicstaticvoid main(String[] args) throws IOException

    {

       //splitFile();

       merge();

    }

 

    //合并文件

    publicstaticvoid merge()throws IOException

    {

       //将碎片文件存储到LIST集合中，Vector的效率低

       ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();

 

       for(int x=1; x<=3; x++)

       {

           al.add(new FileInputStream("c:\\splitfiles\\"+x+".part"));

       }

       

       //将LIST集合数据用枚举法取出来，创建一个匿名内部类

       final Iterator<FileInputStream> it = al.iterator();

 

       Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()

       {

           publicboolean hasMoreElements()

           {

              return it.hasNext();

           }

           public FileInputStream nextElement()

           {

              return it.next();

           }

       };

 

       SequenceInputStream s = new SequenceInputStream(en);

 

       FileOutputStream fos = new FileOutputStream("c:\\splitfiles\\0.bmp");

 

       byte[] buf = newbyte[1024];

 

       int len = 0;

 

       while((len=sis.read(buf))!=-1)

       {

           fos.write(buf,0,len);

       }

 

       fos.close();

       sis.close();

    }

    //切割文件

    publicstaticvoid splitFile()throws IOException

    {

       FileInputStream fis =  new FileInputStream("c:\\1.bmp");

 

       FileOutputStream fos = null;

 

       byte[] buf = newbyte[1024*1024];

 

       int len = 0;

       int count = 1;

       while((len=fis.read(buf))!=-1)

       {

           fos = new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");

           fos.write(buf,0,len);

           fos.close();

       }

       fis.close();  

    }

}

3.   什么时候使用？

当文件太大时，需分段写入硬盘。

 

 

 

Y走路带风
关注
专栏目录
ESP32-C3入门教程——导读
小康师兄
09-13 5万+
一、环境篇 ESP32-C3入门教程 环境篇①——简单介绍与软硬件准备 ESP32-C3入门教程 环境篇②——Windows开发环境准备 ESP32-C3入门教程 环境篇③——VS Code IDE快速入门 二、基础篇 ESP32-C3入门教程 基础篇①——GPIO口控制 ESP32-C3入门教程 基础篇②——PWM控制 ESP32-C3入门教程 基础篇③——ADC输入 ESP32-C3入门教程 基础篇④——串口通信 ESP32-C3入门教程 基础篇⑤——SPI通信 ESP32-C3入门教程 基础篇⑥——I
Java - PrintWriter 类
伊特
07-10 499
Java.lang.Object     Java.io.Writer         Java.io.PrintWriter 实现的接口：Closeable, Flushable, Appendable, AutoCloseable
IO流——(15)File类——文件的切割与合并
真香号
01-09 522
生活中我们经常遇到这样一类问题，就是对于文件上传有大小的限制，尤其是对某个论坛上传附件时，由于论坛的服务器容量比较小，所以在用户上传文件时，进行限制。 比如论坛限制上传大小为2M，我需要上传5M的文件，那么就可以进行将5M文件切割为3个2M大小的碎片文件，上传以后进行合并。接下来就演示文件的切割与合并。 一、切割文件： 1、首先实现需要明确需要切割文件的位置。 2...
PrintWriter类详解
热门推荐
Dream_Ryoma的博客
07-01 9万+
1.java.io.PrintWriter是java中很常见的一个类，该类可用来创建一个文件并向文本文件写入数据。可以理解为java中的文件输出，java中的文件输入则是java.io.File。2.常用的构造方法：注：java.io.PrintWriter的构造方法并不局限于一下范例，java.io.PrintWriter构造方法的参数也可以是字节流。因为本篇文章主要讲关于文件的操作，所以参数是...
Java打印流（PrintStream/PrintWriter）
最新发布
墨辰JC的博客
02-03 7374
打印流是输出信息最方便的类，注意包含字节打印流PrintStream和字符打印流PrintWriter。打印流提供了非常方便的打印功能，可以打印任何类型的数据信息，例如：小数，整数，字符串。而且永远不会抛出IOException异常。一般使用PrintWriter，灵活性更强打印流只有输出流，没有输入流，主要用于打印，会把你的信息指定到一个位置（显示器或文件等）
PrintWriter 输出流中文乱码问题
孤云独去闲的博客
10-15 6116
PrintWriter 输出流中文乱码问题
java基础教程----精华版
09-22
- Java的`java.io`包提供了丰富的类处理输入输出，如FileInputStream, FileOutputStream, BufferedReader, BufferedWriter等。 - 使用流（Stream）模型处理数据，分为字节流和字符流，以及输入流和输出流。 6. **...
Java基础——IO详解
qq_45821255的博客
03-21 2998
本文介绍了IO流的具体内容，包括总结了常用的IO流，把它们做成了体系图。根据体系图分别介绍了它们的使用场景...
JavaIO流复习与巩固--FileDescriptor与File
CSDN文章已停止维护，后续文章会在 https://blog.hufeifei.cn 持续更新
07-18 3577
FileDescriptor FileDescriptor，顾名思义：“文件描述符”，用来表示开放文件、开放套接字。这个概念来自于*nux文件系统，Linux继承Unix “一切皆文件” 的概念： 文件类型 标记符 普通文件 - 目录文件（directory） d 字符设备文件（character） c 块设备文件（block） ...
java用输入流创建数据文件_Java实现文件写入——输入输出流（IO流）
weixin_33764069的博客
02-13 5657
输入输出含义和意义：输入和输出功能是Java对程序处理数据能力的提高，java以流的形式处理数据。流是一组有序的数据序列，根据操作类型，分为输入流和输出流。程序从输入流读取数据，向输出流写入数据。Java是面向对象的程序语言，每一个数据流都是一个对象，它们提供了各种支持“读入”与“写入”操作的流类。Java的输入输出功能来自java.io 包中的InputStream类、OutputStream类...
简述PrintWriter中write()方法和print()方法的区别？
m_wise的博客
04-25 1万+
1. print方法可以将各种类型的数据转换成字符串的形式输出。 2. 重载的write方法只能输出字符、字符数组、字符串等与字符相关的数据。 最终都是重写了抽象类Writer里面的write方法 简而言之:当输出内容有中文时就用write();  eg: PrintWriter wr = response.getWriter(); wr.write("上次访问的时候
PrintWriter的使用
thedarkclouds的博客
12-29 4万+
PrintWriter的使用 java.io.PrintWriter 具有自动行刷新的缓冲字符输出流，特点是可以按行写出字符串，并且可以自动行刷新。 java.io.BufferedWriter是缓冲字符输出流，内部有缓冲区可以进行块写操作提供效率， 而PrintWriter就是通过连接它实现的缓冲功能（PW的很多构造方法内部自动连接它）。 PW支持两个直接对文件写操作的构造方法： * ...
Servlet处理用户请求和响应(二)
凯耐的博客
09-15 3905
(一)浏览器访问Servlet过程示意图1.Servlet主要作用就是处理客户端请求和响应。浏览器每一次请求Servlet,服务器Tomcat在调用Service()方法之前，都会创建两个对象，分别是HttpServletRequest对象和HttpServletResponse对象。3.HttpServletResponse的作用：封装HTTP响应消息。(二)HttpServletRequest对
学习PrintWriter类
zsw2zkl的专栏
01-18 8万+
java.io包 1）首先先知道它的八种构造方法，但怎么记住这八种呢？我们都知道PrintWriter是一种过滤流，也叫处理流。也就是能对字节流和字符流进行处理，所以它会有： PrintWriter(OutputStream out)  根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter。 PrintWriter(Writer out)  创建不带自动行刷新
OutputStream与PrintWriter的使用与区别
weixin_33726318的博客
02-21 669
1.OutputStream 使用步骤： 获取输出流 设置中文 将字符串转换成字节数组 调用outputStream.write() 这里只贴出doGet方法的内容： protected void doGet(HttpServletRequest request, HttpServletResponse respons...
java中讲讲PrintWriter的用法，举例？
mark_to_win的专栏
04-30 8209
1.2 PrintWriter的用法 马 克-to-win：PrintWriter和PrintStream类似，只不过PrintStream是针对字节流的，而PrintWriter是针对字符流的。例：1.2.1import java.io.*;public class TestMark_to_win { public static void main(String args[]) thr...
【Java基础】 PrintWriter和BufferedWriter的区别
weixin_33796205的博客
07-07 1437
最近研究Java Socket编程，经常要对字节输出流和字符输出流打交道，所以在这梳理PrintWriter和BufferedWriter的用法和区别BufferedWriter:将文本写入字符输出流，缓冲各个字符从而提供单个字符，数组和字符串的高效写入。通过write()方法可以将获取到的字符输出，然后通过newLine()进行换行操作。BufferedWriter中的字符...
out.print()与out.write()区别
WALK ON
01-04 841
在servlet中: PrintWriter out = response.getWriter(); 请问out.print()方法与out.write()方法有什麽区别? 共同点：两者都不刷新页面，只在原来的页面写数据.最终都是重写了抽象类Writer里面的write方法. print方法可以将各种类型的数据转换成字符串的形式输出。重载的write方法只能输出字符、字符数组、字符串...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值