[Java视频笔记]day18

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

out: 代表标准输出，默认是控制台。

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

 

描述系统的一些信息。

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

import java.util.*;

class  day18
{
	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);

		String v = System.getProperty("haha");
		System.out.println(v);//输出null

		//可不可以在jvm启动时，动态加载一些属性信息呢？
		//在控制台输入java -Dhaha-qq day18就可以添加一些信息
		System.out.println(v);//输入后 这时输出qq
		
		//获取所有属性信息
		for(Object obj : prop.keySet())
		{
			String value = (String)prop.get(obj);
			System.out.println(obj + "..."+value);
		}
		
	}
}

Runtime类

该类并没有提供构造函数，说明不可以new对象，那么会直接想到该类中的方法都是静态的。发现该类中还有非静态方法。说明该类肯定会提供一个方法获取本类对象。而且该方法是静态的，并且返回值类型是本类类型。由这个特点可以看出该类使用了单例设计模式。

该方法是static Runtime getRuntime();

import java.util.*;

class  day18
{
	public static void main(String[] args) throws Exception
	{
		Runtime r = Runtime.getRuntime();
		Process p = r.exec("C:\\Windows\\System32\\calc.exe");//打开电脑系统程序"计算器"
		//Process p = r.exec("C:\\Windows\\System32\\notepad.exe day18.java");
		//打开记事本应用程序，并在记事本中打开day18.java这个文件
		//p.destroy();//进程杀掉

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

Date类

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

class  day18
{
	public static void main(String[] args) throws Exception
	{
		Date d = new Date();
		sop(d);//输出Fri May 06 15:44:07 CST 2016

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

		sop(time);//输出 2016年05月06日  04:00:28
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

Calendar类

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

class  day18
{
	public static void main(String[] args) throws Exception
	{
		Calendar c = Calendar.getInstance();

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

		//因为西方星期天是一星期的第一天，这里用查表法转成我们习惯的格式
		String[] weeks = {"","星期天","星期一","星期二","星期三","星期四",
			"星期五","星期六"};
		int index = c.get(Calendar.MONTH);
		int index1 = c.get(Calendar.DAY_OF_WEEK);

		sop(c.get(Calendar.YEAR)+"年");
		//sop((c.get(Calendar.MONTH) + 1) + "月");
		sop(mons[index]);
		sop(c.get(Calendar.DAY_OF_MONTH)+"日");
		//sop("星期"+c.get(Calendar.DAY_OF_WEEK));
		sop(weeks[index1]);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

输出：

2016年

五月

6日

星期五

改变日期：

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

class  day18
{
	public static void main(String[] args) throws Exception
	{
		Calendar c = Calendar.getInstance();
		//c.set(2012, 2, 23);//2代表3月， 0代表1月
		c.add(Calendar.YEAR, 4);//年份+4
		printCalendar(c);
	}

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

		//因为西方星期天是一星期的第一天，这里用查表法转成我们习惯的格式
		String[] weeks = {"","星期天","星期一","星期二","星期三","星期四",
			"星期五","星期六"};
		int index = c.get(Calendar.MONTH);
		int index1 = c.get(Calendar.DAY_OF_WEEK);

		sop(c.get(Calendar.YEAR)+"年");
		//sop((c.get(Calendar.MONTH) + 1) + "月");
		sop(mons[index]);
		sop(c.get(Calendar.DAY_OF_MONTH)+"日");
		//sop("星期"+c.get(Calendar.DAY_OF_WEEK));
		sop(weeks[index1]);
	}

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

}

/*
两个练习:
1.获取任意年的二月有多少天
思路：根据指定年设置一个时间
c.set(year, 2, 1);//某一年的3月1日
c.add(Calendar.DAY_OF_MONTH, -1);//3月1日往前推一天，就是2月最后一天
2.获取昨天的现在这个时刻
c.add(Calendar.DAY_OF_MONTH, -1);
*/

Math类

ceil()返回大于指定数据的最小整数

floor()返回小于指定数据的最大整数

round()返回四舍五入后的整数

pow(a, b) 返回a的b次方

random()随机数 大于等于0.0小于1.0的伪随机数

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

class  day18
{
	public static void main(String[] args) throws Exception
	{
		for(int x = 0; x < 10; x ++)
		{
			//double d = Math.random();//0到1
			int d = (int)(Math.random()* 10 + 1);//1到10的随机整数，包含10
			sop(d);
		}

		//另一种写法
		Random r = new Random();
		for(int x =0; x < 10; x ++)
		{
			int d = r.nextInt(10) + 1;//1到10的随机整数，包含10
			sop(d);
		}
	}
		

	public static void base()
	{
		double d = Math.ceil(3.6);
		sop(d);//输出4.0
		d = Math.ceil(-3.6);
		sop(d);//输出-3.0

		d = Math.floor(3.6);
		sop(d);//输出3.0
		d = Math.floor(-3.6);
		sop(d);//输出-4.0

		long l = Math.round(12.34);
		sop(l);//输出12
		l = Math.round(12.54);
		sop(l);//输出13

		sop(Math.pow(2, 3));//输出8.0
	}
	

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

}

IO（Input Output）流

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

2. Java对数据的操作是通过流的方式

3. Java用于操作流的对象都在IO包中

4. 流按操作数据分为两种：字节流和字符流。

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

 

字节流的抽象基类

InputStream OutputStream

字符流的抽象基类

Reader Writer

 

由这四个类派生出来的子类名称都是以其父类作为子类名的后缀。

如: InputStream的子类FileInputStream

如: Reader的子类FileReader

 

先学习字符流的特点。

既然IO流是用于操作数据的。那么数据的最常见体现形式是：文件。先以操作文件为主来演示。

 

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

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

import java.io.*;

class  day18
{
	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异常的处理方式。

import java.io.*;

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

			fw.write("abdfd");
		}
		catch (IOException e)
		{
			System.out.println(e.toString());
		}
		finally//里面一定得关闭,而且判断fw是否建立对象
		{
			try
			{
				if(fw != null)
					fw.close();
			}
			catch (IOException e)
			{
				System.out.println(e.toString());
			}
		}
		
	}

}

对已有文件的数据续写。

import java.io.*;

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

		fw.write("haha");

		fw.write("nihao\r\nxiexie");//在Windows里面\r\n代表换行
		//在Linux里面只写\n就可以

		fw.close();

	}

}

文本文件读取方式一：

import java.io.*;

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

		//调用读取流对象的read方法
		//read()方法一次读一个字符，而且会自动往下读。
		
		int ch = fr.read();
		sop((char)ch);

		ch = fr.read();
		sop((char)ch);
		fr.close();

		ch = fr.read();//如果等于-1，则表示读完了

		/*
		while(true)
		{
			int ch = fr.read();
			if(ch == -1)
				break;
			sop((char)ch);
		}
		*/
		int ch = 0;
		while((ch = fr.read()) != -1)
		{
			sop((char)ch);
		}

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

}

文本文件读取方式二：

通过字符数组进行读取。

import java.io.*;

class  day18
{
	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)
		{
			sop(new String(buf, 0, num));
			//从0开始打印，每次读出来num个，就打印num个
		}
		fr.close();

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

}

练习：

读取一个.java文件，并打印在控制台上.

import java.io.*;

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

		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盘创建一个文件，用于存储文件中的数据。

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

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

4.关闭资源

import java.io.*;

class  day18
{
	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("demo_copy2.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(fw != null)
				try
				{
					fw.close();
				}
				catch (IOException e)
				{
				}
			if(fr != null)
				try
				{
					fr.close();
				}
				catch (IOException e)
				{
				}
		}
	}

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

		//与已有文件关联
		FileReader fr = new FileReader("demo.txt");

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

}