IO流1（其他对象、FileWriter、FileReader）

System
System：描述系统一些信息。
获取系统属性信息：properties getproperties

System:类中的方法和属性都是静态的。
out:标准输出，默认是控制台。
in：标准输入，默认是键盘。

因为Properties是Hashtable的子类，也就是Map集合的一个子类对象。
那么可以通过map的方法取出该集合中的元素。
该集合中存储都是字符串。没有泛型定义。

如何在系统中自定义一些特有信息呢？
System.setProperty(“mykey”,”myvalue”);

获取指定属性信息。
String value = System.getProperty(“os.name”);
System.out.println(“value=”+value);

可不可以在jvm启动时，动态加载一些属性信息呢？
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);
}

Runtime对象
该类并没有提供构造函数。
说明不可以new对象。那么会直接想到该类中的方法都是静态的。
发现该类中还有非静态方法。
说明该类肯定会提供了方法获取本类对象。而且该方法是静态的，并返回值类型是本类类型。

由这个特点可以看出该类使用了单例设计模式完成。（保证了对象唯一性）

该方式是static Runtime getRuntime();

Runtime r = Runtime.getRuntime();
Process p = r.exec(“notepad.exe SystemDemo.java”);//用记事本打开SystemDemo.java
Thread.sleep(4000);//睡眠4000毫秒
p.destroy();//杀掉所有子进程

Date
类Date表示特定的瞬间。精确到毫秒。

将模式封装到SimpleDateformat对象中。
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy年MM月dd日E hh:mm:ss”);

Calendar
Calendar c = Calendar.getInstance();
sop(c.get(Calendar.YEAR)+”年”);//打印年份

需求：获取任意年的二月有多少天。
思路：根据指定年设置一个时间就是
c.set(year,2,1)//某一年的3月1日。
c.add(Calenar.DAY_OF_MONTH,-1);//3月1日，往前推一天，就是2月最后一天。

获取昨天的现在这个时刻。
c.add(Calenar.DAY_OF_MONTH,-1);

Math–Random
double d = Math.ceil(16.34); //ceil返回大于指定数据的最小整数。
double d1 = Math.floor(12.34); //floor返回小于指定数据的最大整数。
long l = Math.round(12.54); //四舍五入
double d2 = Math.pow(2,3); //2的3次方=8
Math.Random(); //随机数 范围0≤x＜1
(int) Math.Random()*10 //范围0≤x＜10，强转整数。

Random r = new Random();
for(int x=0; x<10; x++)
{
int d = (int)(Math.random()*10+1);
int d = r.nextInt(10)+1;
}

IO流
IO(Input Output)流
IO流用来处理设备之间的数据传输
Java对数据的操作是通过流的方式
Java用于操作流的对象都在IO包中
流按操作数据分为两种：字节流与字符流
流按流向分为：输入流，输出流。

IO流常用基类
字节流的抽象基类： InputStream ，OutputStream。
字符流的抽象基类： Reader ，Writer。
注：由这四个类派生出来的子类名称都是 以其父类名作为子类名的后缀。
如：InputStream的子类FileInputStream。
如：Reader的子类FileReader。

示例：

//需求:在硬盘上，创建一个文件并写入一些文字数据。

//找到一个专门用于操作文件的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("abcde");

        //刷新流对象中的缓冲中的数据。
        //将数据刷到目的地中。
        //fw.flush();


        //关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。
        //将数据刷到目的地中。
        //和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
        fw.close();
    }
}

IO异常的处理方式

/*
IO异常的处理方式。
*/
import java.io.*;

class  FileWriterDemo2
{
    public static void main(String[] args) 
    {
        FileWriter fw = null;
        try
        {
            fw = new FileWriter("demo.txt");
            fw.write("abcdefg");

        }
        catch (IOException e)
        {
            System.out.println("catch:"+e.toString());
        }
        finally
        {
            try
            {
                if(fw!=null)
                    fw.close();             
            }
            catch (IOException e)
            {
                System.out.println(e.toString());
            }

        }       

    }
}

演示对已有文件的数据续写

/*
演示对已有文件的数据续写。
*/
import java.io.*;
class  FileWriterDemo3
{
    public static void main(String[] args) throws IOException
    {

        //传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。
        FileWriter fw = new FileWriter("demo.txt",true);

        fw.write("nihao\r\nxiexie");

        fw.close();
    }
}

文本文件读取方式一

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(
        }


        /*
        while(true)
        {
            int ch = fr.read();
            if(ch==-1)
                break;
            System.out.println("ch="+(char)ch);
        }
        */



        fr.close();


    }
}

文本文件读取方式二

/*
第二种方式：通过字符数组进行读取。
*/

import java.io.*;

class FileReaderDemo2 
{
    public static void main(String[] args) throws IOException
    {
        FileReader fr = new FileReader("demo.txt");


        //定义一个字符数组。用于存储读到字符。
        //该read(char[])返回的是读到字符个数。
        char[] buf = new char[1024];

        int num = 0;
        while((num=fr.read(buf))!=-1)
        {
            System.out.println(new String(buf,0,num));
        }


        fr.close();
    }
}

将C盘一个文本文件复制到D盘。

//将C盘一个文本文件复制到D盘。

/*
复制的原理：
其实就是将C盘下的文件数据存储到D盘的一个文件中。

步骤：
1，在D盘创建一个文件。用于存储C盘文件中的数据。
2，定义读取流和C盘文件关联。
3，通过不断的读写完成数据存储。
4，关闭资源。
*/

import java.io.*;

class CopyText 
{
    public static void main(String[] args) throws IOException
    {
        copy_2();
    }


    public static void copy_2()
    {
        FileWriter fw = null;
        FileReader fr = null;
        try
        {
            fw = new FileWriter("SystemDemo_copy.txt");
            fr = new FileReader("SystemDemo.java");

            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)
                {
                }
        }
    }

    //从C盘读一个字符，就往D盘写一个字符。
    public static void copy_1()throws IOException
    {
        //创建目的地。
        FileWriter fw = new FileWriter("RuntimeDemo_copy.txt");

        //与已有文件关联。
        FileReader fr = new FileReader("RuntimeDemo.java");

        int ch = 0;

        while((ch=fr.read())!=-1)
        {
            fw.write(ch);
        }

        fw.close();
        fr.close();

    }


}