Java 其他对象 IO流 字符流--18

System

System:类中的方法和属性都是静态的。

out：标准输出，默认是控制台

in:标准输入，默认是键盘

描述系统的一些信息。

获取系统属性信息：Properties getProperties();

[code]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);

        //获取不存在的信息，返回为null
        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);
        }
        */
    }
}

可不可以在jvm启动时，动态加载一些属性信息呢？

String v = System.getProperty(“haha”);

System.out.println(“v=”+v);

Runtime对象

该类并没有提供构造函数，

说明不可以new对象，那么会直接想到该类中的方法都是静态的

发现该类中还有非静态方法

说明该类中肯定会提供方法获取本类对象。

而且该方法是静态的，并返回值类型是本类类型

由这个特点可以看出该类使用了单例设计模式完成

该方法是static Runtime getRuntime();

[code]class RuntimeDemo
{
    public static void main(String[] args) throws Exception
    {
        Runtime r = Runtime.getRuntime();
        Process p = r.exec("notepad.exe SystemDemo.java");

        //Thread.sleep(4000);
        //杀掉子进程。
        //p.destroy();

    }
}

Date

[code]import java.util.*;
import static java.lang.System.*;
import java.text.*;

class DateDemo
{
    public static void main(String[] args)
    {
        Date d = new Date();
        out.println(d);//打印的时间看不懂，希望有一些格式

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

        //调用format方法让模式格式化指定Date对象。
        String time = sdf.format(d);

        out.println("time="+time);
    }
}

Calendar

[code]import java.util.*;
import static java.lang.System.*;
import java.text.*;

class CalendarDemo
{
    public  static void main(String[] args)
    {
        Calendar c = Calendar.getInstance();
        sop(c.get(Calendar.YEAR)+"年"+c.get(Calendar.MONTH)+"月"+c.get(Calendar.DAY_OF_MONTH)+"日");

        c.add(Calendar.YEAR,-5);
        sop(c.get(Calendar.YEAR)+"年");

        /*
        Date d = new Date();

        SimpleDateFormat y = new SimpleDateFormat("yyyy");

        String year = y.format(d);

        sop(year);
        */
    }

    public static void sop(Object obj)
    {
        out.println(obj);
    }
}

月份的角标0对应一月。所以获得的月份会是当前月份-1。

Math

[code]import  java.util.*;
class MathDemo
{
    public static void main(String[] args)
    {
        //show();

        Random r = new Random();
        for(int x=0;x<10;x++)
        {
            int m = r.nextInt(10)+1;//随机1~10的整数
            sop(m);
        }

        for(int x=0;x<10;x++)
        {
            double d = Math.random();//返回带正号的 double 值，该值大于等于 0.0 且小于 1.0
            sop(d);
        }

        /*
        for(int x=0;x<10;x++)
        {
            int d = (int) (Math.random()*10+1);
            sop(d);
        }
        */

    }

    public static void show()
    {
        double d = Math.ceil(-12.24);
        //ceil返回大于指定数据的最小整数。

        double d1 = Math.floor(12.24);
        //floor返回小于指定数据的最大整数。

        sop("d="+d);
        sop("d1="+d1);

        //四舍五入
        long l = Math.round(11.5);
        sop("l="+l);

        //幂运算
        double d2 = Math.pow(4,3);
        sop("d2="+d2);
    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

IO流

IO流用来处理设备之间的数据传输

java对数据的操作是通过流的方式

java用于操作流的对象都在IO包中

流按操作数据分为两种：字节流与字符流

流按流向分为：输入流，输出流。

IO流常用基类

字节流的抽象基类：

InputStream , OutputStream

字符流的抽象基类：

Reader , Writer

先学习字符流的特点

既然IO流是用于操作数据的，

那么数据的最常见体现形式是：文件

首先以操作文件为主来演示

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

找到一个专门用于操作文件的writer子类对象：FileWriter。 后缀名是父类名，前缀名是该流对象的功能。

[code]import java.io.*;

class FileWriterDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
        //而且该文件会被创建到指定的目录下，如果该目录下已有同名文件，将会被覆盖。
        //其实该步骤就是明确数据要存放的目的地。
        FileWriter fw = new FileWriter("demo.txt");

        //调用writer方法，将字符串写入到流中。
        fw.write("王勋亮");

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

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

    }
}

会在java0217/day18目录中产生一个txt文件。里面有写入的内容。

IOException处理方式

[code]import java.io.*;

class FileWriterDemo2 
{
    public static void main(String[] args)
    {
        //在外边建立引用，在try内进行初始化
        FileWriter fw = null;

        try
        {
            fw = new FileWriter("g:\\demo.txt");

            fw.write("qwewqere");

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

        }

    }
}

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

[code]import java.io.*;
class FileWriterDemo3 
{
    public static void main(String[] args)
    {
        //传递一个true参数，代表不覆盖已有的文件
        //并在已有文件的末尾处进行数据续写
        FileWriter fw = null;
        try
        {
            fw = new FileWriter("demo.txt",true);

            fw.write("hah\r\ngg");//换行
        }
        catch(IOException e)
        {
            System.out.println(e.toString());
        }
        finally
        {
            try
            {
                if(fw != null)
                    fw.close();
            }
            catch(IOException e)
            {
                System.out.println(e.toString());
            }

        }

    }
}

读取文件内容

[code]import java.io.*;

class FileReaderDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个文件读取流对象，和指定名称的文件相关联
        //要保证该文件是已经存在的，如果不存在，会发生FileNotFoundException
        FileReader fr = new FileReader("demo.txt");

        //调用读取流对象的方法
        //read():一次读一个字符，而且会自动往下读，读到最后返回-1

        int ch = 0;

        while((ch=fr.read())!=-1)
        {
            System.out.print((char)ch);
        }

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

        fr.close();

    }
}

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

[code]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("num="+num+"..."+new String(buf,0,num));
        }

        fr.close();

    }
}

读取一个.java文件，并打印在控制台上。
import java.io.*;

class FileReaderTest
{
    public static void main(String[] args) throws IOException
    {
        FileReader fr  = new FileReader("DateDemo.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();
    }
}

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

复制的原理：

其实就是将C盘下的文件数据存储到D盘的一个文件中。

步骤：

1，在D盘创建一个文件，用于存储C盘文件的数据

2，定义读取流和C盘文件关联。

3，通过不断的读写完成数据存储。

4，关闭资源

[code]import java.io.*;

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

    //从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();

    }

    //第二种方式。
    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)
                {
                    throw new RuntimeException("读写失败");
                }
            if(fw!=null)
                try
                {
                    fw.close();
                }
                catch(IOException e)
                {
                    throw new RuntimeException("读写失败");
                }
        }

    }
}