Java基础视频教程第18天_其他常用对象、IO流一

一、其他对象—— System 

	java.lang.System 
	public final class System extends Object 

	System: 不能实例化，其方法都是静态的。
	out: 标准输出，默认是控制台。
	in: 标准输入，默认是键盘。

	常用方法: 
	static long currentTimeMillis();获取当前时间
	static void exit();终止当前正在运行的 Java 虚拟机
	static void gc();运行垃圾回收器

	System 类可以描述系统环境，在虚拟机启动时，会加载一些默认的系统属性信息。可以通过getProperties()方法获取。

	重点方法： 
	获取系统属性信息：
		static Properties getProperties(); 返回当前的系统属性信息

	Properties 是 Hashtable 的一个子类。该集合中存储的都是字符串，没有泛型定义。

	代码：
	class PropertiesDemo
	{
		public static void main(String[] args)
		{
			Properties prop = System.getProperties();

			//在系统中自定义一些特有信息
			System.setProperty("mykey","myvalue");

			//获取指定属性信息。
			String value1 = System.getProperty("os.name");
			System.out.println("os.name: "+value1);

			//获取所有信息，使用高级for循环
			for(Object obj : prop.keySet())
			{
				String value = (String)prop.get(obj);
				System.out.println(obj+"::"+value);
			}
			
			//获取所有信息，使用迭代器
			Set keyset = prop.keySet();
			Iterator it = keyset.iterator();
			while(it.hasNext())
			{
				String key = (String)it.next();
				String value = (String)prop.get(key);
				System.out.println(key+"----"+value);
			}
		}
	}
二、其他对象 —— Runtime 
	java.lang.Runtime 
	public class Runtime extends Object 

	每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。

	Runtime: 该类并没有提供构造函数，不能创建对象；该类中却有非静态方法。
	所以该类提供了一个方法获取本类对象，并且该方法是静态的，并返回值类型是本类类型。(单例设计模式的体现)

	该方法就是: static Runtime getRuntime();

	方法摘要: 
	Process exec(String command); 在单独的进程中执行指定的字符串命令。(exec是 execute 的简写)

	java.lang.Process
	public abstract class Process extends Object 
	Process 类没有子类对象。

	代码：
	class RuntimeDemo  
	{
		public static void main(String[] args) throws Exception  
		{
			Runtime r = Runtime.getRuntime(); 
			Process p = r.exec("D:\\Program Files (x86)\\Tencent\\QQ\\Bin\\QQ.exe");
			Thread.sleep(3000);
			p.destroy();//杀掉子进程

			Process p1 = r.exec("notepad SystemDemo.java");
		}
	}
三、其他对象 —— Date 
	java.util.Date 
	public class Date extends Object implements Serializable, Cloneable, Comparable<Date> 
		Date 表示特定的瞬间，精确到毫秒。
		JDK1.6后，Date的构造方法只有两个，其余都已经过时：
			Date()
			Date(long date)
		Date 的大部分方法也已经过时，只剩下以下几个：
			boolean after(Date when)
			boolean before(Date when)
			Object clone()
			int compareTo(Date anotherDate)
			boolean equals(Object obj)
			int hashCode()
			long getTime()
			void setTime(long time)
			String toString()

	java.text.Format 抽象类
		-java.text.DateFormat 抽象类
			-SimpleDateFormat 

	DateFormat 中有一个方法：
		String format(Date date); 将一个 Date 格式化为日期/时间字符串。
		但是DateFormat是一个抽象类，所以可以使用其子类 SimpleDateFormat ,同时在创建该子类对象的时候传入一个模式。

	SimpleDateFormat(String patten); 构造方法

	日期和时间模式：


	代码:
	import java.util.*;
	import java.text.*;
	class DateDemo 
	{
		public static void main(String[] args) 
		{
			Date d = new Date();
			System.out.println(d);
			//打印格式如下：Wed Mar 18 07:38:59 CST 2015
			//以上格式看不懂，可以将其格式化

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

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

			//Date构造方法二：
			long l = System.currentTimeMillis();
			Date d1 = new Date(l);
			System.out.println(d1);
		}
	}
四、其他对象 —— Calendar 
	java.util.Calendar 
	public abstract class Calendar extends Object implements Serializable, Cloneable, Comparable<Calendar> 

	Calendar 是抽象类，不能创建对象。但是其提供了方法获取 Calendar 的具体对象，该方法是：
		static Calendar getInstance() 
		注意：该类不含有抽象方法，抽象修饰主要是为了不让创建对象。

	year; month; date; day; hour; minutes; seconds;

	January; February; March; April; May; June; July; August; September; October; November; December; 
	简写: Jan; Feb; Mar; Apr; May; June; July; Aug; Sept; Oct; Nov; Dec; 
	
	Monday; Tuesday; Wednesday; Thursday; Friday; Saturday; Sunday; 
	简写: Mon; Tues; Wed; Thur; Fri; Sat; Sun;

	代码一：
	import java.util.*;
	class CalendarDemo
	{
		public static void main(String[] args)
		{
			/*
			用Date 获取年的方式：这种方式比较麻烦

			Date d = new Date();
			System.out.println(d);

			SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
			String year = sdf.format(d);
			int ye = Integer.parseInt(year,10);

			System.out.println(ye);
			*/

			//Calendar 获取年的方式：
			Calendar c = Calendar.getInstance();
			System.out.println(c);
			//打印结果: java.util.GregorianCalendar[time=1426646703687,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2015,MONTH=2,WEEK_OF_YEAR=12,WEEK_OF_MONTH=3,DAY_OF_MONTH=18,DAY_OF_YEAR=77,DAY_OF_WEEK=4,DAY_OF_WEEK_IN_MONTH=3,AM_PM=0,HOUR=10,HOUR_OF_DAY=10,MINUTE=45,SECOND=3,MILLISECOND=687,ZONE_OFFSET=28800000,DST_OFFSET=0]
			int year = c.get(Calendar.YEAR);
			System.out.println(year+"年");
		}
	}
	与实际生活不同的是：
		在计算机中，月份是从0开始的：所以0代表一月，1代表二月，以此类推。
		一个星期也是从星期天开始的：1代表星期天，2代表星期一，3代表星期二，以此类推。
		所以，通过Calendar的get方法获取到的数值与实际数值不一致；那么可以通过查表法来获取星期和月份。
	代码二：
	import java.util.*;
	import java.text.*;
	class CalendarDemo2
	{
		public static void main(String[] args) 
		{
			Calendar c = Calendar.getInstance();

			String[] month = {"一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"};

			String[] week = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};

			int index = c.get(Calendar.MONTH);

			int index2 = c.get(Calendar.DAY_OF_WEEK);

			sop(c.get(Calendar.YEAR)+"年");

			//sop((c.get(Calendar.MONTH)+1)+"月");
			sop(month[index]);

			sop(c.get(Calendar.DAY_OF_MONTH)+"日");

			sop(week[index2]);
		}
		public static void sop(Object obj)
		{
			System.out.println(obj);
		}
	}
	日常生活中有对日期的修改，可以通过Calendar的set()方法类从新设置时间，或者通过add()方法来增减时间。
		abstract void add(int field, int amount) 根据日历的规则，为给定的日历字段添加或减去指定的时间量。 
		void set(...); set中可传入多个参数，详见API
	代码示例：
	import java.util.*;
	class CalendarDemo3
	{
		public static void main(String[] args) 
		{
			Calendar c = Calendar.getInstance();

			//c.set(2012,(2-1),23);//设置时间：因为系统中的月份比实际月份小1，所以月份需要做-1操作才会设置为所需要的月份。

			c.add(Calendar.MONTH,-1);//修改时间，前一个参数表示需要修改的内容，后一个参数表示需要修改的数值(正负号表示增加或者减少)

			printCalendar(c);
		}
		public static void printCalendar(Calendar c)
		{
			String[] month = {"一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"};

			String[] week = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};

			int index = c.get(Calendar.MONTH);

			int index2 = c.get(Calendar.DAY_OF_WEEK);

			sop(c.get(Calendar.YEAR)+"年");

			sop(month[index]);

			sop(c.get(Calendar.DAY_OF_MONTH)+"日");

			sop(week[index2]);
		}
		public static void sop(Object obj)
		{
			System.out.println(obj);
		}
	}
五、其他对象 —— Math-Random 
	java.lang.Math 
	public final class Math extends Object 
	该类不能创建对象，其方法都是静态的。

	方法:
		static int/long/double/float abs(int/long/double/float i); 返回绝对值 
		static double ceil(double a); 返回大于指定数据的最小整数
		static double floor(double a);返回小于指定数据的最大整数
		static long round(double a); 返回最接近参数的 long ，也就是四舍五入
		static int round(float a);四舍五入 
		static double pow(double a, double b); 返回a的b次幂。

	重点方法：
		random(); 
			返回带正号的 double 值，该值大于等于 0.0 且小于 1.0 。返回值是一个伪随机选择的数，在该范围内（近似）均匀分布。
			第一次调用该方法时，它将创建一个新的伪随机数生成器，与以下表达式完全相同
				new java.util.Random
	
	java.util.Random
	public class Random extends Object implements Serializable 
	此类的实例用于生成伪随机数流。
		int nextInt(int n) 
			返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。 

	代码：
	import java.util.*;
	class MathDemo 
	{
		public static void main(String[] args) 
		{
			Random r = new Random();
			for (int x=0 ;x<20 ;x++ )
			{
				//int d = (int)(Math.random()*10+1);//该方法调用的是Math中的random()方法，需要强转才能得到int类型的值

				int d = r.nextInt(10)+1;//直接只用Random类中的方法。
				sop(d);
			}

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

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

			long l = Math.round(12.50);
			//四舍五入 l=13

			int i = Math.round(21.31f);//21 

			double d2 = Math.pow(2.0,3.0);//2.0^3.0=8.0 

			sop("d="+d);
			sop("d1="+d1);
			sop("l="+l);
			sop("d2="+d2);
			sop("i="+i);
		}
		public static void sop(Object obj)
		{
			System.out.println(obj);
		}
	}
六、IO流——概述 
	IO: Input  Output 
		IO流用来处理设备之间的数据传输 
		Java对数据的操作是通过流的方式
		Java用于操作流的对象都在IO包中
		流按操作数据分为两种：字节流和字符流
		流按流向分为：输入流，输出流

	早期IO包中出现的都是字节流。因为数据的体现形式都是字节，也就是二进制数据。一般的二进制数据，字节流都可以搞定。
	但是有一部分数据是文本数据，它是比较常见的。为了方便于处理这些数据，单独将其分离出字符流。

	字符流的由来：
	美国人最开始编制出ASCII编码表(全名：美国信息标准交换码)。中国人汉字编码表：JB2312(收录了几千的中文及标点符号)，然后扩容为GBK(两万多中文)；再次扩容为18030？其他国家也做了相应的事情。
	然后国际标准化组织规范成unicode码表，又优化为UTF-8。
	unicode中，无论什么字符，都用2个字节来表示。
	当存入数据时使用的编码表，和取出数据时使用的编码表不一致，则会产生乱码。为了解决这个问题；java在流技术上基于字节流，产生了字符流。字符流可以在内部融合编码表。这样，在处理数据的时候就很方便。

	简单一句话：字符流的对象中融合的编码表。
	只有文字涉及编码。
	当处理图片时，使用的是字节流。因为图片不能进行编码的查找。

	所以出现了字节流和字符流并存的情况。
	通用字节流，字符流基于字节流。

	在IO体系当中，有很多对象，这些对象之间有了关系，形成一个体系。这个体系中一共有四个基类。
	在IO中，对于数据的操作，只有 读 和 写 。
	字节流的抽象基类：
		InputStream 读 , OutputStream 写
	
	字符流的抽象基类：
		Reader 读者 , Writer 写者

	这四个基类都是抽象的。

	注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。前缀名就是该对象的功能。
		如: InputStream 的子类 FileInputStream 用于读取文件的字节流
		如: Reader 的子类 FileReader 用于读取文件的字符流

	IO流就是围绕 读和写 来展开的。

七、IO流 —— FileWriter 
	通过IO包来使用IO体系。
	字符流: Reader , Writer 

	Writer: 
	构造方法被 protected 修饰，只能被子类使用。
	
	IO流是用于操作数据的，数据的最常见体现形式是：文件。

	操作文件的演示：
	需求：在硬盘上，创建一个文件并写入一些数据。

	Writer 
		-OutputStreamWriter 
			-FileWriter 用于写入文件的便捷类。此类的构造方法假定默认字符编码。

	FileWriter: 
		1、该对象一初始化就要有被操作的文件。
		2、创建该对象时，要么抛出异常，要么try处理。

	代码：
	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();

			//关闭流资源，但是关闭之前会刷新一个缓冲中的数据。
			fw.close();

			//fw.write("haha");该流被关闭之后就不可以往流中写数据了，否则会抛出Stream closed异常。
			//fw.flush();
		}
	}
八、IO异常处理方式 
	因为操作流时，创建流对象，或者调用FileWriter中的write方法、flush方法、close方法都会抛出异常，所以需要对这些异常进行处理。
	处理时请注意以下两点：
		1、close()必须放在finally中(因为资源用完必须要关闭)；
			而且还需要对其进行try处理(因为close方法会抛出异常)；
			同时需要对流对象其进行非空判断(如果流对象为空，则不能调用它的close方法)。

		2、流对象须定义在try外面，同时初始化为null，在try中明确指向。这样close()才可以访问该流对象。
	代码：
	import java.io.*;
	class FileWriterDemo2 
	{
		public static void main(String[] args) 
		{
			FileWriter fw = null;//fw定义在try外面
			try
			{
				fw = new FileWriter("demo.txt");//在try中创建对象
				fw.write("abcdefg");
			}
			catch (IOException e)
			{
				System.out.println(e.toString());
			}
			finally
			{
				if(fw!=null)//非空判断
				{
					try
					{
						fw.close();
					}
					catch (IOException e)
					{
						System.out.println(e.toString());
					}
				}
			}
		}
	}
九、文件的续写 
	FileWriter 中还有一个重载的构造函数：
		FileWriter(String fileName, boolean append) 
			根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。
			如果后一个参数传入true，则代表不覆盖已有的文件，并在已有文件的末尾处进行数据续写。

	代码示例：
	import java.io.*;
	class FileWriterDemo3
	{
		public static void main(String[] args) throws IOException 
		{
			//传递一个true参数，代表不覆盖已有的文件，并在已有文件的末尾处进行数据续写。
			//注意：如果该文件不存在，则创建一个新的文件。
			FileWriter fw = new FileWriter("demo.txt",true);

			fw.write("\r\nnihao\r\nxiexie");
			fw.close();
		}
	}
十、文本文件读取方式一 
	Reader
		-InputStreamReader
			-FileReader: 用于读取文件的便捷类。此类的构造方法假定默认字符编码。字符流百分之百都有编码。

	方式一：
	调用 read()方法：
		int read(); 读取单个字符。返回一个int类型的整数，该整数就是读取到的字符，整数的范围在 0 到 65535 之间 (0x00-0xffff)，如果已到达流的末尾，则返回 -1 。

	代码：
	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("ch="+(char)ch);
			}

			fr.close();
		}
	}
十一、文本文件读取方式二 
	方式二：
		通过字符数组进行读取。
		int read(char[] cbuf) 将字符读入数组。返回一个int类型的整数，该整数表示读取的字符数；
							  如果已到达流的末尾(也就是最后一次往数组中存入的字符数为0时)，则返回 -1 。
	import java.io.*;
	class FileReaderDemo2
	{
		public static void main(String[] args) throws IOException  
		{
			FileReader fr = new FileReader("demo.txt");

			//定义一个字符数组，用于存储读到的字符，字符数组的长度一般定义为1024的整数倍。
			//char[] buf = new char[1024];
			char[] buf = new char[3];
			
			int num = 0;
			while((num=fr.read(buf))!=-1)
			{
				System.out.println(new String(buf,0,num));//结果abc  def  gef
			}

			fr.close();
		}
	}


十二、文本文件读取练习
	需求：读取一个 .java 文件，并打印在控制台上。
	import java.io.*;

	class FileReaderTest 
	{
		public static void main(String[] args) throws IOException  
		{
			FileReader fr = new FileReader("SystemDemo.java");

			char[] buf = new char[1024];

			int len = 0;

			while((len=fr.read(buf))!=-1)
				System.out.print(new String(buf,0,len));//请注意，这个位置输出语句不要换行

			fr.close();
		}
	}
十三、拷贝文本文件 
	需求：
		将C盘一个文本文件复制到D盘。

	思路：
		1、在D盘创建一个文件，用于存储C盘文件中的数据；
		2、定义读取流和C盘文件关联；
		3、通过不断的读写完成数据存储；
		4、关闭资源。
	
	代码: 
	import java.io.*;
	class CopyTest  
	{
		public static void main(String[] args) throws IOException  
		{
			//copy_1();
			copy_2();
		}
		//读取一个字符，就写入一个字符
		public static void copy_1() throws IOException 
		{
			//通过FileWriter创建目的地
			FileWriter fw = new FileWriter("RuntimeDemo_copy.txt");

			//通过FileReader与原文件关联
			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)
					{
					}
				}
				if(fw!=null)
				{
					try
					{
						fw.close();
					}
					catch (IOException e)
					{
					}
				}
			}
		}
	}
十四、考本文本文件图例