黑马程序员——>第十八天<其他对象-io流>

android培训、java培训、期待与您交流-------           

 

不是说是要大家重点的去掌握这个对象以及他的方法，是要教大家一种如何去查阅api如何去使用api中提供的这些对象，并能实现一些小功能，方法简单记一下，有这么多对象出现就可以了。
01其他对象(System)

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启动时，动态加载一些属性信息呢？-D<name>-<value>  以键值对的形式存在
  String v = System.getProperty("haha");

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


  /*
  //获取所有属性信息。
  for(Object obj : prop.keySet())
  {
   String value = (String)prop.get(obj);

   System.out.println(obj+"::"+value);
  }
  */
 }
}

虚拟机在启动时，会走一遍你的系统信息，

02其他对象(Runtime)
  每个java应用程序都有一个runtime类实例，使应用程序能够与其运行的环境相连接。可以通过getRuntime方法获取当前运行时。应用程序不能创建自己的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");exec(执行)：//在单独的进程中执行指定命令和变量
  
  //Thread.sleep(4000); // 等待四秒后再被干掉
  //p.destroy(); // 删掉子进程   秒杀

 }
}

 

 

03其他对象(Date)

import java.util.*;
import java.text.*;
class DateDemo 
{
 public static void main(String[] args) 
 {
  Date d = new Date();
  System.out.println(d);//打印的时间看不懂，希望有些格式。
//DateFormat  日期格式化
  //将模式封装到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);


 }
}

04其他对象(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]);

 

05io流(概述)
IO(Input Output)流

 IO流用来处理设备之间的数据传输
 Java对数据的操作是通过流的方式
 Java用于操作流的对象都在IO包中
 流按操作数据分为两种：字节流与字符流
 流按流向分为：输入流，输出流

  早期io包里出现的都是字节流，因为数据无论是内存中的还是硬盘上的他们的体现形式都是字节。最终落实为二进制数据。为什么要单独出一个字符流概念呢？可以理解为在操作数据时，数据当中有好多种，其中有一部分涉及到文本数据，为了方便与处理它，单独分裂出来一个字符流。到底哪里方便呢？
java技术在字节流的基础上产生了字符流，可以在内部去融合编码表，在处理文字时就会变的很方便
字符流的对象里边融合了编码表
       处理文字用字符流  图片用字节流   通用字节流

字符流和字节流：

字节流两个基类：  一个输入，一个输出
InputStream   OutputStream

字符流两个基类：
Reader Writer

注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
  如：InputStream的子类FileInputStream
  如：Reader的子类FileReader
 
07io流(FileWriter)

先学习一下字符流的特点。

既然IO流是用于操作数据的，
那么数据的最常见体现形式是：文件。

那么先以操作文件为主来演示。

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

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

没有空参数构造函数：你想要操作文件，你想要给文件中写数据，就应该先有文件，所以叫做,该流对象，一被初始化 ，就必须有被操作的文件存在，这就叫做初始化动作，它不需要一创建时是空的，那样没有用，因为没有地方写数据。

 

import java.io.*;
class  FileWriterDemo
{
 public static void main(String[] args) throws IOException
 {
  //创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
  //而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
  //其实该步就是在明确数据要存放的目的地。
  FileWriter fw = new FileWriter("demo.txt");

  //调用write方法，将字符串写入到流中。   没有直接写到txt中而是写到了内存当中
  fw.write("abcde");

  //刷新流对象中的缓冲中的数据。
  //将数据刷到目的地中。
  //fw.flush();


  //关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。
  //将数据刷到目的地中。
  //和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
  fw.close();
 }
}
//都涉及到io异常

08io流(io异常处理方式)
/*
IO异常的处理方式。
*/

import java.io.*;

class  FileWriterDemo2
{
 public static void main(String[] args) 
 {
  FileWriter fw = null; // 在外面进行引用，在try中进行初始化   作用于整个函数
  try
  {
   fw = new FileWriter("demo.txt");
   fw.write("abcdefg");

  }
  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异常，无论读还是写，还有创建

09io流(文件的续写)

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

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();
 }
}

 

10io流(文本文件读取方式一)

 

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(char)ch);
  }

  fr.close();


 }
}

读一个，打印一下        效率很低

11io流(文本文件读取方式二)

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

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];   //一个字符俩字节  1024*2那就是2k

  int num = 0;
  while((num=fr.read(buf))!=-1)
  {
   System.out.println(new String(buf,0,num));   //读几个  打印几个
  }
  

  fr.close();
 }
}
fr.read(buf)  //把流关联的数据读一个存到数组中去

 

读一个，存一下，存满后再全打印出去 第二种读取方式好

12io流(拷贝文本文件)

//将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_2();
 }


 public static void copy_2()
 {
  FileWriter fw = null;  // 在try外面先定义好引用
  FileReader fr = null;   //局部变量都要初始化一下，所以最好定义成null
  try
  {
   fw = new FileWriter("SystemDemo_copy.txt");   //初始化
   fr = new FileReader("SystemDemo.java");

   char[] buf = new char[1024];   //在内存中定义一个缓冲区，就是一个数组

   int len = 0;   //不知道有多少数据   就写 len= 0
   while((len=fr.read(buf))!=-1)  //往数组里边装
   {
    fw.write(buf,0,len);  //将数组中的内容写到流里边去   从哪开始，写几个
//你数组当中，一共有1024个格子，而你就读到了4个字符，就装了4个格子，1020个格子都是空的。将1024有数据没数据全写到目的地里去了，太大了，只要写有效个数据就可以了。
   }
  }
  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)
    {
    }
  }//标准异常处理动作
 }

 //从C盘读一个字符，就往D盘写一个字符。
 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培训、期待与您交流-------