----------------------Android培训、Java培训、java学习型技术博客、期待与您交流！ ----------------------
IO(Input Output)流
IO流用来处理设备之间的数据传输
Java对数据的操作是通过流的方式
Java用于操作流的对象都在IO包中
流按操作数据分为两种：字节流与字符流
流按流向分为：输入流，输出流。
字节流的抽象基类：
InputStream，OutputStream
字符流的抽象基类：
Reader，Writer。
注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
如：InputStream的子类FilelnputStream。
如：Reader的子类FileReader。
例子演示：
通过缓冲区复制一个.java文件。
readLine方法的原理
无论是读一行，获取读取多个字符。其实都是在硬盘中一个一个字符的读取，所以最终还是
使用的Read方法一个一个的读取。在内存中建立一个数组，读取一个存储一个字符，读到换行
符后一次性将数组中的数据返回。
import java.io.*;
class CopyTextByBuf
{
public static void main(String[] args) throws IOException
{
BufferedReader bufr = null ;
BufferedWriter bufw = null ;
try
{
bufr=new BufferedReader(new FileReader("BufferedWriterDemo.java"));
bufw=new BufferedWriter(new FileWriter("bufWriter_copy.txt"));
String line =null;
while ((line=bufr.readLine())!=null)
{
bufw.write(line);
bufw.flush();
}
}
catch (IOException e)
{
throw new RuntimeException("读写失败");
}
finally
{
try
{
if(bufr!=null)
bufr.close();
}
catch (IOException e)
{
throw new RuntimeException("读取关闭失败");
}
finally
{
try
{
if(bufw!=null)
bufw.close();
}
catch (IOException e)
{
throw new RuntimeException("写入关闭失败");
}
}
}
}
}该缓冲区提供了一个一次读一行的方法 ReadLine,方便与对文本数据的获取。
当返回null时，表示读到文件末尾。
readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。
例子演示：
import java.io.*;
class BufferedReaderDemo
{
public static void main(String[] args) throws IOException
{
//创建一个读取流对象和文件相关联。
FileReader fr = new FileReader("buf.txt");
//为了提高效率，加入缓冲技术。将字符读取流对象作为参数传递给缓冲区的构造函数。
BufferedReader bufr = new BufferedReader(fr);
String line = null;
while ((line=bufr.readLine())!=null)
{
System.out.println(line);
}
bufr.close();
}
}
所以在创建缓冲区时，必须先有流对象。
该缓冲区中提供了一个跨平台的换行符。
newLine（）；
例子演示：
import java.io.*;
class BufferWriterDemo
{
public static void main(String[] args) throws IOException
{
//创建一个字符写入流对象。
FileWriter fw = new FileWriter("buf.txt");
//为了提高字符写入流修效率。加入缓冲技术。
//只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
BufferedWriter bufw=new BufferedWriter(fw);
for (int x=1;x<5 ;x++ )
{
bufw.write("abcd"+x);
bufw.newLine();
bufw.flush();
}
//记住，只要用到缓冲区，就要记得刷新。
//bufw.flush();
//其实关闭缓冲区，就是关闭缓冲区中的流对象。
bufw.close();
}
}
例子演示：
将C盘一个文本文件复制到D盘。复制的原理;
其实就是将C盘下的文件数据存储到D盘的一个文件中。
步骤：
1，在D盘创建一个文件。用于存储C盘文件中的数据。
2，定义读取流和c 盘文件关联。
3，通过不断的读写完成数据存储。
4，关闭资源。
import java.io.*;
class CopyText
{
public static void main(String[] args)
{
copy_2();
}
public static void copy_1()throws IOException
{
//创建目的地。
FileWriter fw = new FileWriter("dalong.txt");
//与已有文件相关联。
FileReader fr = new FileReader("Sixu.txt");
int ch = 0;
while ((ch=fr.read())!=-1)
{
fw.write(ch);
}
fw.close();
fr.close();
}
public static void copy_2()
{
FileWriter fw = null;
FileReader fr = null;
try
{
fw = new FileWriter("SystemDemo_copy.txt");
fr = new FileReader("demo.txt");
char [] buf =new char[1024];
int len =0;
while ((len=fr.read(buf))!=-1)
{
fw.write(buf,0,len);
}
}
catch (IOException e)
{
throw new RuntimeException("读写失败");
}
finally
{
if (fr!=null)
try
{
fr.close();
}
catch(IOException e)
{
}
if (fw!=null)
try
{
fw.close();
}
catch(IOException e)
{
}
}
}
}
读取一个.java文件，并打印在控制台上。
import java.io.*;
class FileReaderTest
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("FileReaderDemo.java");
char [] buf = new char[1024];
int num =0;
while ((num=fr.read(buf))!=-1)
{
System.out.print(new String(buf,0,num));
}
fr.close();
}
}
第二种方式：通过字符数组进行读取。
import java.io.*;
class FileReaderDemo2
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader ("demo.txt");
//定义一个字符数组，用于存储读到字符。
//该reader（char[]）返回的是读到字符个数。
char[] buf = new char[1024];
int num =0;
while((num=fr.read(buf))!=-1)
{
System.out.println(new String(buf,0,num));
}
}
}import java.io.*;
class FileWriterDemo3
{
public static void main(String[] args) throws IOException
{
//传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。
FileWriter fw = new FileWriter("demo.txt",true);
fw.write("\r\nmiss you");
fw.close();
System.out.println("Hello World!");
}
}
import java.io.*;
class FileReaderDemo
{
public static void main(String[] args) throws IOException
{
//创建一个文件读取流对象，和指定名称的文件相关联。
//要保证该文件时已经存在的，如果不存在，会发生异常，FileNotFoundException.
FileReader fr = new FileReader ("demo.txt");
//调用读取流对象的read方法
//read():一次读一个字符。而且会自动往下读。
int ch = 0;
while ((ch=fr.read())!=-1)
{
System.out.println((char)ch);
}
/*
while(true)
{
int ch = fr.read();
if(ch==-1)
break;
System.out.println("ch="+(char)ch);
}
*/
System.out.println("Hello World!");
}
}
import java.io.*;
class FileWriterDemio2
{
public static void main(String[] args)
{
FileWriter fw = null;
try
{
fw = new FileWriter("sixu.txt");
fw.write("dengqiufengqi");
}
catch (IOException e )
{
System.out.println("catch:"+e.toString());
}
finally
{
try
{
if(fw!=null)
fw.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
System.out.println("Hello World!");
}
}
字节流两个基类：
InputStream OutputStream
字符流两个基类：
Reader Writer
先学习一下字符流的特点。
既然Io流是用于操作数据的，那么数据最常见的形式是：文件。
那么先以操作文字为主来演示。
需求：在硬盘上，创建一个文件并写入一些文字数据。
找到一个专门用于操作文件的Writer子类对象。FileWriter。
后缀名是父类名，前缀名是该流对象的功能。
例子演示：
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args) throws IOException
{
//创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
//而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
//实现该步就是在明确数据要存放的目的地。
FileWriter fw = new FileWriter("demo.txt");
//调用Write方法，将字符串写入到流中。
fw.write("dengqiufengqi");
//刷新流对象中的缓冲中的数据。
//将数据刷到目的地中。
fw.flush();
//关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。
//将数据刷新到目的地中。
//和flush区别：flush刷新后，流可以继续使用，close刷新后会将流关闭。
fw.close();
System.out.println("Hello World!");
}
}
import java.util.*;
class MathDemo
{
public static void main(String[] args)
{
Random r = new Random();
for (int x=0;x<10 ;x++ )
{
//int d =(int)(Math.random()*10+1);
int d = r.nextInt(10)+1;
sop(d);
}
}
public static void show()
{
double d = Math.ceil(16.34);//ceil返回大于指定数据的最小值。
double d1=Math.floor(12.34);//floor返回小于指定数据的最大整数。
long l = Math.round(12.54);//四舍五入
sop("d="+d);
sop("d1="+d1);
sop("l="+l);
double d2 =Math.pow(2,3);
sop("d2="+d2);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
import java.util.*;
import java.text.*;
class DateDemo
{
public static void main(String[] args)
{
Date d =new Date();
System.out.println(d);//打印时间看不懂，优化格式。
//将模式封装到simpleDateFormat("yyyy年MM月dd日 hh:mm:ss");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日E hh:mm:ss");
//调用format方法让模式格式化指定Date对象。
String time =sdf.format(d);
System.out.println("time="+time);
}
}
该类并没有提供构造函数。
说明不可以new对象。那么会直接想到该类中的方法都是静态的。
发现该类中还有非静态方法。
说明该类肯定会提供了方法获取本类对象。而且该方法是静态的，并且返回值类型是本类类型。
由这个特点可以看出该类使用了单例设计模式完成。
该方法是 static Runtime geyRuntime();
例子演示：
class RuntimeDemo
{
public static void main(String[] args) throws Exception
{
Runtime r =Runtime.getRuntime();
r.exec("D:\\应用软件\\腾讯扣扣\\Bin\\QQ.exe");
//Thread.sleep(6000);
//p.destroy();杀掉子进程
}
}
System:类中的方法和属性都是静态的。
out：标准输出，默认是控制台。
in：标准输入，默认是键盘。
描述系统一些信息。
获取系统属性信息：Properties getProperty(String key, String def)
例子演示：
import java.util.*;
class SystemDemo
{
public static void main(String[] args)
{
Properties prop=System.getProperties();
//应为properties是Hashtable的子类，也就是Map集合的一个子类对象。
//那么可以通过map的方法取出该集合中的元素。
//该集合存储的都是字符串，没有泛型定义
//如何在系统中自定义一些特有信息呢？
System.setProperty("mykey","myvalue");
//获取指定属性信息。
String value =System.getProperty("os name");
System.out.println("value="+value);
//可不可以在JVM启动时，动态的加载一些属性信息呢？
//命令行下 java -Dhaha=qqqq SystemDemo
String v=System.getProperty("haha");
System.out.println("v="+v);
/*
for (Object obj :prop.keySet())
{
String value =(String)prop.get(obj);
System.out.println(obj+"::"+value);
}
*/
}
}
----------------------Android培训、Java培训、java学习型技术博客、期待与您交流！ ----------------------
详细请查看：http://edu.csdn.net/
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
