Java高级视频_IO输入与输出（一）

一、其它对象

01、Systeam

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

描述系统一些信息。

获取系统属性信息：Properties getProperties();
*/
import java.util.*;
class SystemDemo 
{
	public static void main(String[] args) 
	{
		//获取系统属性信息
		Properties prop = System.getProperties(); 
		
		//如何在系统中自定义信息
		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);
		}
		*/
	}
}

02、Runtime

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

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

该方式是static Ruuntime getRuntime();
*/
class  RuntimeDemo
{
	public static void main(String[] args) throws Exception
	{
		Runtime r = Runtime.getRuntime();
		
		//调用一个系统可执行文件
		//Process P = r.exec("C:\\Program Files\\foobar2000\\foobar2000.exe");
		Process P = r.exec("notepad.exe F:\\java\\11\\RuntimeDemo.java");
		
        Thread.sleep(4000);//4秒后执行
		P.destroy();
		//System.out.println("Hello World!");
	}
}

3、

03、Date (日期类)

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

		//将模式封装到SimpleDateformat对象中。
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日星期E hh:mm:ss");
		
		//调用format方法让模式格式化指定Date对象。
		String time = sdf.format(d);

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

04、Calendar（日历）

import java.util.*;
import java.text.*;

class CalendarDemo 
{
	public static void main(String[] args) 
	{
		xin();
		
	}
	public static void xin()//新方法
	{
		Calendar c = Calendar.getInstance();
		sop(c.get(Calendar.YEAR)+"年");
		sop((c.get(Calendar.MONTH)+1)+"月");
		sop(c.get(Calendar.DAY_OF_MONTH)+"日");
		sop("星期"+c.get(Calendar.DAY_OF_WEEK));
	}
	public static void jiu()//旧方法
	{
		Date d = new Date();

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy");

		String year=sdf.format(d);
		sop(year);
	}
	public static void sop(Object obj)
	{
        System.out.println(obj);
	}
}

二、数据类

01、Math-Random（随机数）

import java.util.*;

class MathDemo 
{
	public static void main(String[] args) 
	{
		Random r = new Random();
		for(int x=0;x<10;x++)
		{
			double 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);
	}

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

三、IO（Input/Output）流

01、概述

（1）IO流用来处理设备之间的数据传输。

（2）Java对数据的操作是通过流的方式。

（3）Java用于操作流的对象都在IO包中。

（4）流按操作数据分为两种：字节流与字符流。

（5）流按流向分为：输入流，输出流。

02、IO流常用基类

（1）字节流的抽象基类：

InputStream，OutputStream。

（2）字符流的抽象基类：

Reader，Writer。

（3）注：由这四个类派生出来的子类名称都是以其父类名的后缀。

——如：InputStream的子类FileinputStream。

——如：Reader的子类FileReader

（4）例子

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

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

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

03、IO异常处理方式

import java.io.*;
class FileWriterDemo2 
{
	public static void main(String[] args) 
	{
		FileWriter fw = null;
		try
		{
			//异常：目录不存在
			fw = new FileWriter("demo.txt");//创建写入流对象

			//异常：内存已满
			fw.write("sdkjfjewoifwe");//执行写入操作
		}
		catch (IOException e)
		{
			System.out.println("carch"+e.toString());
		}
		finally 
		{
			try
			{
				//异常：没有成功创建写入流对象
				if(fw!=null)
					fw.close();
			}
			catch (IOException e)
			{
                System.out.println(e.toString());
			}
		}
		
	}
}

04、文件的续写

/*
演示对已有文件的数据续写
*/
import java.io.*;
class FileWriterDemo3
{
	public static void main(String[] args) 
	{
		FileWriter fw = null;
		try
		{
			//异常：目录不存在
			//fw = new FileWriter("demo.txt",true);//创建写入流对象
            fw = new FileWriter("demo.txt",true);//创建写入流对象,文件末尾写入数据
			//异常：内存已满
			fw.write("sdkjfjewoifwe");//执行写入操作
		}
		catch (IOException e)
		{
			System.out.println("carch"+e.toString());
		}
		finally 
		{
			try
			{
				//异常：没有成功创建写入流对象
				if(fw!=null)
					fw.close();
			}
			catch (IOException e)
			{
                System.out.println(e.toString());
			}
		}
		
	}
}

05、文件的读取方式

（1）一个个字节的读取

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

		//调用读取流对象的read方法。
        //read():一次读一个字符，返回的是int类型，而且会自动往下读，读到结尾为-1.
		
		int ch = 0;

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

（2）通过字符数组进行读取。

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.print(new String(buf,0,num));
		}		
		
		fr.close();
	}
}

06、文件的复制

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

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

import java.io.*;
class  CopyText
{
	public static void main(String[] args) throws IOException
	{
		Copy_1();
		Copy_2();
	}
    
	//从一个读一个字符，就往另一个写一个字符。
	public static void Copy_1()
	{
		FileWriter fw = null;
		FileReader fr = null;

		
        try
        { 
			fw = new FileWriter("C:\\0663_1.txt");
            fr = new FileReader("C:\\0663.txt");

			int ch = 0;
        	while ((ch = fr.read())!=-1)
		    {
			     fw.write(ch);
		    }
        }
        catch (IOException e)
        {
			throw new RuntimeException("读写失败！");
        }
		finally
		{
			try
			{
				if(fr!=null)
				fw.close();
			}
			catch (IOException e)
			{
                throw new RuntimeException("读取关闭失败！");
			}
			try
			{
				if(fw!=null)
				fr.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("写入关闭失败！");
			}
		    
		}

		

	}
   //从一个读一个字符数组，就往另一个写一个字符数组。
	public static void Copy_2()
	{
		FileWriter fw = null;
		FileReader fr = null;
		try
		{
			fw = new FileWriter("C:\\0663_2.txt");
            fr = new FileReader("C:\\0663.txt");

			char[] ch = new char[1024];

		    int num=0;        
		    while ((num = fr.read(ch))!=-1)
		    {
			    fw.write(ch,0,num);
		    }
		} 
		catch (IOException e)
        {
			throw new RuntimeException("读写失败！");
        }
		finally
		{
			try
			{
				if(fr!=null)
				fw.close();
			}
			catch (IOException e)
			{
                throw new RuntimeException("读取关闭失败！");
			}
			try
			{
				if(fw!=null)
				fr.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("写入关闭失败！");
			}
		
		
		}
	}
}