Java学习之路0723(九)(I/O流、File文件类)

I/O流

在I/O流中所有输入流都是抽象类InputStream(字节输入流)或抽象类Reader(字符输入流)的子类;而所有的输出流都是抽象类OutputStream(字节输出流)或Writer(字符输出流)的子类。

File 类

File类是Java.io包中唯一代表磁盘文件本身的对象。文件的创建通过File的构造方法来实现

例如:File file=new File(“d://1.txr”);

File类的常见方法

这里写图片描述

获取文件信息
FileInputStream与FileOutputStream类都是用来操作磁盘文件

构造方法有:
FileInputStream(String name);使用给定的文件名创建对象,较为简单
FileInputstream(File file);使用File对象创建一个FileInputStream对象

FileOutputStream是用来向文件写入信息用的

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

import javax.naming.NamingException;

public class Test {
    public static void main(String[] args)  {
        File ss=new File("d://22.txt");
        try {
            InputStream file=new FileInputStream(ss);
            int index = 0;
            index = file.read(array);
            System.out.println(file.read(array));
            while(index!=-1){
                index=file.read(array);
                System.out.println(new String(array));      
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            System.out.println("未创建文件");
            e.printStackTrace();
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        }



}

运行结果:
北京有点大!
我想去看看!
这里写图片描述

FileInputStream与InputStream的区别

FileInputStream是普通类,InputStream是抽象类,前者是文件字节输入,后者是字节输入流,前者是后者的实现类。InputStream必须有非抽象类实现才能使用。

遍历寻找符合条件的文件

遍历文件需直到file的几种实现方法
listFile():返回一个抽象路径名数组,这些路径名表示的目录中满足指定过滤器的文件和目录。
isDirectory():测试此抽象路径名表示的文件名是否是一个目录
getAbsolutePath():返回此路径名的绝对路径名字符串。
getNaem():返回此抽象路径名表示的文件或目录的名称。

import java.io.File;
import java.io.FileInputStream;
public class Test1 {
    public static void main(String[] args) {
        bianli("d://");//遍历寻找文件
    }
    public static void bianli(String path){
        File file=new File(path);
        File[] filearray=file.listFiles();
        for (int i = 0; i < filearray.length; i++) {
            if (filearray[i].isDirectory()) {
                bianli(filearray[i].getAbsolutePath());
            }else{
                if (filearray[i].getName().endsWith(".MP4")) {
                    System.out.println(filearray[i].getAbsolutePath());
                }

            }
        }
    }
}

这里写图片描述

文件过滤信息

package jie0723;

import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;

public class ZipFilenameFilter implements FilenameFilter{

    @Override
    public boolean accept(File dir, String name) {
        // TODO Auto-generated method stub
        return name.endsWith(".png");
    }

}
import java.io.File;
public class Test1 {
    public static void main(String[] args) {
        guolv();//文件过滤
    }
public static void guolv(){
        ZipFilenameFilter files=new ZipFilenameFilter();
        File file=new File("d://文档");
        File[] filearray=file.listFiles();
        for(int i=0;i<filearray.length;i++){
            System.out.println(filearray[i].getAbsolutePath());
        }
    }
}   

这里写图片描述

读取文件中内容

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;


public class Test1 {
    public static void main(String[] args) {
    readFile();//读取文件
    }
public static void readFile(){
        File file=new File("d://22.txt");
        FileInputStream in=null;
        byte[] array=new byte[1024];
        try {
            in=new FileInputStream(file);
                int i=in.read(array);
                while(i!=-1){
                    System.out.println(new String(array));
                    i=in.read(array);
                }

        } 
         catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
    }
        finally{
            try {
                in.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

这里写图片描述

利用BufferesReader读取文件内容

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class Test1 {
    public static void main(String[] args) {
    bufferedreadfile();//利用Bufferedreader读取文件内容
    }

public static void bufferedreadfile(){
        File file=new File("d://22.txt");
        FileInputStream fileIn;
        try {
            fileIn = new FileInputStream(file);
            InputStreamReader in=new InputStreamReader(fileIn);
            BufferedReader br=new BufferedReader(in);
            String s=br.readLine();
            while(s!=null){
                System.out.println(s);
                s=br.readLine();
            }
            br.close();
            in.close();
            fileIn.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

这里写图片描述

向文件中写入信息

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
    writerFile();//写入文件
    }
public static void writerFile(){
        Scanner scanner=new Scanner(System.in);
        String s=scanner.next();
        File file=new File("d://2.txt");
        if(!(file.exists())){
            try {
                file.createNewFile();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        FileOutputStream out=null;
        try {
            out=new FileOutputStream(file);
            out.write(s.getBytes());
            out.flush();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

这里写图片描述

利用BufferedWriter写入文件信息

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {
    buffeerWriterFile();//利用BufferedWritre写入文件内容
    }

public static void buffeerWriterFile(){
        File file=new File("d://11.txt");
        FileOutputStream fileWriter;
        try {
            fileWriter = new FileOutputStream(file);
            OutputStreamWriter outwriter=new OutputStreamWriter(fileWriter);
            BufferedWriter br=new BufferedWriter(outwriter);
            br.write("该去吃中午饭!");
            br.newLine();
            br.write("吃完饭去睡午觉!");
            outwriter.flush();
            fileWriter.flush();
            br.close();
            outwriter.close();
            fileWriter.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

这里写图片描述

复制文件信息

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

public class Test1 {
    public static void main(String[] args) {
    copyFile("d://1.txt","d://22.txt");//将一个文件的内容复制到另一个文件中
    }

public static void copyFile(String soure,String copy){
        File sourefile=new File(soure);
        File copyfile=new File(copy);
        try {
            FileInputStream in=new FileInputStream(sourefile);
            FileOutputStream out=new FileOutputStream(copyfile);
            byte[] array=new byte[1024];
            int i=0;
            while(i!=-1){
                i=in.read(array);
                if(i!=-1){
                    out.write(array, 0, i);
                }
            }
            in.close();
            out.flush();
            out.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

运行前的
这里写图片描述
运行后的
这里写图片描述

利用PrinterWriter写入文件信息

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;

public class Test1 {
    public static void main(String[] args) {
        printStream();//printStream的使用
    }
public static void printStream(){
        File file=new File("D://22.txt");
        try {
            PrintStream pw=new PrintStream(file);
            System.setOut(pw);
            System.out.println("北京有点大!我想去看看!");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

这里写图片描述

利用DOM解析XML文件

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

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class Test1 {
    public static void main(String[] args) {
        analysis();//利用DOM解析XML
    }

public static void analysis(){
        File file=new File("d://xml.txt");
        DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
        try {
            //从DOM工厂会得DOM解析器
            DocumentBuilder db=dbf.newDocumentBuilder();
            //解析XML文档,得到一个Document,即DOM树
            Document d=db.parse(file);
            //得到所有的节点信息列表
            NodeList weathers=d.getElementsByTagName("Weather");
            for(int i=0;i<weathers.getLength();i++){
                Node weather=weathers.item(i);
                for (Node node=weather.getFirstChild();node!=null;node=(Node) node.getNextSibling()) {
                    if (node.getNodeType()==Node.ELEMENT_NODE) {
                        System.out.println(node.getNodeName());
                        if (node.getFirstChild()!=null) {
                            System.out.println(node.getFirstChild().getNodeValue());

                        }
                    }

                }
            }
        } catch (ParserConfigurationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SAXException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

city
北京
status1
多云
status2
雷阵雨
figure1
duoyun
figure2
leizhenyu
direction1
无持续风向
direction2
无持续风向
power1
≤3
power2
≤3
temperature1
32
temperature2
21
ssd
8
tgd1
28
tgd2
28
zwx
1
ktk
3
pollution
3
xcz
5
zho
diy
fas
chy
1
zho_shuoming
暂无
diy_shuoming
暂无
fas_shuoming
暂无
chy_shuoming
短袖衫、短裙、短裤、薄型T恤衫、敞领短袖棉衫
pollution_l
轻度
zwx_l
最弱
ssd_l
较热
fas_l
暂无
zho_l
暂无
chy_l
薄短袖类
ktk_l
较适宜开启(制冷)
xcz_l
不适宜
diy_l
暂无
pollution_s
对空气污染物扩散无明显影响
zwx_s
紫外线最弱
ssd_s
户外活动不适宜在中午前后展开。
ktk_s
比较适宜开启空调
xcz_s
洗车后当日有降水、大风或沙尘天气,不适宜洗车
gm
1
gm_l
低发期
gm_s
环境温度较高,要提防长时间在空调环境中引发的空调病;
yd
5
yd_l
不适宜
yd_s
出现下雨天气时会伴有雷声,不适宜户外运动;
savedate_weather
2015-07-23
savedate_life
2015-07-23
savedate_zhishu
2015-07-23
udatetime
2015-07-23 08:10:12

利用SAX解析XML文件

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.SAXException;

public class Test1 {
    public static void main(String[] args) {
    saxFile();//利用SAX解析文档
    }
public static void saxFile(){
        SAXParserFactory factory=SAXParserFactory.newInstance();
        File file=new File("d://xml.txt");
        try {
            SAXParser parser=factory.newSAXParser();
            MySAXHandler handler=new MySAXHandler();
            parser.parse(file, handler);
        } catch (ParserConfigurationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SAXException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class MySAXHandler extends DefaultHandler{

    @Override
    public void startDocument() throws SAXException {
        // TODO Auto-generated method stub
        System.out.println("开始文档");
        super.startDocument();
    }

    @Override
    public void endDocument() throws SAXException {
        // TODO Auto-generated method stub
        System.out.println("结束文档");
        super.endDocument();
    }



    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        // TODO Auto-generated method stub
        System.out.println("开始标签"+qName);
        super.startElement(uri, localName, qName, attributes);
    }

    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        // TODO Auto-generated method stub
        System.out.println("结束标签"+qName);
        super.endElement(uri, localName, qName);
    }

    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        // TODO Auto-generated method stub
        String s=new String(ch,start,length);
        if (!s.equals(" ")) {
            System.out.println("标签内容:"+s);

        }
        super.characters(ch, start, length);

    }

}

开始文档
开始标签Profiles

开始标签Weather

开始标签city
北京
结束标签city

开始标签status1
多云
结束标签status1

开始标签status2
雷阵雨
结束标签status2

开始标签figure1
duoyun
结束标签figure1

开始标签figure2
leizhenyu
结束标签figure2

开始标签direction1
无持续风向
结束标签direction1

开始标签direction2
无持续风向
结束标签direction2

开始标签power1
≤3
结束标签power1

开始标签power2
≤3
结束标签power2

开始标签temperature1
32
结束标签temperature1

开始标签temperature2
21
结束标签temperature2

开始标签ssd
8
结束标签ssd

开始标签tgd1
28
结束标签tgd1

开始标签tgd2
28
结束标签tgd2

开始标签zwx
1
结束标签zwx

开始标签ktk
3
结束标签ktk

开始标签pollution
3
结束标签pollution

开始标签xcz
5
结束标签xcz

开始标签zho
结束标签zho

开始标签diy
结束标签diy

开始标签fas
结束标签fas

开始标签chy
1
结束标签chy

开始标签zho_shuoming
暂无
结束标签zho_shuoming

开始标签diy_shuoming
暂无
结束标签diy_shuoming

开始标签fas_shuoming
暂无
结束标签fas_shuoming

开始标签chy_shuoming
短袖衫、短裙、短裤、薄型T恤衫、敞领短袖棉衫
结束标签chy_shuoming

开始标签pollution_l
轻度
结束标签pollution_l

开始标签zwx_l
最弱
结束标签zwx_l

开始标签ssd_l
较热
结束标签ssd_l

开始标签fas_l
暂无
结束标签fas_l

开始标签zho_l
暂无
结束标签zho_l

开始标签chy_l
薄短袖类
结束标签chy_l

开始标签ktk_l
较适宜开启(制冷)
结束标签ktk_l

开始标签xcz_l
不适宜
结束标签xcz_l

开始标签diy_l
暂无
结束标签diy_l

开始标签pollution_s
对空气污染物扩散无明显影响
结束标签pollution_s

开始标签zwx_s
紫外线最弱
结束标签zwx_s

开始标签ssd_s
户外活动不适宜在中午前后展开。
结束标签ssd_s

开始标签ktk_s
比较适宜开启空调
结束标签ktk_s

开始标签xcz_s
洗车后当日有降水、大风或沙尘天气,不适宜洗车
结束标签xcz_s

开始标签gm
1
结束标签gm

开始标签gm_l
低发期
结束标签gm_l

开始标签gm_s
环境温度较高,要提防长时间在空调环境中引发的空调病;
结束标签gm_s

开始标签yd
5
结束标签yd

开始标签yd_l
不适宜
结束标签yd_l

开始标签yd_s
出现下雨天气时会伴有雷声,不适宜户外运动;
结束标签yd_s

开始标签savedate_weather
2015-07-23
结束标签savedate_weather

开始标签savedate_life
2015-07-23
结束标签savedate_life

开始标签savedate_zhishu
2015-07-23
结束标签savedate_zhishu

开始标签udatetime
2015-07-23 08:10:12
结束标签udatetime

结束标签Weather

结束标签Profiles
结束文档

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值