JAVASE学习笔记第18天

其他对象(System)

/**

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

 

out: 标准输入，默认是控制台

in：  标准输出，默认是键盘。

 

1，Properties是Hashtable的子类，也就是Map集合的一个子类对象，

那么可以通过map的方法操作该集合中的元素。

2、Properties集合中存储的都是字符串，没有泛型的定义。

 

*/

import java.util.*;

 

class Demo1

{

       publicstatic void main(String[] args)

       {

          //获取指定属性的信息

              Stringvalue1=System.getProperty("os.name");

              System.out.println(value1);    

 

              System.out.println("-------------------------------------");

             

              //在系统中自定义一些特有的信息。

              System.setProperty("hhahh","lllllll");          

 

              //动态的自定义一些信息

              Stringv = System.getProperty("hahha");

              System.out.println("v="+v);

 

              /*

              在命令行输入：

            java -Dhahha=lllll Demo1

               输出结果：

              v=lllll

              */

 

              /*

              Propertiesprop=System.getProperties();

              //获取所有的属性的信息

              for(Objectkey : prop.keySet())

              {

                     Stringvalue = (String) prop.get(key);//别忘了强制转换

 

                     System.out.println(key+"::"+value);

              }

              */

       }

}

 

其他对象(Runtime)

/**

查阅api的步骤：

1，找构造函数

2，如果没有构造函数，可能该类的属性和方法就是static的

3，如果存在不是static的方法，则说明该类中提供了一个static方法，

        返回了一个本类的对象。

 

Runtime类：

1、每一个java应用程序都有一个Runtime类实例，使应用程序

能够与其运行的环境相连接。

      

2、static RuntimegetRuntime() ;返回一个本类的对象。

*/

 

class Demo2

{

       publicstatic void main(String[] args)throws Exception

       {

              Runtimer = Runtime.getRuntime();

              //打开一个进程,需要抛出异常,注意在指定路径的时候\是转意字符  C：\\ myclass

              Processp =r.exec("notepad.exe Demo1.java");

             

              //睡4秒

              Thread.sleep(4000);

              //杀死进程,杀死的使我们现在自己打开的进程

              p.destroy();

       }

}

 

 

 

其他对象(Date)

/**

查阅文档的时候，当我们找不到我们需要的东西的时候，可以看一下，另请参阅

*/

 

import java.util.*;

import java.text.*;  //SimpleDateFormat属于这个包

 

class Demo3

{

       publicstatic void main(String[] args)

       {

              //创建一个Date对象

              Datedate = new Date();

              System.out.println(date);   //Thu Aug 21 11:16:40 CST 2014

             

              //我们发现打印的结果，我们看不懂，

              //那我们想能不能够将显示的结果按照我们定义的默认打印呢？

 

              //将模式封装到SimpleDateFormat中

              //在SimpleDateFormat中提供了时间日期对照表 ：y表示年 M :表示月 d：表示天

              SimpleDateFormatsdf = new SimpleDateFormat("yyyy年MM月dd日");

             

              //调用Date中的方法，让date格式化为指定的模式。

              Stringtime = sdf.format(date);

 

              System.out.println(time);//结果为: 2014年08月21日

       }

}

其他对象(Calendar)

 

例子1：

/**

Calendar :是一个抽象类，相当于日期

 

1，使用getInstance()，及其重载的方法获取对象

2，public abstract voidadd(int field,  int amount)

       根据日历的规则，为给定的日历字段加或减去指定的时间量。

       例如，要从当前日历时间减去5 天，可以通过调用以下方法做到这一点：

              add(Calendar.DAY_OF_MONTH,-5)。

 

 

*/

 

import java.util.*;

import java.text.*;

 

class Demo4

{

       publicstatic void main(String[] args)

       {

              method();

       }

 

       publicstatic void sop(Object obj)

       {

              System.out.println(obj);

       }

 

       publicstatic void method()

       {

              Datedate = new Date();

 

              SimpleDateFormatsdf = new SimpleDateFormat("yyyy年MM月dd日E");//2014年08月23日星星期六

              System.out.println(sdf.format(date));   

             

              //得到对象

              Calendarc = Calendar.getInstance();

 

              //改善代码，使用查表法查找

              String[]m_index ={"一月","二月","三月","四月"

                                                               ,"五月","六月","七月","八月"

                                                               ,"九月","十月","十一月","十二月"};

 

              String[]w_index ={"星期日","星期一","星期二","星期三",

                                                                      "星期四","星期五","星期六"};

 

              //获取年

              System.out.println(c.get(Calendar.YEAR));

 

              //获取月份

              intnum=c.get(Calendar.MONTH);

              System.out.println(m_index[num]);

 

              //获取日子

              sop(c.get(Calendar.DAY_OF_MONTH));

 

              //获取星期

              intnum1=c.get(Calendar.DAY_OF_WEEK);

              sop(w_index[num1-1]);

}

}

 

 

其他对象(Math—Random)(面试)

/**

Math类中的常用的方法：

1,public static double ceil(double a)

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

2，public static doublefloor(double a)

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

3，public static longround(double a)

       四舍五入

4，public static doublepow(double a, double b)

     返回a的b次方

5，public static doublerandom()

       返回带正号double值，在0~1之间。

*/

 

class Demo5

{

       publicstatic void main(String[] args)

       {

              doublea = 3.4;

              sop(Math.ceil(a));//4.0

              sop(Math.floor(a));//3.0

 

              sop(Math.round(3.56));//4

              sop(Math.round(3.3));  //3

 

              sop(Math.pow(2,3));  //8

 

              for(intx =0 ;x <6; x++)

              {

                     sop((int)(Math.random()*10+1));//输出1到10之间的整数

              }

       }     

      

       publicstatic void sop(Object obj)

       {

              System.out.println(obj);

       }

}

 

其他对象(IO流（概述）)

1、IO（Input Output）流

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

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

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

l  流按操作数据分为两种：字节流和字符流

l  流按流的方向分为:输入流，输出流

2、注意：

l  字节流包含字符流

l  字符流的出现是为了文字和编码表的匹配

3、IO流常用基类

l  字节流的抽象基类：

InputStream                OutputStream

l  字符流的抽象基类：

Reader                        Writer

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

如：InputStream 的子类：FileInputStream

        Reader的子类：FileReader

 

 

 

 

 

 

 

其他对象(IO流（FileWriter）)

/**

先学习一下字符流：既然IO流是用于操作数据的，那么数据最常见的形式就是：

文件。

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

*/

import java.io.*;

 

class IODemo

{

       publicstatic void main(String[] args)throws IOException

       {

              /*

              创建一个FileWriter对象，该对象一被初始化就必须要明确操作的文件。

              而且该文件会被创建在指定的目录下。如果该目录下已经有同名的文件，

              将被覆盖。其实该步骤就是在明确数据要存放的目的地。

              */   

              //创建一个FileWriter对象

              FileWriterfw = new FileWriter("demo.txt");

 

              //调用write方法，将字符串写入到流中

              fw.write("adddd");

 

             

              //刷新流对象缓冲中的数据，将数据刷新到目的地中             

              //fw.flush();

 

              /*

              1，关闭流资源，但是关闭前会刷新一次内部的缓冲中的数据

              将数据刷新到目的地中

 

              2，和flush的区别：flush刷新后，流还可以继续使用；

                                           close刷新之后，会关闭流资源

              */          

 

              fw.write("adddd");

              //刷新一次，且关闭流资源

              fw.close();

       }}

其他对象(IO流（异常处理方式）)

/**

IO中的异常处理:

1，在全局定义引用，在局部创建对象

2，别忘了处理空指针异常

*/

import java.io.*;

 

class IODemo2

{

       publicstatic void main(String[] args)

       {

              //创建引用

              FileWriterfw  = null;

              try

              {

                     fw= new FileWriter("H:\\Demo.txt");

                     //向流中写入数据

                     fw.write("aaaaaa");

              }

              catch(IOException e)

              {

                     System.out.println("catch:"+e.toString());

              }

 

              finally

              {

                     try

                     {

                            //防止空指针异常

                            if(fw!=null) 

                                   //关闭流

                                   fw.close();

                     }

                     catch(IOException e)

                     {

                            System.out.println(e.toString());

                     }

              }

       }

}

 

 

其他对象(IO流（文件的续写）)

/**

演示对已有文件的数据的续写。

在windows中，/r/n代表着换行（例如记事本）

*/

import java.io.*;

 

class IODemo3

{

       publicstatic void main(String[] args)

       {

              //创建引用

              FileWriterfw =null;

              try

              {

                     //传递一个true参数，代表着不覆盖已有的文件，

                     //并且在已有的文件的末尾处添加内容

                     fw= new FileWriter("Demo.txt",true);

 

                     fw.write("nihao\r\nxiexie");

              }

              catch(IOException e)

              {

                     System.out.println("catch:"+e.toString());

              }

              finally

              {

                     if(fw!=null)

                            try

                            {

                                   fw.close();

                            }

                            catch (IOException e)

                            {

                                   System.out.println(e.toString());

                            }

              }

       }

}

 

 

其他对象(IO流（文本文件读取方式一）)

 

/**

文件的读取：

FileReader

*/

import java.io.*;

 

class IODemo4

{

       publicstatic void main(String[] args)throws IOException

       {

              //创建一个文件读取流对象，和指定的文件相关联

              //要保证该文件已经存在，如果不存在，会发生异常

              FileReaderfr = new FileReader("demo.txt");

 

              //调用读取流对象的read方法

              //read():一次读一个字符，而且会自动向下读

 

              for(intch=0;(ch=fr.read())!=-1;)

              {

                     System.out.print((char)ch)       ;

              }     

 

              fr.close();

 

       }

}

 

其他对象(IO流（文本文件读取方式二）)

/*第二种方式：通过字符数组进行读取*/

 

import java.io.*;

 

class IODemo5

{

       publicstatic void main(String[] args)throws IOException

       {

              FileReaderfr = new FileReader("demo.txt");

 

              //定义一个字符数组，用于存储读到的字符

              //该reader(char[])返回的是读取到的字符的个数

             

              char[]buf = new char[1024]; //通常字符数组的长度是1024的整数倍

 

              for(intnum=0;(num=fr.read(buf))!=-1;)

              {

                     System.out.println(newString(buf,0,num)); 

                     //将字符数组中指定的内容转换为字符串

              }

 

              fr.close();

       }

}

其他对象(IO流（文本文件读取练习）)

/**

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

*/

import java.io.*;

 

class Test

{

       publicstatic void main(String[] args)throws IOException

       {

              FileReaderfr = new FileReader("Demo1.java");

             

              char[]ch = new char[1024];

              for(intnum=0;(num=fr.read(ch))!=-1;)

              {

                     System.out.print(newString(ch,0,num));

              }

 

              fr.close();

       }

}

 

 

 

 

 

 

 

其他对象(IO流（拷贝文本文件）)

/**

需求:将C盘一个文件复制到D盘

 

思路：

其实就是将c盘下的文件数据存储到D盘的一个文件中

 

步骤：

1，在D盘创建一个文件，用于存储c盘文件中的数据

2，定义读取流对象，关联c盘中的文件

3，利用读写操作将c盘中的数据写到d盘中

*/

 

import java.io.*;

 

class Test2

{

       publicstatic void main(String[] args)throws IOException

       {

              copy_2();

       }

 

       //使用读一个字符写一个字符的方法，较慢

       publicstatic void copy_1() throws IOException

       {

              //创建目的地

              FileWriterfw = new FileWriter("Demo1_copy.txt");

             

              //关联文件

              FileReaderfr =new FileReader("Demo1.java");

             

              //文件读写操作

              for(intch=0;(ch=fr.read())!=-1;)

              {

                     fw.write(ch);

              }

             

              //关闭

              fw.close();

              fr.close();

       }

 

       //使用先存，再读的方法

       publicstatic void copy_2()

       {

              //创建引用

              FileWriterfw = null;

              FileReaderfr = null;         

             

              try

              {

                     //创建对象

                     fw= new FileWriter("Demo2_copy.txt");

                     fr= new FileReader("Demo2.java");

                    

                     //创建存储区域

                     char[]  buf = new char[1024];

                     //读写

                     for(intlen=0;(len=fr.read(buf))!=-1;)

                     {

                            fw.write(buf,0,len);    

                     }                          

              }

              catch(IOException e)

              {

                     System.out.println(e.toString());

              }

              finally

              {

                     if(fw!=null)

                            try

                            {

                                   fw.close();

                            }

                            catch(IOException e)

                            {

                                   System.out.println(e.toString());

                            }

                     if(fr!=null)

                            try

                            {

                                   fr.close();

                            }

                            catch(IOException e)

                            {

                                   System.out.println(e.toString());

                            }

              }

       }

}