标签：
类 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();
}
}
标签：
原文地址：http://blog.csdn.net/sr_19930829/article/details/51334514
