Java语言实验6 常用类和输入输出流
java输入输出流实验报告总结
java输入输出流实验报告总结Java输入输出流是Java中非常重要的概念,也是Java程序设计的基础。
在Java 程序中,输入输出流用于处理与设备之间的数据传输,例如键盘、鼠标、文件等。
Java的输入输出流主要包含两种类型:字节流和字符流。
字节流以字节为最小读写单位,而字符流以字符为最小读写单位。
Java的输入流有很多种类型,例如:InputStream、ByteArrayInputStream、FileInputStream等。
这些输入流的共同特点是读取外部数据到程序中。
Java的输出流也有多种类型,例如:OutputStream、ByteArrayOutputStream、FileOutputStream等。
这些输出流的共同特点是将程序中的数据输出到外部。
下面将以实验报告的形式进行总结,详细介绍Java输入输出流的原理和使用方法。
实验一:字节流输入输出1. 实验目的:掌握字节流输入输出的基本使用方法。
2. 实验内容:编写一个程序,实现从文件中读取数据,然后将数据输出到另一个文件中。
3. 实验步骤:a. 创建一个输入流对象,用于读取原始文件的数据。
b. 创建一个输出流对象,用于将读取到的数据输出到目标文件中。
c. 循环读取输入流中的数据,直到读取到文件末尾。
d. 将读取到的数据写入输出流中。
e. 关闭输入流和输出流。
4. 实验结果:成功读取原始文件中的数据,并将数据输出到目标文件中。
实验二:字符流输入输出1. 实验目的:掌握字符流输入输出的基本使用方法。
2. 实验内容:编写一个程序,实现从键盘输入文字,然后将文字输出到屏幕上。
3. 实验步骤:a. 创建一个字符输入流对象,用于读取键盘输入的文字。
b. 创建一个字符输出流对象,用于将读取到的文字输出到屏幕上。
c. 循环读取输入流中的文字,直到读取到换行符。
d. 将读取到的文字写入输出流中。
e. 关闭输入流和输出流。
4. 实验结果:成功从键盘输入文字,并将文字输出到屏幕上。
Java的输入与输出流(实验报告)
成都大学实验报告实验项目名称Java的输入与输出流一、实验目的:1. 理解I/O流的概念,掌握其分类2. 掌握文本文件读写、二进制文件读写二、实验内容(包括源程序及相关说明):1. 分别使用FileWriter 和BufferedWriter 往文件中写入10万个随机数,比较用时。
源代码如下:(1)import java.io.*;public class Ex1_1 {public static void main(String[] args) throws IOException{long t=System.currentTimeMillis();FileWriter fw =new FileWriter("d:\\Ex1.txt");for(int i=1;i<=100000;i++){fw.write((int)(Math.random()*10000)+" \n");}fw.close();t=System.currentTimeMillis()-t;System.out.println("The elapsed: "+t);}}(2)import java.io.*;public class Ex1_1 {public static void main(String[] args) throws IOException{long t=System.currentTimeMillis();BufferedWriter fw=new BufferedWriter(new FileWriter("d:\\Ex1.txt"));for(int i=1;i<=100000;i++){fw.write((int)(Math.random()*10000)+"\n");}fw.close();t=System.currentTimeMillis()-t;System.out.println("The elapsed: "+t);}}2. 生成一个html文件,使其能显示2的幂次(0~9)的表格如下:代码如下:import java.io.*;public class Ex1_1 {public static void main(String[] args) throws IOException{BufferedWriter bw=new BufferedWriter(new FileWriter("d:\\Ex2.html"));bw.write("<table border=1 align=center width=200 height=250>");bw.newLine();bw.write("<tr><td align=center>Power of 2<td align=center>Value</tr>");for(int i=0;i<=9;i++){bw.write("<tr><td align=center>"+i+"<td align=center>"+Math.pow(i, 2)+"</tr>");}bw.write("</table>");bw.newLine();bw.close();}}3. 在文本文件bigbook.txt中包含有很长篇幅的英语短文,编写程序要求统计文件的所有短文中包含英文字母“A”的个数,并显示统计的时间。
java 输入输出流实验
}
catch(Exception exp){}
clip.start();
voiceWord.setEnabled(true);
}
}6.实验指导
(1)BufferedReader对象调用readLine方法可读取文件中的一行内容。
catch(IOException exp){}
}
}
public void run()
{
voiceWord.setEnabled(false);
try{
if(clip!=null)
{
clip.close();
}
clip=AudioSystem.getClip();
File voiceFile=new File(showWord.getText().trim()+".wav");
add(pCenter,BorderLayout.CENTER);
menubar=new JMenuBar();
menu=new JMenu("帮助");
help=new JMenuIter("关于学单词");
help.addActionListener(this);
menu.add(help);
menubar.add(menu);
FileReader类是Reader的子类,该类创建的对象称为文件字符输入流。文件字符输入流按字符读取文件中的数据。FileReader流按顺序读取文件,只要不关闭流,每次调用读取方法时FileReader流就会依次读取文件中其余的内容,直到文件的末尾或流被关闭。
JAVA——输入、输出流(File类)
JAVA——输⼊、输出流(File类)⼀、File类1、File类的对象主要⽤来获取⽂件本⾝的⼀些信息,例如⽂件所在的⽬录、⽂件的长度或⽂件读写权限等,不涉及对⽂件的读写操作。
2、创建⼀个File对象的构造⽅法有3个:File(String filename);//filename:⽂件名File(String directoryPath,String filename);//directoryPath:⽂件路径File(File dir,String filename);//dir:⼀个⽬录3、⽂件的属性经常使⽤File类的下列⽅法获取⽂件本⾝的信息package Test;import java.io.File;import java.io.IOException;/*File类//获取⽂件的名字public String getName() {return null;}//判断⽂件是否可读public boolean canRead(){return true;}//判断⽂件是否可被写⼊public boolean canWrite(){return true;}//判断⽂件是否存在public boolean exists(){return true;}//获取⽂件的长度(单位是字节)public void length(){}//获取⽂件的绝对路径public String getAbsolutePath(){return null;}//获取⽂件⽗母录public String getParent(){return null;}//判断是否是⼀个普通⽂件,⽽不是⽬录public boolean ifFile(){return true;}//判断⽂件是否是⼀个⽬录public boolean isDirectory(){return true;}//判断⽂件是否是隐藏⽂件public boolean isHidden(){return true;}//获取⽂件的最后修改时间public Object lastModified(){return null;}*///以下是例⼦:public class Test_1 {public static void main(String[] args) {String path = "E:\\soft";File f = new File(path,"E:\\soft");System.out.println(f.getName()+"是可读的吗:"+f.canRead());System.out.println(f.getName()+"的长度:"+f.length());System.out.println(f.getName()+"的绝对路径:"+f.getAbsolutePath());File file = new File(path,"b.txt");System.out.println("在当前⽬录下创建新⽂件"+file.getName());if(!file.exists()){try{file.createNewFile();System.out.println("创建成功");} catch (IOException e) {e.printStackTrace();}}}}4、⽬录例⼦:1package Test;23import java.io.File;45public class dir {6public static void main(String[] args) {7 File dirFile = new File(".");8 FileAccept fileAccept = new FileAccept() ;9 fileAccept.setExtendName("java");10 String filename[] = dirFile.list(fileAccept);11for(String name:filename){12 System.out.println(name);13 }14 }15 }1package Test;23import java.io.File;4import java.io.FilenameFilter;56public class FileAccept implements FilenameFilter { 7private String extendName;8public void setExtendName(String s){9 extendName = "."+s;10 }11public boolean accept(File dir, String name){12return name.endsWith(extendName);13 }14 }。
对java中的输入/输出的总结(字节流,字符流)
1,先是关于字节流import java.io.*;public class SimpleIO {/**System 类包含一些有用的类字段和方法。
它不能被实例化。
字段摘要static PrintStream err “标准”错误输出流。
static InputStream in “标准”输入流。
static PrintStream out “标准”输出流。
字段不是一个类,它是一个类的static属性out是System类的一个属性,而它的类型是PrintStreamPrintStream是一个类,它有个方法是println().*/public static void main(String[] args) {// TODO Auto-generated method stubchar c;System.out.println("请输入一个字符:");try{c=(char)System.in.read();System.out.println("你输入的字符是:"+c);}catch(IOException e){System.out.println("产生异常");}}}2,关于字符流的考虑。
import java.io.*;public class SimpleIOs {/**ng.Object继承者 java.io.Reader继承者 java.io.InputStreamReader构造方法摘要InputStreamReader(InputStream in)创建一个使用默认字符集的 InputStreamReader。
InputStreamReader(InputStream in, Charset cs)创建使用给定字符集的 InputStreamReader。
InputStreamReader(InputStream in, CharsetDecoder dec)创建使用给定字符集解码器的 InputStreamReader。
Java的输入输出流
字节输入/输出流
读取数据的方法 int read() throws IOException ; int read(byte[] b) throws IOException ;
注意:read方法若返回-1,则表明当前读取位置已经 int read(byte[] b,int off,int len) throws 到达流的末尾。 IOException ; 例如:int n; while((n=fis.read())!=-1){ //数据处理 }
public static final char separator;
文件类和文件的随机访问
文件的随机访问类
RandomAccessFile类可以对文件进行随机读写 操作。 创建一个RandomAccessFile对象
RandomAccessFile(File file,String r:只读;rw:可读可写 例如:File file=new File(“d:\\a.txt”); mode) ;
• FileInputStream/FileOutputStream
字节输入/输出流
InputStream类及其子类
InputStream类是抽象类,不能直 接生成对象,它是所有字节输入流类的 父类。该类提供了输入处理的基本方法, 注意:该类中的大多数方法都可能抛出IOException异常, 它的子类一般都重写这些方法。
因此调用它们时,应放在try…catch块中,捕获和处理 IOException异常。
public void mark(int readlimit); public void reset();
字节输入/输出流
OutputStream类及其子类
OutputStream类是抽象类,不能直 接生成对象,它是所有字节输出流类的 父类。该类提供了输出处理的基本方法, 注意:该类中的大多数方法都可能抛出IOException异常, 它的子类一般都重写这些方法。
JAVA6输入输出
5 运行可执行文件
第6章 输入/输出
File构造方法举例
import java.io.*; public class E{
public static void main(String[] args){ File f1=new File(“D:\\3000\\a.java”);//假设不存在该文件 File f2=new File("c:\\1000"); System.out.println(f1.getName()+"的长度:"+f1.length()); System.out.println(f1.getName()+"绝对路径:
第6章 输入/输出
ObjectInputStream类和ObjectOutputStream类
ObjectInputStream类和ObjectOutputStream类提供了读 写对象的方法
public ObjectInputStream (InputStream in) public ObjectOutputStream (OutputStream out) 只有实现了Serializable接口的类产生的对象才可以被写到文件中。 如果类中有类类型的成员变量,则必须保证该成员变量对应的类 也是可序列化的。
public FileReader(File filename) public FileWriter(File filename)
第6章 输入/输出
import java.io.*;
public class E{
public static void main(String[] args){ char a[]="四月十二日10点发起总攻".toCharArray(); //转换为字符数组 int n=0,m=0;
JAVA课件 LESSON6 JAVA的输入输出流
第六讲 Java的输入输出流1课前思考如何读取硬盘上的某个文件内容? 2. 如何知道文件系统中有哪些目录和子目 录? 3. 如何往硬盘上写文件? 4. 如何接收键盘输入?1.2java.io包字节流从InputStream和OutputStream派生出来的一系 列类,以字节(byte)为基本处理单位。
字符流从Reader和Writer派生出的一系列类,以16位的 Unicode码表示的字符为基本处理单位。
3流在计算机中,“流”的概念是1984年由C语言 第一次引入的。
“流”可以看作是一个流动 的数据缓冲区,数据从数据源流向数据目 的地。
4字节流InputStream、OutputStream FileInputStream、FileOutputStream PipedInputStream、PipedOutputStream ByteArrayInputStream、 ByteArrayOutputStream FilterInputStream、FilterOutputStream DataInputStream、DataOutputStream BufferedInputStream、BufferedOutputStream5字符流Reader、Writer InputStreamReader、 OutputStreamWriter FileReader、FileWriter CharArrayReader、CharArrayWriter PipedReader、PipedWriter FilterReader、FilterWriter BufferedReader、BufferedWriter StringReader、StringWriter6其它文件处理 File、RandomAccessFile; 接口 DataInput、DataOutput、ObjectInput、 ObjectOutput;7I/O处理的类层次FileInputStream PipedInputStream ByteArrayInputStream InputStream SequenceInputStream StringBufferInputStream FilterInputStream ObjectInputStream ObjectInputBufferedInputStream LineNumberInputStream PushbackInputStream DataInputStream DataInputRandomAccessFile8I/O处理的类层次ObjectOutput ObjectOutputStream FileOutputStream OutputStream PipedOutputStream ByteArrayOutputStream File FileDescriptor StreamTokenizer FilterOutputStream RandomAccessFileDataOutput DataOutputStream BufferedOutputStream PrintStreamFileNameFilter9InputStream从流中读取数据int read( ); int read( byte b[ ] ); int read( byte b[ ], int off, int len ); int available( ); long skip( long n );10InputStream关闭流close( );使用输入流中的标记void mark( int readlimit ); void reset( ); boolean markSupported( );11OutputStream输出数据void write( int b ); void write( byte b[ ] ); void write( byte b[ ], int off, int len );flush( )刷空输出流,并输出所有被缓存的字 节。
Java中的输入流与输出流
Java中的输⼊流与输出流⼀、流的概念在Java中,流是从源到⽬的地的字节的有序序列。
Java中有两种基本的流——输⼊流(InputStream)和输出流(OutputStream)。
根据流相对于程序的另⼀个端点的不同,分为节点流和过滤流。
(1)节点流:以特定源如磁盘⽂件、内存某区域或者线程之间的管道为端点的构造输⼊输出流,是⼀种基本的流。
(2)过滤流:以其他已经存在的流为端点构造的输⼊输出流。
根据流中的数据单位分为字节流和字符流。
(1)字节流:流中的数据是以8位字节为单位进⾏读写,以InputStream和OutputStream为基础类。
(2)字符流:流中的数据是以16为字符为单位进⾏读写,以Reader和Writer为基础类。
⼆、字节流InputStream和OutputStream是字节流的两个顶层⽗类,提供了输⼊流类和输出流类的通⽤API。
1、输⼊字节流InputStream基本⽅法:(1)基本读⽅法;: int read() int read(byte[] b) int read(byte[] b,int off,int len)(2) 关闭流:void close()(3) 返回输⼊流中还有多少可读字节 int available()(4) 跳过指定字节 long skip(long n)(5) 回读数据 boolean markSupported() void Mark(int readlimt) void reset()2 、输出字符流OutputStream基本⽅法:(1)基本写⽅法:void write(int c) void write(byte[] b) void write(byte[] b,int off,int len)(2) 关闭流:void close()(3)q强制输出:void flush()三、字符流Reader和Writer是字符流的顶层⽗类,字符流能够处理Unicode字符集中的所有字符。
java输入输出流实验报告总结】
java输入输出流实验报告总结】Java输入输出流实验报告总结在本次实验中,我们学习了Java的输入输出流的概念和用法。
输入输出流是Java中用于处理输入和输出操作的工具。
通过输入流,我们可以将外部数据输入到程序中进行处理,通过输出流,我们可以将程序中的数据输出到外部文件或设备上。
在本次实验中,我们通过几个具体的示例来探索输入输出流的不同用法和特性,以期更好地理解和掌握它们的使用。
首先,我们学习了如何使用FileInputStream和FileOutputStream这两个类来进行字节流的输入和输出操作。
这两个类分别用于从指定文件中读取字节数据和将字节数据写入到指定文件中。
通过这两个类,我们可以实现文件的拷贝、移动、创建等功能。
同时,我们还了解了如何使用BufferedInputStream和BufferedOutputStream这两个类来提高读写效率。
这两个类可以通过缓存数据来减少对底层系统的IO操作次数,从而提高读写速度。
接下来,我们学习了如何使用FileReader和FileWriter这两个类进行字符流的输入和输出操作。
这两个类与字节流的输入输出类似,但它们处理的是字符数据。
通过这两个类,我们可以读取和写入文本文件中的字符数据。
我们还了解了字符编码和字符集的概念,并学习了如何使用InputStreamReader和OutputStreamWriter来进行字符流和字节流之间的转换。
除了字节流和字符流,我们还学习了对象流的使用。
对象流可以将Java 对象直接写入到文件中,也可以从文件中读取Java对象。
这在处理一些复杂的对象数据时非常有用。
我们通过使用ObjectInputStream和ObjectOutputStream这两个类,实现了对象的读写操作。
需要注意的是,被写入和读取的对象必须实现Serializable接口,否则会抛出NotSerializableException异常。
在实验过程中,我们还探索了如何使用标准输入输出流。
Java程序设计-Java-输入输出
假如流对象不再被引用,Java旳垃圾回收机制也会隐式
地关闭它
4
6.1.1 I/O流旳概念
输入流 为了从信息源获取信息,程序打开一种输入流,程序可 从输入流读取信息
输出流 当程序需要向目的位置写信息时,便需要打开一种输出 流,程序经过输出流向这个目的位置写信息
5
6.1.1 I/O流旳概念
25
6.2.1 写文本文件
打开C盘根目录下旳Hello.txt文件
换行有些问题
每次运营这个程序,都将删除已经存在旳”Hello.txt”文件 ,创建一种新旳同名文件
FileWriter旳构造措施有五个,本例是经过一种字符串指 定文件名来创建
FileWriter类旳write措施向文件中写入字符
23
6.2.1 写文本文件
FileWriter类 创建一种磁盘文件 关闭一种磁盘文件 write() 措施 捕获I/O异常 BufferedWriter 类
24
6.2.1 写文本文件
在C盘根目录创建文本文件Hello.txt,并往里写入 若干行文本
import java.io.*; class WriteTxtFile { public static void main (String[] args ) throws IOException {
11
阴影部分为节点流
12
6.1.2 预定义旳I/O流类概述
面对字节旳流
数据源或目旳中具有非字符数据,必须用字节流来 输入/输出
一般被用来读写诸如图片、声音之类旳二进制数据 绝大多数数据是被存储为二进制文件旳,世界上旳
文本文件大约只能占到2%,一般二进制文件要比具 有相同数据量旳文本文件小得多。
实验6-java输入输出流操作
实验6:java输入输出流操作实验目的:1.了解字节流和字符流2.了解流的分类实验步骤:一.Java输出流操作1.求2-200间的素数,将结果通过输出流保存在“D:\\prime.dat”文件中;2.源代码如下:3.编写上述代码,编译运行代码,查看程序执行结果。
二.Java输入流操作1.通过输入流操作,将上题中保存到“D:\\prime.dat”中的素数读出来,并在控制台打印出来。
2.源代码如下:3.编写上述代码,编译运行代码,查看程序执行结果。
三.Java输出流和输入流综合应用通过Java输出流和输入流操作练习,实现将“D:\\prime.dat”文件复制到“D:\\newprime.dat”。
「提示」先将prime.dat中的内容通过输入流读取进来,再将读取到的内容通过输出流输出到目标文件中。
四、编程题编写一个程序:要求输入5个学生的成绩(0-100的整数),并将这5个数保存到文件“data.txt”中。
然后再编写一个程序:从文件“data.txt”中读取这5个学生的成绩,计算并输出它们的平均数,然后再按从小到大的顺序输出这5个学生的成绩。
【提示:可以使用DataOutputStream类将5个整数成绩保存到“data.txt”中,使用DataInputStream类将5个成绩读出来。
其中类DataOutputStream的构造方法如下:DataOutputStream(FileOutputStresam fos)而类FileOutputStream的构造方法如下FileOutputStream(String filename)DataOutputStream类有方法writeInt(int x),此方法的功能是将整数x写入当前流中。
类DataInputStream的构造方法如下:DataInputStream(FileInputStream fis)而类FileInputStream的构造方法如下:FileInputStream(String filename)类DataInputStream有方法readInt(),此方法的功能是读取当前流中的整数。
java 实验六 输入输出 实验报告
实验六输入输出实验目标:1. 理解I/O流的概念与机制,掌握其分类;2. 掌握文本文件的读写、二进制文件的读写、处理流类的概念和用法、对象序列化;3. 掌握File类,压缩流类和RandomAccessFile类的使用;4. 遇到I/O方面的问题,能够自行查阅API稳当解决。
实验任务:1、课本198页习题2,并使用这个程序来copy自己硬盘的大文件(任何格式都可以,如电影,最好大于500MB),看看需时多少?提示:首先需要看懂课本文本文件例子,再模仿修改,关键不同在下面三点。
(1)文本文件复制中是每次读一行,而在二进制文件复制中是自行指定读取多少字节的数据,写法如下。
private boolean copyFiles() { //这个私有方法用来拷贝文件,如无异常返回true try {byte[] buf = new byte[512];int num = source.read(buf); //从源文件读取数据while (num > 0) { // 只要能够读取数据,就继续读dest.write(buf, 0, num); //向目标文件写入num = source.read(buf); //从源文件读取数据}}catch (IOException iox) {System.out.println("Problem reading or writing");return false;}return true;}-------------------以上请注意byte[] buf = new byte[512],说明每次只读512字节,请更换每次读取的缓冲字节数,比如byte[] buf = new byte[5120],每次读5mb左右,请试试copy 效率回有所提高吗?请截图回答。
(2)需时多少可以通过CPU时钟计算,方法见下。
Calendar start=Calendar.getInstance();new BinaryFileCopy().copy(args[0], args[1]);Calendar end=Calendar.getInstance();long time=end.getTimeInMillis()-start.getTimeInMillis();System.out.println("copy时间为"+time+"毫秒");(3)因为这个程序执行需要输入参数的,所以在eclipse里面不能直接执行的,要到dos界面去执行,这里命令行的写法就有点讲究了。
1java掌握字符输入、输入输出流以及缓冲输入、输出的使用方法的实验总结
1java掌握字符输入、输入输出流以及缓冲输入、输出的使用方法的实验总结在Java中,我们可以使用字符输入流和输出流来读写字符数据。
而缓冲输入流和输出流是在字符流的基础上增加了缓冲功能,可以提高读写的效率。
字符输入流的常用类有FileReader和InputStreamReader。
FileReader可以用于读取文件中的字符数据,InputStreamReader可以用于读取字节流转换成字符流。
字符输出流的常用类有FileWriter和OutputStreamWriter。
FileWriter可以用于将字符数据写入文件,OutputStreamWriter 可以用于将字符流转换成字节流。
缓冲输入流的常用类有BufferedReader。
BufferedReader可以用于读取字符流,并且提供了按行读取的功能。
缓冲输出流的常用类有BufferedWriter。
BufferedWriter可以用于写入字符流,并且提供了缓冲功能。
在实际应用中,我们经常需要从用户输入中读取字符数据。
可以使用Scanner类来实现字符输入功能。
Scanner类提供了多种方法来读取不同类型的输入。
实验总结:1. 字符输入流和输出流以及缓冲输入流和输出流都是用于字符数据的读写操作,可以方便地处理各种文本文件。
2. 在使用字符输入流和输出流时,需要注意字符编码的设置,以免出现乱码问题。
3. 使用缓冲输入流和输出流可以提高读写的效率,特别是处理大文件时尤为重要。
4. 在从用户输入中读取字符数据时,可以使用Scanner类的各种方法,根据需要进行不同类型的数据读取。
5. 在进行输入输出操作时,一定要注意资源的释放,及时关闭流对象,避免出现内存泄漏的情况。
JAVA程序设计_输入输出流_101 File类、输入输出流的分类_
输入输出流1模块导航←File类←输入/输出流的分类◆输入流和输出流◆节点流和处理流◆字节流和字符流文件处理◆输入输出(I/O)处理中,最常见的是对文件的操作◆java.io包中有关文件处理的类有:◆File、FileInputStream、FileOutputStream…◆这里先讲解File类。
File类←java.io.File类◆主要用于文件和目录的创建、查找和删除等操作。
◆File类的对象是文件和目录路径名的抽象表示形式,即File类的对象代表一个文件或一个目录(文件夹)的路径,而不是文件本身。
◆File 类不能读写文件内容本身,如果需要访问文件内容本身,则需要使用输入/输出流。
←通过以下构造方法创建一个File对象。
←File类的构造方法一:File(String path):通过将path给定路径名字符串转换成抽象路径名来创建一个新 File 实例。
←注意:(1)路径可以是相对路径,也可以绝对路径;(2)路径可以是存在,也可以是不存在;(3)创建File对象,只是把字符串路径封装为File对象,不考虑路径的真假情况。
File类的构造方法二:File(String parent, String child) :将两个字符串(父路径,子路径),拼接之后形成的路径封装成一个File对象。
参数:把路径分为了两部分优点:父路径和子路径,可以单独书写,使用起来非常灵活;父路径和子路径都可以变化例如:File file = new File("C:\\","a.txt");System.out.println(file); //c:\a.txtFile类←File类的构造方法三:File(File parent, String child):通过给定的父抽象路径名和子路径名字符串创建一个新的File实例。
←优点:◆①父路径和子路径都可以变化◆②父路径是File类型,可以使用File的方法对路径进行一些操作,再使用路径创建对象例如:File parent = new File("c:\\");File file = new File(parent,"hello.java");System.out.println(file);//c:\hello.javaFile类常用方法●文件属性测试boolean exists( ):测试当前File对象所指的文件是否存在boolean canWrite( ) :测试当前文件是否可写boolean canRead( ) :测试当前文件是否可读boolean isFile( ) :测试当前文件是否是文件(不是目录)boolean isDirectory( ) :测试当前文件是否是目录●获取文件或目录的信息:String getName( ) :得到一个文件的名称(不包括路径)String getPath( ) :得到一个文件的路径名String getAbsolutePath( ) :得到一个文件的绝对路径名String getParent( ) :得到一个文件的上一级目录名File类常用方法普通文件信息long lastModified( ):得到文件最近一次修改的时间long length( ):得到文件的长度,以字节为单位。
Java中的输入输出流操作详解
Java中的输入输出流操作详解Java是一种面向对象的编程语言,广泛应用于各种领域。
在Java中,输入输出流是非常重要的概念,它提供了一种机制来实现程序与外部世界的交互。
本文将详细介绍Java中的输入输出流操作,包括输入流和输出流的概念、常用的输入输出流类以及它们的用法。
一、输入流和输出流的概念在Java中,输入流和输出流是用于在程序与外部环境之间传输数据的通道。
输入流用于从外部环境(如文件、网络等)读取数据到程序中,而输出流则用于将程序中的数据写入到外部环境中。
输入流和输出流是Java IO库中的核心概念,通过它们可以实现数据的读取和写入。
二、常用的输入流类1. InputStreamInputStream是所有输入流类的抽象基类,它定义了读取字节的基本方法。
常用的InputStream的子类包括FileInputStream、ByteArrayInputStream和DataInputStream等。
FileInputStream用于从文件中读取数据,ByteArrayInputStream 用于从字节数组中读取数据,DataInputStream用于从输入流中读取基本数据类型。
2. ReaderReader是所有字符输入流类的抽象基类,它定义了读取字符的基本方法。
常用的Reader的子类包括FileReader和BufferedReader等。
FileReader用于从文件中读取字符,BufferedReader用于从字符输入流中读取字符并缓冲输入。
三、常用的输出流类1. OutputStreamOutputStream是所有输出流类的抽象基类,它定义了写入字节的基本方法。
常用的OutputStream的子类包括FileOutputStream、ByteArrayOutputStream和DataOutputStream等。
FileOutputStream用于将数据写入文件,ByteArrayOutputStream用于将数据写入字节数组,DataOutputStream用于将基本数据类型写入输出流。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
源代码:
packaget2;
ng.*;
classStringBufferExample
{
publicstaticvoidmain(Stringargs[ ])
{
StringBufferstr=newStringBuffer("ABCDEFG");
intn1=Integer.parseInt(s6);//将s6转化成int型数据
doublen2=Double.parseDouble(s7);//将s7转化成double型数据
doublen=n1+n2;
System.out.println(n);
Strings8=newString("ABCDEF");
}
}
}
运行结果:
3、日期类
任务一:Date和Calendar的使用
(1)内容
编写一个Java应用程序用户从键盘输入两个日期,程序将判断两个日期的大小关系以及两个日期之间的间隔天数。
(2)
源代码:
packaget3;
importjava.util.*;
classDateExample
{
publicstaticvoidmain(Stringargs[ ])
一、实验目的
1、掌握String类的常用方法。
2、掌握StringBuffer类的常用方法。
3、掌握Java提供的日期类Date和Calendar。
4、掌握字符输入、输出流用法。
5、掌握缓冲流的用法。
二、实验内容及步骤
1、String类的使用
(1)内容
编写一个java应用程序,判断两个字符串是否相同,判断字符串的前缀、后缀是否与某个字符串相同,以及按字典比较来比较两个字符串的大小关系,进行字符串检索,创建子字符串,将数字型字符串转化为熟悉,将字符串放到数组中,用字符串数组创建字符串等。
longtimeOne=calendar.getTimeInMillis() ;// calendar表示的时间转换成毫秒。
calendar.set(yearTwo,monthTwo,dayTwo);//将calendar的时间设置为yearTwo年monthTwo月dayTwo日
longtimeTwo=calendar.getTimeInMillis();// calendar表示的时间转换成毫秒
如输入:2011
4
输出结果为:
2011- 4
日一二三四五六
1 2
3 4 5 6 7 8 9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
(2)
源代码:
packaget31;
ng.*;
importjava.util.Scanner;
printMonthTitle(year,month);
printMonthBody(year,month);
}
publicstaticvoidprintMonthTitle(intyear,intmonth) {
System.out.println(" "+getMonthName(month) +" "+year);
if(s1.equals(s2))//判断s1与s2是否相同
{
System.out.println("s1与s2相同");
}
else
{
System.out.println("s1与s2不相同");
}
Strings3=newString("22030219851022024");
if(s3.startsWith("220302"))//判断s3的前缀是否是“220302”
StringfileName=path.substring(12,18);//获取path中“A.java”子字符串
System.out.println("c:\\java\\jsp\\A.java中含有的文件名:"+fileName);
Strings6=newString("100"),
s7=newString("123.678");
publicclassCalendar {
publicstaticvoidmain(String[]args) {
//TODOAuto-generated method stub
Scannerinput=newScanner(System.in);
System.out.print("请输入年份: ");
switch(month) {
case1:monthName="一月";break;
case2:monthName="二月";break;
{
Scannerread=newScanner(System.in);
System.out.println("输入第一个日期的年份:");
intyearOne=read.nextInt( );
System.out.println("输入该年的月份:");
intmonthOne=read.nextInt( );
Datedate1=newDate(timeOne);//用timeOne做参数构造date1
Datedate2=newDate(timeTwo);//用timeTwo做参数构造date2
if(date2.equals(date1))
{
System.out.println("两个日期的年、月、日完全相同");
(2)按要求,将代码替换为Java代码。
packaget1;
classStringExample
{
publicstaticvoidmain(Stringargs[ ])
{
Strings1=newString("you are a student"),
s2=newString("how are you");
System.out.printf("%d年%d月%d日和%d年%d月%d日相隔%d天",yearOne,monthOne,dayOne,yearTwo,monthTwo,dayTwo,相隔天数);
}
}
运行结果:
*任务二:简单日历的实现
(1)内容
建立简单的日历,该日历能根据用户输入年月显示相应日历。
intmonthTwo=read.nextInt( );
System.out.println("输入该月份的日期:");
intdayTwo=read.nextInt( );
Calendarcalendar=Calendar.getInstance();//初始化日历对象。
calendar.set(yearOne,monthOne,dayOne);//将calendar的时间设置为yearOne年monthOne月dayOne日
StringBufferyourStr=newStringBuffer("i Love THIS GaME");
for(i)
if(Character.isLowerCase(yourStr.charAt(i))){
c=Character.toUpperCase(yourStr.charAt(i));//将yourStr中的大写字符替换为对应的小写字符,小写字符替换为对应的大写字符
if(Character.isLowerCase(c))
{
c=Character.toUpperCase(c);
otherStr.setCharAt(start,c);//把字符改为大写字符
}
start=otherStr.indexOf(" ",start);//查找下一个空格。
}
System.out.println(otherStr);
}
elseif(date2.after(date1))
{
System.out.println("您输入的第二个日期大于第一个日期");
}
elseif(date2.before(date1))
{
System.out.println("您输入的第二个日期小于第一个日期");
}
long相隔天数=(Math.abs(timeTwo-timeOne))/(1000*60*60*24);//计算两个日期相隔天数
chara[ ]=s8.toCharArray();//将s8存放到数组a中
for(inti=a.length-1;i>=0;i--){
System.out.printf("%3c",a[i]);
}
}
}
运行结果:
2、StringBuffer类的常用方法
(1)要求:
编写一个应用程序,使用StringBuffer对象实现对字符串的编辑操作,如替换字符串的某些字符、删除字符串中的某些字符、在字符串中插入或尾加新的字符串等。
System.out.println("输入该月份的日期:");
intdayOne=read.nextInt( );
System.out.println("输入第二个日期的年份:");
intyearTwo=read.nextInt( );