---------------------- android培训、java培训、期待与您交流！ ----------------------
1.其他对象(System)
/*
System:类中的方法和属性都是静态的.
out.标准输出,默认是控制台.
in:标准输入,默认是键盘.
描述系统一些信息
获取系统属性信息:Properties getProperties();
*/
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);
//可不可以在jvm启动时,动态加载一些属性信息呢?
String v = System.getProperty("haha");
System.out.println("v="+v);
//获取所有属性信息.
for(Object obj : prop.keySet())
{
String values = (String)prop.get(obj);
System.out.println(obj+"::"+values);
}
}
}
2.其他对象(Runtime)
/*
Runtime对象:
该类并没有提供构造函数.
说明不可以new对象.那么会直接想到该类中的方法都是静态的.
发现该类中还有非静态方法.
说明该类肯定会提供方法获取本类对象.而且该方法是静态的,
并且返回值类型是本类类型.
有这个特点可以看出该类使用了单例设计模式完成.
该方式是:static Runtime getRuntime();
*/
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();
}
}
3.其他对象(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);
long l = System.currentTimeMillis();
Date d1 = new Date(l);
System.out.println("d1:"+d1);
}
}
4.其他对象(Calendar)
import java.util.*;
import java.text.*;
class CalendarDemo
{
public static void main(String[] args)
{
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);
}
}
import java.util.*;
/*
两个练习:
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);
*/
class CalendarDemo2
{
public static void main(String[] args)
{
Calendar c = Calendar.getInstance();
c.set(2012,2,23);
c.add(Calendar.DAY_OF_MONTH,-18);
printCalendar(c);
}
public static void printCalendar(Calendar c)
{
String[] mons = {"一月","二月","三月","四月"
,"五月","六月","七月","八月"
,"九月","十月","十一月","十二月"};
String[] weeks = {
"","星期日","星期一","星期二","星期三","星期四","星期五","星期六",
};
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);
}
}
5.其他对象(Math-Random)
/*
练习:给定一个小数.
保留该小数的后两位.
选作.可以考虑四舍五入.
*/
import java.util.*;
class MathDemo
{
public static void main(String[] args)
{
/*Random r = new Random();
for(int x=0; x<10;x++)
{
//int d = (int)(Math.random()*10+1);
int d = r.nextInt(10)+1;
sop(d);
}
*/
saveTwo(12.3456,3,true);
}
public static void saveTwo(double d,int scale,boolean isRound)
{
double base = Math.pow(10,scale);
double num = isRound?Math.round(d*base)/base:((int)(d*base));
sop("num="+num);
}
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);
sop("d2="+d2);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
6.IO流(概述)
IO(Input Output)流
.IO流用来处理设备之间的数据传输.
.java对数据的操作是通过流的方式.
.java用于操作流的对象都在IO包里.
.流按操作数据分为两种:字节流与字符流
.流按流向分为:输入流,输出流.
IO流常用的基类:
.字节流的抽象基类:
InputStream,OutputStream.
.字符流的抽象基类:
Reader,Writer.
.注:有这四个类派生出来的子类名称都是以其父类名作为子类名的后缀.
如:InputStream的子类为FileInputStream.
如:Reader的子类是FileReader.
7.IO流(FileWrite)
/*
字符流和字节流:
字节流的两个基类:
InputStream OutputStream
字符流两个基类:
Reader Writer
先学习一下字符流的特点.
既然IO流是用于操作数据的,
那么数据的最常见体现形式是:文件.
那么先以操作文件为主来演示.
需求:在硬盘上,创建一个文件写入一些文字数据.
找到一个专门用于操作文件的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("abcde淤泥和");
//刷新流对象中的缓冲中的数据.
//将数据刷到目的地中.
fw.flush();
//关闭流资源,但是关闭之前会刷新一次内部的缓冲中的数据.
//将数据刷到目的地中.
//和flush()区别:flush刷新后,流可以继续使用,close刷新后,会将流关闭.
fw.close();
}
}
8.IO流(IO异常处理方式)
/*
IO异常的处理方式
*/
import java.io.*;
class FileWriterDemo2
{
public static void main(String[] args)
{
FileWriter fw = null;
try
{
fw = new FileWriter("demo.txt");
fw.write("abcdhhjk");
}
catch (IOException e)
{
System.out.println("catch:"+e.toString());
}
finally
{
try
{
if(fw!=null)
fw.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
}
}
9.IO流(文件的续写)
/*
演示对已有文件的数据续写.
*/
import java.io.*;
class FileWriterDemo3
{
public static void main(String[] args) throws IOException
{
//传递一个true参数,代表不覆盖已有的文件.
//并在已有文件的末尾处进行数据的续写.
FileWriter fw = new FileWriter("demo.txt",true);
fw.write("nihao\r\nxiexie");
fw.close();
}
}
10.IO流(文本文件读取方式一)
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.print((char)ch);
}
fr.close();
}
}
11.IO流(文本文件读取方式二)
/*
第二种方式:通过字符数组进行读取.
*/
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(new String(buf,0,num));
}
fr.close();
}
}
12.IO流(文本文件读取练习)
/*
读取一个.java文件,并打印在控制台上.
*/
import java.io.*;
class FileReaderTest
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("FileWriterDemo.java");
char[] buf = new char[1024];
int num = 0;
while((num=fr.read(buf))!=-1)
{
System.out.println(new String(buf,0,num));
}
fr.close();
}
}
13.IO流(拷贝文本文件)
14.IO流(拷贝文本文件图例)
//将c盘一个文本文件复制到d盘
/*
复制的原理:
其实就是将C盘下的文件数据存储到D盘的一个文件中.
步骤:
1.在d盘创建一个文件夹.用于存储c盘文件中的数据.
2.定义读取流和c盘文件关联.
3.通过不断的读写完成数据存储.
4.关闭资源.
*/
import java.io.*;
class CopyText
{
public static void main(String[] args) throws IOException
{
//copy_1();
copy_2();
}
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 num =0;
while ((num=fr.read(buf))!=-1)
{
fw.write(new String(buf,0,num));
}
}
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)
{
}
}
}
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();
}
}---------------------- android培训、 java培训、期待与您交流！ ----------------------详细请查看： http://edu.csdn.net/heima
169
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
