JAVA高级视频_IO输入与输出_第一部分(System、Runtime、Date、Calendar、MathRandom、IO输入输出与概述、文件的续写、FileReader、复制文件、)...

一、IO输入与输出_System类

例子：TestSystem.java

 1 package com.shanhw.javaEnhance;
 2
 3 import java.util.Properties;
 4
 5 /*
 6  * System：类中的方法和属性都是静态的。
 7  * Out：代表标准输出，默认是控制台。
 8  * In：标准输入，默认是键盘。
 9  *
10  * 描述系统一些信息
11  * 获取系统属性信心：Properties getProperties()
12  */
13 public class TestSystem {
14     public static void main(String[] args) {
15         // 因为 Properties 是Hashtable的子类，也就是Map集合的子类对象
16         // 那么就是通过Map的方法取出该集合的元素
17         // 该集合里面存储的都是字符串，没有泛型定义
18         Properties prop = System.getProperties();
19
20         // 如何在系统中自定义一些特有的信息
21         prop.setProperty("shanhwKey"," shanhwValue");
22
23         // 获取指定属性信息
24         String val = prop.getProperty("os.name");
25         System.out.println(val);
26
27         // 可不可以再JVM启动时，动态的加载一些属性信息呢？
28         String value = prop.getProperty("Tecent");
29         // java -DTecent=TMQQ TestSystem(在执行的时候)
30
31         // 获取所有系统属性信息
32         for(Object obj : prop.keySet()){
33             String valu = (String)prop.get(obj);
34             System.out.println(obj + "：：" + valu);        }
35         }
36 }

二、IO输入与输出_Runtime对象

注意：getRuntime();返回与当前Java应用程序相关的运行时对象。RunTime对象、该类并没有提供构造函数、说明不可以new对象，那么会直接想到该类中的方法是静态的发现该类中还有非静态方法说明该类肯定会提供了方法获取本类对象。而且该方法是静态的，并返回值类型是本类类型，单例模式

例子：TestRunTime.java

 1 package com.shanhw.javaEnhance;
 2
 3
 4 /*
 5  * RunTime对象
 6  * 该类并没有提供构造函数
 7  * 说明不可以new对象，那么会直接想到该类中的方法是静态的
 8  * 发现该类中还有非静态方法
 9  * 说明该类肯定会提供了方法获取本类对象。而且该方法是静态的，并返回值类型是本类类型
10  * 单例模式
11  */
12 public class TestRunTime {
13     public static void main(String[] args) throws Exception {
14         Runtime r = Runtime.getRuntime();
15         Process p = r.exec("D:\\Program Files (x86)\\Baofeng\\StormPlayer\\StormPlayer.exe D:\\TDDOWNLOAD\\Movie\\少年派的奇幻漂流.rmvb");
16
17         Thread.sleep(4000);
18         p.destroy();
19     }
20 }

三、IO输入与输出_Date对象

例子：TestDate.java

 1 package com.shanhw.javaEnhance;
 2
 3 import java.text.SimpleDateFormat;
 4 import java.util.Date;
 5
 6 public class TestDate {
 7     public static void main(String[] args) {
 8         Date date = new Date();
 9         SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 E hh:mm:sss");
10         String fDate = sdf.format(date);
11         System.out.println(fDate);
12     }
13 }

四、IO输入与输出_Calendar对象

对应的方法：

static Clendar getInstance() 使用默认时区和语言环境获得一个日历

static Clendar getInstance(Locale aLocale) 使用默认时区和指定语言环境获得一个日历

static Clendar getInstance(TimeZone zone) 使用指定时区和默认语言环境获得一个日历

static Clendar getInstance(TimeZone zone,Locale aLocale ) 使用指定时区和语言环境获得一个日历

例子：TestCalendar.java

 1 package com.shanhw.javaEnhance;
 2
 3 import java.util.Calendar;
 4
 5 public class TestCalendar {
 6
 7     public static void main(String[] args) {
 8         Calendar c = Calendar.getInstance();
 9         c.set(2012, 2, 3);
10         // add(int field, int amount)  根据日历的规则，为给定的日历字段添加或减去指定的时间量
11         printCalendar(c);
12         // 1、获取任意年的二月有多少天
13         int year = 2011;
14         c.set(year, 2,1);
15         c.add(Calendar.DAY_OF_MONTH,-1);
16         // 2、获取昨天的这个日期
17         c.add(Calendar.DAY_OF_MONTH,-1);
18         // 有效上课天数
19
20     }
21     public static void printCalendar(Calendar c){
22         // 查表方法
23         String [] months = {"一月","二月","三月","四月",
24                                             "五月","六月","七月","八月",
25                                             "九月","十月","十一月","十二月"};
26         String [] weeks = {"","星期日","星期一","星期二","星期三","星期四",
27                                         "星期五","星期六"};
28         sop(c.get(Calendar.YEAR) + "年");
29         sop(months[c.get(Calendar.MONTH)]);
30         sop(c.get(Calendar.DAY_OF_MONTH) + "日");
31         sop(weeks[c.get(Calendar.DAY_OF_WEEK)]);
32     }
33     public static void sop(Object o)
34     {
35         System.out.println(o);
36     }
37 }

五、IO输入与输出_MathRandom对象

注意：1、ceil返回大于指定参数的最小整数 2、 floor返回小于指定参数的最大整数 3、四舍五入 round 4、返回第一个参数的第二个参数次幂的值pow(2, 3) 5、// 保留两位小数DecimalFormat df = new DecimalFormat("0.00") double d7 = 1.4587; System.out.println((df.format(d7)));

例子：TestMathDemo.java

 1 package com.shanhw.javaEnhance;
 2
 3 import java.text.DecimalFormat;
 4 import java.util.Random;
 5
 6 public class TestMathDemo {
 7     public static void main(String[] args) {
 8         // ceil返回大于指定参数的最小整数
 9         double d = Math.ceil(16.333);
10         // floor返回小于指定参数的最大整数
11         double d1 = Math.floor(16.333);
12         // 四舍五入
13         long d2 = Math.round(16.533);
14         // 返回第一个参数的第二个参数次幂的值
15         double d3 = Math.pow(2, 3);
16         // 保留两位小数
17         DecimalFormat df = new DecimalFormat("0.00");
18         double d7 = 1.4587;
19         p(df.format(d7));
20         p(d3);
21         p(d);
22         p(d1);
23         p(d2);
24         p("================Random double================");
25         // random 随机数
26         for(int i=0;i<10;i++)
27         {
28             double d4 = Math.random();
29             p(d4);
30         }
31         p("================Random 1================");
32         // 1、
33         for(int i=0;i<100;i++)
34         {
35             int d5 = (int)(Math.random()*10 + 1) ;
36             p(d5);
37         }
38         p("================Random 2================");
39         // 2、
40         Random r = new Random();
41         for(int i=0;i<100;i++)
42         {
43             int d6 = r.nextInt(10) + 1;
44             p(d6);
45         }
46     }
47     public static void  p(Object obj){
48         System.out.println(obj);
49     }
50 }

七、IO输入输出与概述

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

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

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

·流按操作数据分为两种：字节流与字符流

·流按流向分为：输入流，输出流

·字节流的抽象基类：InputStream，OutputStream

·字符流的抽象基类：Reader，Writer

·注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀：如 1、InputStream的子类FileInputStream 2、Reader的子类FileReader

例子：TestFileWriter.java

 1 package com.shanhw.javaEnhance;
 2
 3 import java.io.FileWriter;
 4 import java.io.IOException;
 5
 6 public class TestFileWriter {
 7     public static void main(String[] args) {
 8         FileWriter fw = null;
 9         try
10         {
11             // 创建对象，该对象以初始化，就必须明确要操作的对象
12             // 而且该文件会被创建到指定的文件夹下，如果该目录下有同名文件将被覆盖
13             fw = new FileWriter("E:\\Workspaces\\FileWriterDemo.txt");
14             // 调用write方法，将字符串写入了流中去了
15             fw.write("abc");
16             // 刷新该流的缓冲，将数据刷新到目的地当中去
17             fw.flush();
18         } catch (IOException e)
19         {
20             e.printStackTrace();
21         }finally
22         {
23             try {
24                 if(fw != null)
25                 {
26                     // 关闭流资源，关闭之前刷新缓冲数据
27                     fw.close();
28                 }
29             } catch (IOException e) {
30                 e.printStackTrace();
31             }
32         }
33     }
34
35 }

八、IO输入输出_文件的续写

FileWriter fw = new FileWriter("E:\\Workspaces\\FileWriterDemo.txt"，true);

例子：TestFileWriteAppend.java

 1 package com.shanhw.javaEnhance;
 2
 3 import java.io.FileWriter;
 4 import java.io.IOException;
 5
 6 public class TestFileWriteAppend {
 7
 8     /**
 9      * 文件续写
10      */
11     public static void main(String[] args) {
12         FileWriter fw = null;
13         try
14         {
15             // TRUE 代表不覆盖已有的文件，并在已有文件的末尾处，进行数据的续写
16             fw = new FileWriter("E:\\Workspaces\\FileWriterDemo.txt",true);
17             // 调用write方法，将字符串写入了流中去了
18             fw.write("shanhw\r\nwelcome");
19             // 刷新该流的缓冲，将数据刷新到目的地当中去
20             fw.flush();
21         } catch (IOException e)
22         {
23             e.printStackTrace();
24         }finally
25         {
26             try {
27                 if(fw != null)
28                 {
29                     // 关闭流资源，关闭之前刷新缓冲数据
30                     fw.close();
31                 }
32             } catch (IOException e) {
33                 e.printStackTrace();
34             }
35         }
36     }
37
38 }

九、IO输入输出_FileReader

例子：TestFileReader.java

 1 package com.shanhw.javaEnhance;
 2
 3 import java.io.FileReader;
 4 import java.io.IOException;
 5
 6 public class TestFileReader {
 7
 8     /**
 9      * 读取文件
10      */
11     public static void main(String[] args) {
12         FileReader fr = null;
13         try
14         {
15             // 创建一个读取对象，和指定名称的文件相关联
16             fr = new FileReader("E:\\Workspaces\\FileWriterDemo.txt");
17             /*
18             System.out.println("===========1===========");
19             while(true)
20             {
21                 int ch = fr.read();
22                 if(ch == -1)
23                     break;
24                 System.out.println((char)ch);
25             }*/
26             System.out.println("===========2===========");
27             int ch = 0;
28             while((ch = fr.read()) != -1)
29             {
30                 System.out.println("ch = " + (char)ch);
31             }
32         } catch (IOException e)
33         {
34             e.printStackTrace();
35         }finally
36         {
37             try {
38                 if(fr != null)
39                 {
40                     // 关闭流资源，关闭之前刷新缓冲数据
41                     fr.close();
42                 }
43             } catch (IOException e) {
44                 e.printStackTrace();
45             }
46         }
47     }
48
49 }

九、IO输入输出_FileReader_读文件的第二种方式

例子：TestFileReaderSecond.java

 1 package com.shanhw.javaEnhance;
 2
 3 import java.io.FileReader;
 4 import java.io.IOException;
 5
 6 public class TestFileReaderSecond {
 7
 8     /**
 9      * 读取文件
10      */
11     public static void main(String[] args) {
12         FileReader fr = null;
13         try
14         {
15             // 创建一个读取对象，和指定名称的文件相关联
16             fr = new FileReader("E:\\Workspaces\\FileWriterDemo.txt");
17             // 定义一个数组，用于存储
18             char[] c = new char[1024];
19
20             int ch = 0;
21             while((ch = fr.read(c)) != -1)
22             {
23                 // String(char[] value, int offset, int count) 分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
24                 // 读到几个就打印几个
25                 System.out.println(new String(c,0,ch));
26             }
27         } catch (IOException e)
28         {
29             e.printStackTrace();
30         }finally
31         {
32             try {
33                 if(fr != null)
34                 {
35                     // 关闭流资源
36                     fr.close();
37                 }
38             } catch (IOException e) {
39                 e.printStackTrace();
40             }
41         }
42     }
43
44 }

十、IO输入与输出_FileReader＿复制文件

例子：TestIOCopy.java

  1 package com.shanhw.javaEnhance;
  2
  3 import java.io.FileReader;
  4 import java.io.FileWriter;
  5 import java.io.IOException;
  6
  7 public class TestIOCopy {
  8
  9     /**
 10      * 复制文件
 11      * 其实就是将C盘的文件数据存储到D盘的一个文件下面中
 12      * 1、在D盘创建一个文件，用于存储C盘文件中的数据
 13      * 2、定义一个读取流，和C盘文件关联
 14      * 3、通过不断的读写来完成数据的存储
 15      * 4、关闭资源
 16      */
 17     public static void main(String[] args) {
 18         // TODO Auto-generated method stub
 19         copy_First();
 20         copy_Second();
 21     }
 22     /**
 23      * 毕老师建议此方式（定义了缓冲区）
 24      */
 25     public static void copy_Second()
 26     {
 27
 28         FileWriter fw = null;
 29         FileReader fr = null;
 30         try
 31         {
 32              fw = new FileWriter("E:\\Workspaces\\IOPractice_Copy\\FileWriterDemo_Second.txt");
 33              fr = new FileReader("E:\\Workspaces\\FileWriterDemo.txt");
 34              // 定义缓冲区
 35              char [] c = new char[1024];
 36              int num = 0;
 37              while((num = fr.read(c)) != -1)
 38              {
 39                 fw.write(c,0,num);
 40              }
 41         }
 42         catch (IOException e)
 43         {
 44             // TODO Auto-generated catch block
 45             e.printStackTrace();
 46         }
 47         finally
 48         {
 49             try
 50             {
 51                 if(fw != null)
 52                 {
 53                     fw.close();
 54                 }
 55                 if(fr != null)
 56                 {
 57                     fr.close();
 58                 }
 59             }
 60             catch (IOException e)
 61             {
 62                 // TODO Auto-generated catch block
 63                 e.printStackTrace();
 64             }
 65         }
 66
 67     }
 68     /**
 69      * 毕老师不建议此方式
 70      */
 71     public static void copy_First()
 72     {
 73         FileWriter fw = null;
 74         FileReader fr = null;
 75         try
 76         {
 77              fw = new FileWriter("E:\\Workspaces\\IOPractice_Copy\\FileWriterDemo.txt");
 78              fr = new FileReader("E:\\Workspaces\\FileWriterDemo.txt");
 79              int num = 0;
 80              while((num = fr.read()) != -1)
 81              {
 82                 fw.write(num);
 83              }
 84         }
 85         catch (IOException e)
 86         {
 87             // TODO Auto-generated catch block
 88             e.printStackTrace();
 89         }
 90         finally
 91         {
 92             try
 93             {
 94                 if(fw != null)
 95                 {
 96                     fw.close();
 97                 }
 98                 if(fr != null)
 99                 {
100                     fr.close();
101                 }
102             }
103             catch (IOException e)
104             {
105                 // TODO Auto-generated catch block
106                 e.printStackTrace();
107             }
108         }
109     }
110
111 }

转载于:https://www.cnblogs.com/shanhouwang/archive/2013/03/12/2954897.html

JAVA高级视频_IO输入与输出_第一部分(System、Runtime、Date、Calendar、MathRandom、IO输入输出与概述、文件的续写、FileReader、复制文件、)...相关推荐

黑马程序员-JAVA高级视频_IO输入与输出-20天-9(切割合并文件)
package string.test;import java.io.*; import java.util.Vector;/** 切割文件*/ public class SplitFile {pub ...
java基础-基本的输入与输出
java基础-基本的输入与输出作者:尹正杰版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.基本的输出基本的输出,System.out 就是系统的标准输出设备,默认为显示器. 1>. ...
Java从键盘上输入与输出
1 问题以作业题三题为例,需要输入学生的成绩等级,然后反映出相应等级的成绩范围.直接在程序里面写出学生等级的方法不利于做出一些改变,在逻辑上也不符合常理,所以选择设置程序从键盘输入等级然后反馈出相应 ...
全连接层的输入和输出_理解Web应用程序的本质，网络数据流处理与基础网络连接...
前言前面一篇文章,我从整个应用程序的整体以及跟运行环境的关系简单聊了一下我们现在常用的Spring框架的设计基础和原则,其中主要是控制反转和依赖注入,以及容器化编程等概念. 这里我不想去复述这些概念 ...
python如何输入和输出_输入和输出
输出用print()在括号中加上字符串,就可以向屏幕上输出指定的文字.比如输出'hello, world',用代码实现如下: >>> print('hello, world') p ...
matlab为什么生成obj文件,为文件输入和输出创建新的 System object
简介 System object 是派生自 matlab.System 的 MATLAB 类.因此,System object 都继承一个通用公共接口,其中包括标准方法: setup - 初始化对象, ...
(计算机组成原理)第七章输入和输出系统-第一节：I/O系统基本概念和I/O控制方式简介
文章目录一:I/O系统的基本组成 (1)I/O硬件和I/O软件 (2)I/O指令和通道指令二:I/O控制方式三:通道控制方式现代计算机结构大致分为主机和 I/O设备(外设),I/O的意思就是 ...
java缓冲流复制文件_java使用缓冲流复制文件的方法
本文实例为大家分享了java使用缓冲流复制文件的具体代码,供大家参考,具体内容如下 [1] 程序设计 /*------------------------------- 1.缓冲流是一种处理流,用来加 ...
java 文件路径怎么写_java本地文件路径怎么写
1. java里文件路径怎么写 File file = new File("D:\\123.txt"); 你这种不用绝对路径是不行的, 只有一个方法,在web工程启动servlet ...
java 写文件换行_Java写到.txt文件，如何实现换行
http://blog.csdn.net/liangoo7/article/details/7882773 java中写.txt文件,实现换行的几种方法: 1.使用java中的转义符"\r\ ...

JAVA高级视频_IO输入与输出_第一部分(System、Runtime、Date、Calendar、MathRandom、IO输入输出与概述、文件的续写、FileReader、复制文件、)...

JAVA高级视频_IO输入与输出_第一部分(System、Runtime、Date、Calendar、MathRandom、IO输入输出与概述、文件的续写、FileReader、复制文件、)...相关推荐

最新文章

热门文章