w250shini11
w250shini11

java中的IO整理

转载地址：http://www.cnblogs.com/rollenholt/archive/2011/09/11/2173787.html     非常感谢原创作者


java中的IO整理

写在前面：本文章基本覆盖了java IO的全部内容，java新IO没有涉及，因为我想和这个分开，以突出那个的重要性，新IO哪一篇文章还没有开始写，估计很快就能和大家见面。照旧，文章依旧以例子为主，因为讲解内容的java书很多了，我觉的学以致用才是真。代码是写出来的，不是看出来的。

最后欢迎大家提出意见和建议。

【案例1】创建一个新文件

?
1
2
3
4
5
6
7
8
9
10
11
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) {
         File f= new  File( "D:\\hello.txt" );
         try {
             f.createNewFile();
         } catch  (Exception e) {
             e.printStackTrace();
         }
     }
}

【运行结果】：

程序运行之后，在d盘下会有一个名字为hello.txt的文件。

【案例2】File类的两个常量

?
1
2
3
4
5
6
7
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) {
         System.out.println(File.separator);
         System.out.println(File.pathSeparator);
     }
}

【运行结果】：

\

;

此处多说几句：有些同学可能认为，我直接在windows下使用\进行分割不行吗？当然是可以的。但是在linux下就不是\了。所以，要想使得我们的代码跨平台，更加健壮，所以，大家都采用这两个常量吧，其实也多写不了几行。呵呵、

现在我们使用File类中的常量改写上面的代码：

?
1
2
3
4
5
6
7
8
9
10
11
12
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) {
         String fileName= "D:" +File.separator+ "hello.txt" ;
         File f= new  File(fileName);
         try {
             f.createNewFile();
         } catch  (Exception e) {
             e.printStackTrace();
         }
     }
}

你看，没有多写多少吧，呵呵。所以建议使用File类中的常量。

 

删除一个文件

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
  * 删除一个文件
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) {
         String fileName= "D:" +File.separator+ "hello.txt" ;
         File f= new  File(fileName);
         if (f.exists()){
             f.delete();
         } else {
             System.out.println( "文件不存在" );
         }
         
     }
}

创建一个文件夹

?
1
2
3
4
5
6
7
8
9
10
11
/**
  * 创建一个文件夹
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) {
         String fileName= "D:" +File.separator+ "hello" ;
         File f= new  File(fileName);
         f.mkdir();
     }
}

【运行结果】：

D盘下多了一个hello文件夹

 

列出指定目录的全部文件（包括隐藏文件）：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
  * 使用list列出指定目录的全部文件
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) {
         String fileName= "D:" +File.separator;
         File f= new  File(fileName);
         String[] str=f.list();
         for  ( int  i = 0 ; i < str.length; i++) {
             System.out.println(str[i]);
         }
     }
}

【运行结果】：

$RECYCLE.BIN

360

360Downloads

360Rec

360SoftMove

Config.Msi

da

Downloads

DriversBackup

eclipse

java web整合开发和项目实战

Lenovo

MSOCache

Program

Program Files

python

RECYGLER.{8F92DA15-A229-A4D5-B5CE-5280C8B89C19}

System Volume Information

Tomcat6

var

vod_cache_data

新建文件夹

（你的运行结果应该和这个不一样的，呵呵）

但是使用list返回的是String数组，。而且列出的不是完整路径，如果想列出完整路径的话，需要使用listFiles.他返回的是File的数组

列出指定目录的全部文件（包括隐藏文件）：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
  * 使用listFiles列出指定目录的全部文件
  * listFiles输出的是完整路径
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) {
         String fileName= "D:" +File.separator;
         File f= new  File(fileName);
         File[] str=f.listFiles();
         for  ( int  i = 0 ; i < str.length; i++) {
             System.out.println(str[i]);
         }
     }
}

【运行结果】：

D:\$RECYCLE.BIN

D:\360

D:\360Downloads

D:\360Rec

D:\360SoftMove

D:\Config.Msi

D:\da

D:\Downloads

D:\DriversBackup

D:\eclipse

D:\java web整合开发和项目实战

D:\Lenovo

D:\MSOCache

D:\Program

D:\Program Files

D:\python

D:\RECYGLER.{8F92DA15-A229-A4D5-B5CE-5280C8B89C19}

D:\System Volume Information

D:\Tomcat6

D:\var

D:\vod_cache_data

D:\新建文件夹

通过比较可以指定，使用listFiles更加方便、

 

判断一个指定的路径是否为目录

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
  * 使用isDirectory判断一个指定的路径是否为目录
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) {
         String fileName= "D:" +File.separator;
         File f= new  File(fileName);
         if (f.isDirectory()){
             System.out.println( "YES" );
         } else {
             System.out.println( "NO" );
         }
     }
}

【运行结果】：YES

 

搜索指定目录的全部内容

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/**
  * 列出指定目录的全部内容
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) {
         String fileName= "D:" +File.separator;
         File f= new  File(fileName);
         print(f);
     }
     public  static  void  print(File f){
         if (f!= null ){
             if (f.isDirectory()){
                 File[] fileArray=f.listFiles();
                 if (fileArray!= null ){
                     for  ( int  i = 0 ; i < fileArray.length; i++) {
                         //递归调用
                         print(fileArray[i]);
                     }
                 }
             }
             else {
                 System.out.println(f);
             }
         }
     }
}

【运行结果】：

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\framepages\web4welcome_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\help_005fhome_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\help_005fhome_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\home_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\home_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\index_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\index_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\login_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\login_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\modify_005fuser_005finfo_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\modify_005fuser_005finfo_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\register_005fnotify_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\register_005fnotify_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\sign_005fup_jsp.class

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\sign_005fup_jsp.java

D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\transit_jsp.class

……

 

【使用RandomAccessFile写入文件】

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
  * 使用RandomAccessFile写入文件
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) throws  IOException {
         String fileName= "D:" +File.separator+ "hello.txt" ;
         File f= new  File(fileName);
         RandomAccessFile demo= new  RandomAccessFile(f, "rw" );
         demo.writeBytes( "asdsad" );
         demo.writeInt( 12 );
         demo.writeBoolean( true );
         demo.writeChar( 'A' );
         demo.writeFloat( 1 .21f);
         demo.writeDouble( 12.123 );
         demo.close();  
     }
}

如果你此时打开hello。txt查看的话，会发现那是乱码。

 

字节流

【向文件中写入字符串】

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
  * 字节流
  * 向文件中写入字符串
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) throws  IOException {
         String fileName= "D:" +File.separator+ "hello.txt" ;
         File f= new  File(fileName);
         OutputStream out = new  FileOutputStream(f);
         String str= "你好" ;
         byte [] b=str.getBytes();
         out.write(b);
         out.close();
     }
}

查看hello.txt会看到“你好”

当然也可以一个字节一个字节的写。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
  * 字节流
  * 向文件中一个字节一个字节的写入字符串
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) throws  IOException {
         String fileName= "D:" +File.separator+ "hello.txt" ;
         File f= new  File(fileName);
         OutputStream out = new  FileOutputStream(f);
         String str= "你好" ;
         byte [] b=str.getBytes();
         for  ( int  i = 0 ; i < b.length; i++) {
             out.write(b[i]);
         }
         out.close();
     }
}

结果还是：“你好”

 

向文件中追加新内容：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
  * 字节流
  * 向文件中追加新内容：
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) throws  IOException {
         String fileName= "D:" +File.separator+ "hello.txt" ;
         File f= new  File(fileName);
         OutputStream out = new  FileOutputStream(f, true );
         String str= "Rollen" ;
         //String str="\r\nRollen";  可以换行
         byte [] b=str.getBytes();
         for  ( int  i = 0 ; i < b.length; i++) {
             out.write(b[i]);
         }
         out.close();
     }
}

【运行结果】：

你好Rollen

 

【读取文件内容】

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
  * 字节流
  * 读文件内容
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) throws  IOException {
         String fileName= "D:" +File.separator+ "hello.txt" ;
         File f= new  File(fileName);
         InputStream in= new  FileInputStream(f);
         byte [] b= new  byte [ 1024 ];
         in.read(b);
         in.close();
         System.out.println( new  String(b));
     }
}

【运行结果】

你好Rollen

Rollen_

但是这个例子读取出来会有大量的空格，我们可以利用in.read(b);的返回值来设计程序。如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
  * 字节流
  * 读文件内容
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) throws  IOException {
         String fileName= "D:" +File.separator+ "hello.txt" ;
         File f= new  File(fileName);
         InputStream in= new  FileInputStream(f);
         byte [] b= new  byte [ 1024 ];
         int  len=in.read(b);
         in.close();
         System.out.println( "读入长度为：" +len);
         System.out.println( new  String(b, 0 ,len));
     }
}

【运行结果】：

读入长度为：18

你好Rollen

Rollen

 

读者观察上面的例子可以看出，我们预先申请了一个指定大小的空间，但是有时候这个空间可能太小，有时候可能太大，我们需要准确的大小，这样节省空间，那么我们可以这样干：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
  * 字节流
  * 读文件内容,节省空间
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) throws  IOException {
         String fileName= "D:" +File.separator+ "hello.txt" ;
         File f= new  File(fileName);
         InputStream in= new  FileInputStream(f);
         byte [] b= new  byte [( int )f.length()];
         in.read(b);
         System.out.println( "文件长度为：" +f.length());
         in.close();
         System.out.println( new  String(b));
     }
}

文件长度为：18

你好Rollen

Rollen

 

将上面的例子改为一个一个读：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
  * 字节流
  * 读文件内容,节省空间
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) throws  IOException {
         String fileName= "D:" +File.separator+ "hello.txt" ;
         File f= new  File(fileName);
         InputStream in= new  FileInputStream(f);
         byte [] b= new  byte [( int )f.length()];
         for  ( int  i = 0 ; i < b.length; i++) {
             b[i]=( byte )in.read();
         }
         in.close();
         System.out.println( new  String(b));
     }
}

输出的结果和上面的一样。

 

细心的读者可能会发现，上面的几个例子都是在知道文件的内容多大，然后才展开的，有时候我们不知道文件有多大，这种情况下，我们需要判断是否独到文件的末尾。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
  * 字节流
  *读文件
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) throws  IOException {
         String fileName= "D:" +File.separator+ "hello.txt" ;
         File f= new  File(fileName);
         InputStream in= new  FileInputStream(f);
         byte [] b= new  byte [ 1024 ];
         int  count = 0 ;
         int  temp= 0 ;
         while ((temp=in.read())!=(- 1 )){
             b[count++]=( byte )temp;
         }
         in.close();
         System.out.println( new  String(b));
     }
}

【运行结果】

你好Rollen

Rollen_

提醒一下，当独到文件末尾的时候会返回-1.正常情况下是不会返回-1的

 

字符流

【向文件中写入数据】

现在我们使用字符流

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
  * 字符流
  * 写入数据
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) throws  IOException {
         String fileName= "D:" +File.separator+ "hello.txt" ;
         File f= new  File(fileName);
         Writer out = new  FileWriter(f);
         String str= "hello" ;
         out.write(str);
         out.close();
     }
}

当你打开hello。txt的时候，会看到hello

其实这个例子上之前的例子没什么区别，只是你可以直接输入字符串，而不需要你将字符串转化为字节数组。

当你如果想问文件中追加内容的时候，可以使用将上面的声明out的哪一行换为：

Writer out =new FileWriter(f,true);

这样，当你运行程序的时候，会发现文件内容变为：

hellohello如果想在文件中换行的话，需要使用“\r\n”

比如将str变为String str="\r\nhello";

这样文件追加的str的内容就会换行了。

 

从文件中读内容：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
  * 字符流
  * 从文件中读出内容
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) throws  IOException {
         String fileName= "D:" +File.separator+ "hello.txt" ;
         File f= new  File(fileName);
         char [] ch= new  char [ 100 ];
         Reader read= new  FileReader(f);
         int  count=read.read(ch);
         read.close();
         System.out.println( "读入的长度为：" +count);
         System.out.println( "内容为" + new  String(ch, 0 ,count));
     }
}

【运行结果】：

读入的长度为：17

内容为hellohello

hello

 

当然最好采用循环读取的方式，因为我们有时候不知道文件到底有多大。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
  * 字符流
  * 从文件中读出内容
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) throws  IOException {
         String fileName= "D:" +File.separator+ "hello.txt" ;
         File f= new  File(fileName);
         char [] ch= new  char [ 100 ];
         Reader read= new  FileReader(f);
         int  temp= 0 ;
         int  count= 0 ;
         while ((temp=read.read())!=(- 1 )){
             ch[count++]=( char )temp;
         }
         read.close();
         System.out.println( "内容为" + new  String(ch, 0 ,count));
     }
}

运行结果：

内容为hellohello

hello

 

关于字节流和字符流的区别

实际上字节流在操作的时候本身是不会用到缓冲区的，是文件本身的直接操作的，但是字符流在操作的 时候下后是会用到缓冲区的，是通过缓冲区来操作文件的。

读者可以试着将上面的字节流和字符流的程序的最后一行关闭文件的代码注释掉，然后运行程序看看。你就会发现使用字节流的话，文件中已经存在内容，但是使用字符流的时候，文件中还是没有内容的，这个时候就要刷新缓冲区。

使用字节流好还是字符流好呢？

答案是字节流。首先因为硬盘上的所有文件都是以字节的形式进行传输或者保存的，包括图片等内容。但是字符只是在内存中才会形成的，所以在开发中，字节流使用广泛。

文件的复制

其实ＤＯＳ下就有一个文件复制功能，比如我们想把ｄ盘下面的ｈｅｌｌｏ．ｔｘｔ文件复制到d盘下面的rollen.txt文件中，那么我们就可以使用下面的命令：

copy d:\hello.txt d:\rollen.txt

运行之后你会在d盘中看见hello.txt.，并且两个文件的内容是一样的，（这是屁话）

 

下面我们使用程序来复制文件吧。

基本思路还是从一个文件中读入内容，边读边写入另一个文件，就是这么简单。、

首先编写下面的代码：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
  * 文件的复制
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) throws  IOException {
         if (args.length!= 2 ){
             System.out.println( "命令行参数输入有误，请检查" );
             System.exit( 1 );
         }
         File file1= new  File(args[ 0 ]);
         File file2= new  File(args[ 1 ]);
         
         if (!file1.exists()){
             System.out.println( "被复制的文件不存在" );
             System.exit( 1 );
         }
         InputStream input= new  FileInputStream(file1);
         OutputStream output= new  FileOutputStream(file2);
         if ((input!= null )&&(output!= null )){
             int  temp= 0 ;
             while ((temp=input.read())!=(- 1 )){
                 output.write(temp);
             }
         }
         input.close();
         output.close();
     }
}

然后在命令行下面

javac hello.java

java hello d:\hello.txt d:\rollen.txt

现在你就会在d盘看到rollen。txt了，

OutputStreramWriter 和InputStreamReader类

整个IO类中除了字节流和字符流还包括字节和字符转换流。

OutputStreramWriter将输出的字符流转化为字节流

InputStreamReader将输入的字节流转换为字符流

但是不管如何操作，最后都是以字节的形式保存在文件中的。

 

将字节输出流转化为字符输出流

?
1
2
3
4
5
6
7
8
9
10
11
12
13
/**
  * 将字节输出流转化为字符输出流
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) throws  IOException {
         String fileName= "d:" +File.separator+ "hello.txt" ;
         File file= new  File(fileName);
         Writer out= new  OutputStreamWriter( new  FileOutputStream(file));
         out.write( "hello" );
         out.close();
     }
}

运行结果：文件中内容为：hello

将字节输入流变为字符输入流

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
  * 将字节输入流变为字符输入流
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) throws  IOException {
         String fileName= "d:" +File.separator+ "hello.txt" ;
         File file= new  File(fileName);
         Reader read= new  InputStreamReader( new  FileInputStream(file));
         char [] b= new  char [ 100 ];
         int  len=read.read(b);
         System.out.println( new  String(b, 0 ,len));
         read.close();
     }
}

【运行结果】：hello

前面列举的输出输入都是以文件进行的，现在我们以内容为输出输入目的地，使用内存操作流

ByteArrayInputStream 主要将内容写入内容

ByteArrayOutputStream  主要将内容从内存输出

使用内存操作流将一个大写字母转化为小写字母

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
  * 使用内存操作流将一个大写字母转化为小写字母
  * */
import  java.io.*;
class  hello{
     public  static  void  main(String[] args) throws  IOException {
         String str= "ROLLENHOLT" ;
         ByteArrayInputStream input= new  ByteArrayInputStream(str.getBytes());
         ByteArrayOutputStream output= new  ByteArrayOutputStream();
         int  temp= 0 ;
         while ((temp=input.read())!=- 1 ){
             char  ch=( char )temp;
             output.write(Character.toLowerCase(ch));
         }
         String outStr=output.toString();
         input.close();
         output.close();
         System.out.println(outStr);
     }
}

【运行结果】：

rollenholt

内容操作流一般使用来生成一些临时信息采用的，这样可以避免删除的麻烦。

管道流

管道流主要可以进行两个线程之间的通信。

PipedOutputStream 管道输出流

PipedInputStream 管道输入流

验证管道流
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
/**
  * 验证管道流
  * */
import  java.io.*;
 
/**
  * 消息发送类
  * */
class  Send implements  Runnable{
     private  PipedOutputStream out= null ;
     public  Send() {
         out= new  PipedOutputStream();
     }
     public  PipedOutputStream getOut(){
         return  this .out;
     }
     public  void  run(){
         String message= "hello , Rollen" ;
         try {
             out.write(message.getBytes());
         } catch  (Exception e) {
             e.printStackTrace();
         } try {
             out.close();
         } catch  (Exception e) {
             e.printStackTrace();
         }
     }
}
 
/**
  * 接受消息类
  * */
class  Recive implements  Runnable{
     private  PipedInputStream input= null ;
     public  Recive(){
         this .input= new  PipedInputStream();
     }
     public  PipedInputStream getInput(){
         return  this .input;
     }
     public  void  run(){
         byte [] b= new  byte [ 1000 ];
         int  len= 0 ;
         try {
             len= this .input.read(b);
         } catch  (Exception e) {
             e.printStackTrace();
         } try {
             input.close();
         } catch  (Exception e) {
             e.printStackTrace();
         }
         System.out.println( "接受的内容为 " +( new  String(b, 0 ,len)));
     }
}
/**
  * 测试类
  * */
class  hello{
     public  static  void  main(String[] args) throws  IOException {
         Send send= new  Send();
         Recive recive= new  Recive();
         try {
//管道连接
             send.getOut().connect(recive.getInput());
         } catch  (Exception e) {
             e.printStackTrace();
         }
         new  Thread(send).start();
         new  Thread(recive).start();
     }
}

【运行结果】：

接受的内容为 hello , Rollen

打印流

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
  * 使用PrintStream进行输出
  * */
import  java.io.*;
 
class  hello {
     public  static  void  main(String[] args) throws  IOException {
         PrintStream print = new  PrintStream( new  FileOutputStream( new  File( "d:"
                 + File.separator + "hello.txt" )));
         print.println( true );
         print.println( "Rollen" );
         print.close();
     }
}

【运行结果】：

true

Rollen

当然也可以格式化输出

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
  * 使用PrintStream进行输出
  * 并进行格式化
  * */
import  java.io.*;
class  hello {
     public  static  void  main(String[] args) throws  IOException {
         PrintStream print = new  PrintStream( new  FileOutputStream( new  File( "d:"
                 + File.separator + "hello.txt" )));
         String name= "Rollen" ;
         int  age= 20 ;
         print.printf( "姓名：%s. 年龄：%d." ,name,age);
         print.close();
     }
}

【运行结果】：

姓名：Rollen. 年龄：20.

 

使用OutputStream向屏幕上输出内容

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
  * 使用OutputStream向屏幕上输出内容
  * */
import  java.io.*;
class  hello {
     public  static  void  main(String[] args) throws  IOException {
         OutputStream out=System.out;
         try {
             out.write( "hello" .getBytes());
         } catch  (Exception e) {
             e.printStackTrace();
         }
         try {
             out.close();
         } catch  (Exception e) {
             e.printStackTrace();
         }
     }
}

【运行结果】：

hello

 

输入输出重定向

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import  java.io.File;
import  java.io.FileNotFoundException;
import  java.io.FileOutputStream;
import  java.io.PrintStream;
 
/**
  * 为System.out.println()重定向输出
  * */
public  class  systemDemo{
     public  static  void  main(String[] args){
         // 此刻直接输出到屏幕
         System.out.println( "hello" );
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         try {
             System.setOut( new  PrintStream( new  FileOutputStream(file)));
         } catch (FileNotFoundException e){
             e.printStackTrace();
         }
         System.out.println( "这些内容在文件中才能看到哦！" );
     }
}

【运行结果】：

eclipse的控制台输出的是hello。然后当我们查看d盘下面的hello.txt文件的时候，会在里面看到：这些内容在文件中才能看到哦！

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import  java.io.File;
import  java.io.FileNotFoundException;
import  java.io.FileOutputStream;
import  java.io.PrintStream;
 
/**
  * System.err重定向 这个例子也提示我们可以使用这种方法保存错误信息
  * */
public  class  systemErr{
     public  static  void  main(String[] args){
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         System.err.println( "这些在控制台输出" );
         try {
             System.setErr( new  PrintStream( new  FileOutputStream(file)));
         } catch (FileNotFoundException e){
             e.printStackTrace();
         }
         System.err.println( "这些在文件中才能看到哦！" );
     }
}

【运行结果】：

你会在eclipse的控制台看到红色的输出：“这些在控制台输出”，然后在d盘下面的hello.txt中会看到：这些在文件中才能看到哦！

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.FileNotFoundException;
import  java.io.IOException;
 
/**
  * System.in重定向
  * */
public  class  systemIn{
     public  static  void  main(String[] args){
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         if (!file.exists()){
             return ;
         } else {
             try {
                 System.setIn( new  FileInputStream(file));
             } catch (FileNotFoundException e){
                 e.printStackTrace();
             }
             byte [] bytes = new  byte [ 1024 ];
             int  len = 0 ;
             try {
                 len = System.in.read(bytes);
             } catch (IOException e){
                 e.printStackTrace();
             }
             System.out.println( "读入的内容为："  + new  String(bytes, 0 , len));
         }
     }
}

【运行结果】：

前提是我的d盘下面的hello.txt中的内容是：“这些文件中的内容哦！”，然后运行程序，输出的结果为：读入的内容为：这些文件中的内容哦！

 

BufferedReader的小例子

注意： BufferedReader只能接受字符流的缓冲区，因为每一个中文需要占据两个字节，所以需要将System.in这个字节输入流变为字符输入流，采用：

?
BufferedReader buf = new  BufferedReader(
                 new  InputStreamReader(System.in));

下面给一个实例：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import  java.io.BufferedReader;
import  java.io.IOException;
import  java.io.InputStreamReader;
 
/**
  * 使用缓冲区从键盘上读入内容
  * */
public  class  BufferedReaderDemo{
     public  static  void  main(String[] args){
         BufferedReader buf = new  BufferedReader(
                 new  InputStreamReader(System.in));
         String str = null ;
         System.out.println( "请输入内容" );
         try {
             str = buf.readLine();
         } catch (IOException e){
             e.printStackTrace();
         }
         System.out.println( "你输入的内容是："  + str);
     }
}

运行结果：

请输入内容

dasdas

你输入的内容是：dasdas

 

Scanner类

其实我们比较常用的是采用Scanner类来进行数据输入，下面来给一个Scanner的例子吧

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import  java.util.Scanner;
 
/**
  * Scanner的小例子，从键盘读数据
  * */
public  class  ScannerDemo{
     public  static  void  main(String[] args){
         Scanner sca = new  Scanner(System.in);
         // 读一个整数
         int  temp = sca.nextInt();
         System.out.println(temp);
         //读取浮点数
         float  flo=sca.nextFloat();
         System.out.println(flo);
         //读取字符
         //...等等的，都是一些太基础的，就不师范了。
     }
}

其实Scanner可以接受任何的输入流

下面给一个使用Scanner类从文件中读出内容

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import  java.io.File;
import  java.io.FileNotFoundException;
import  java.util.Scanner;
 
/**
  * Scanner的小例子，从文件中读内容
  * */
public  class  ScannerDemo{
     public  static  void  main(String[] args){
 
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         Scanner sca = null ;
         try {
             sca = new  Scanner(file);
         } catch (FileNotFoundException e){
             e.printStackTrace();
         }
         String str = sca.next();
         System.out.println( "从文件中读取的内容是："  + str);
     }
}

【运行结果】：

从文件中读取的内容是：这些文件中的内容哦！

数据操作流DataOutputStream、DataInputStream类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import  java.io.DataOutputStream;
import  java.io.File;
import  java.io.FileOutputStream;
import  java.io.IOException;
 
public  class  DataOutputStreamDemo{
     public  static  void  main(String[] args) throws  IOException{
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         char [] ch = { 'A' , 'B' , 'C'  };
         DataOutputStream out = null ;
         out = new  DataOutputStream( new  FileOutputStream(file));
         for ( char  temp : ch){
             out.writeChar(temp);
         }
         out.close();
     }
}

A B C

现在我们在上面例子的基础上，使用DataInputStream读出内容

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import  java.io.DataInputStream;
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.IOException;
 
public  class  DataOutputStreamDemo{
     public  static  void  main(String[] args) throws  IOException{
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         DataInputStream input = new  DataInputStream( new  FileInputStream(file));
         char [] ch = new  char [ 10 ];
         int  count = 0 ;
         char  temp;
         while ((temp = input.readChar()) != 'C' ){
             ch[count++] = temp;
         }
         System.out.println(ch);
     }
}

【运行结果】：

AB

合并流 SequenceInputStream

SequenceInputStream主要用来将2个流合并在一起，比如将两个txt中的内容合并为另外一个txt。下面给出一个实例：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.FileOutputStream;
import  java.io.IOException;
import  java.io.InputStream;
import  java.io.OutputStream;
import  java.io.SequenceInputStream;
 
/**
  * 将两个文本文件合并为另外一个文本文件
  * */
public  class  SequenceInputStreamDemo{
     public  static  void  main(String[] args) throws  IOException{
         File file1 = new  File( "d:"  + File.separator + "hello1.txt" );
         File file2 = new  File( "d:"  + File.separator + "hello2.txt" );
         File file3 = new  File( "d:"  + File.separator + "hello.txt" );
         InputStream input1 = new  FileInputStream(file1);
         InputStream input2 = new  FileInputStream(file2);
         OutputStream output = new  FileOutputStream(file3);
         // 合并流
         SequenceInputStream sis = new  SequenceInputStream(input1, input2);
         int  temp = 0 ;
         while ((temp = sis.read()) != - 1 ){
             output.write(temp);
         }
         input1.close();
         input2.close();
         output.close();
         sis.close();
     }
}

【运行结果】

结果会在hello.txt文件中包含hello1.txt和hello2.txt文件中的内容。

文件压缩 ZipOutputStream类

先举一个压缩单个文件的例子吧：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.FileOutputStream;
import  java.io.IOException;
import  java.io.InputStream;
import  java.util.zip.ZipEntry;
import  java.util.zip.ZipOutputStream;
 
public  class  ZipOutputStreamDemo1{
     public  static  void  main(String[] args) throws  IOException{
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         File zipFile = new  File( "d:"  + File.separator + "hello.zip" );
         InputStream input = new  FileInputStream(file);
         ZipOutputStream zipOut = new  ZipOutputStream( new  FileOutputStream(
                 zipFile));
         zipOut.putNextEntry( new  ZipEntry(file.getName()));
         // 设置注释
         zipOut.setComment( "hello" );
         int  temp = 0 ;
         while ((temp = input.read()) != - 1 ){
             zipOut.write(temp);
         }
         input.close();
         zipOut.close();
     }
}

【运行结果】

运行结果之前，我创建了一个hello.txt的文件，原本大小56个字节，但是压缩之后产生hello.zip之后，居然变成了175个字节，有点搞不懂。

不过结果肯定是正确的，我只是提出我的一个疑问而已。

上面的这个例子测试的是压缩单个文件，下面的们来看看如何压缩多个文件。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.FileOutputStream;
import  java.io.IOException;
import  java.io.InputStream;
import  java.util.zip.ZipEntry;
import  java.util.zip.ZipOutputStream;
 
/**
  * 一次性压缩多个文件
  * */
public  class  ZipOutputStreamDemo2{
     public  static  void  main(String[] args) throws  IOException{
         // 要被压缩的文件夹
         File file = new  File( "d:"  + File.separator + "temp" );
         File zipFile = new  File( "d:"  + File.separator + "zipFile.zip" );
         InputStream input = null ;
         ZipOutputStream zipOut = new  ZipOutputStream( new  FileOutputStream(
                 zipFile));
         zipOut.setComment( "hello" );
         if (file.isDirectory()){
             File[] files = file.listFiles();
             for ( int  i = 0 ; i < files.length; ++i){
                 input = new  FileInputStream(files[i]);
                 zipOut.putNextEntry( new  ZipEntry(file.getName()
                         + File.separator + files[i].getName()));
                 int  temp = 0 ;
                 while ((temp = input.read()) != - 1 ){
                     zipOut.write(temp);
                 }
                 input.close();
             }
         }
         zipOut.close();
     }
}

【运行结果】

先看看要被压缩的文件吧：

接下来看看压缩之后的：

大家自然想到，既然能压缩，自然能解压缩，在谈解压缩之前，我们会用到一个ZipFile类，先给一个这个例子吧。java中的每一个压缩文件都是可以使用ZipFile来进行表示的

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import  java.io.File;
import  java.io.IOException;
import  java.util.zip.ZipFile;
 
/**
  * ZipFile演示
  * */
public  class  ZipFileDemo{
     public  static  void  main(String[] args) throws  IOException{
         File file = new  File( "d:"  + File.separator + "hello.zip" );
         ZipFile zipFile = new  ZipFile(file);
         System.out.println( "压缩文件的名称为："  + zipFile.getName());
     }
}

【运行结果】：

压缩文件的名称为：d:\hello.zip

 

现在我们呢是时候来看看如何加压缩文件了，和之前一样，先让我们来解压单个压缩文件（也就是压缩文件中只有一个文件的情况），我们采用前面的例子产生的压缩文件hello.zip

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import  java.io.File;
import  java.io.FileOutputStream;
import  java.io.IOException;
import  java.io.InputStream;
import  java.io.OutputStream;
import  java.util.zip.ZipEntry;
import  java.util.zip.ZipFile;
 
/**
  * 解压缩文件（压缩文件中只有一个文件的情况）
  * */
public  class  ZipFileDemo2{
     public  static  void  main(String[] args) throws  IOException{
         File file = new  File( "d:"  + File.separator + "hello.zip" );
         File outFile = new  File( "d:"  + File.separator + "unZipFile.txt" );
         ZipFile zipFile = new  ZipFile(file);
         ZipEntry entry = zipFile.getEntry( "hello.txt" );
         InputStream input = zipFile.getInputStream(entry);
         OutputStream output = new  FileOutputStream(outFile);
         int  temp = 0 ;
         while ((temp = input.read()) != - 1 ){
             output.write(temp);
         }
         input.close();
         output.close();
     }
}

【运行结果】：

解压缩之前：

这个压缩文件还是175字节

解压之后产生：

又回到了56字节，表示郁闷。

 

现在让我们来解压一个压缩文件中包含多个文件的情况吧

ZipInputStream类

当我们需要解压缩多个文件的时候，ZipEntry就无法使用了，如果想操作更加复杂的压缩文件，我们就必须使用ZipInputStream类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.FileOutputStream;
import  java.io.IOException;
import  java.io.InputStream;
import  java.io.OutputStream;
import  java.util.zip.ZipEntry;
import  java.util.zip.ZipFile;
import  java.util.zip.ZipInputStream;
 
/**
  * 解压缩一个压缩文件中包含多个文件的情况
  * */
public  class  ZipFileDemo3{
     public  static  void  main(String[] args) throws  IOException{
         File file = new  File( "d:"  + File.separator + "zipFile.zip" );
         File outFile = null ;
         ZipFile zipFile = new  ZipFile(file);
         ZipInputStream zipInput = new  ZipInputStream( new  FileInputStream(file));
         ZipEntry entry = null ;
         InputStream input = null ;
         OutputStream output = null ;
         while ((entry = zipInput.getNextEntry()) != null ){
             System.out.println( "解压缩"  + entry.getName() + "文件" );
             outFile = new  File( "d:"  + File.separator + entry.getName());
             if (!outFile.getParentFile().exists()){
                 outFile.getParentFile().mkdir();
             }
             if (!outFile.exists()){
                 outFile.createNewFile();
             }
             input = zipFile.getInputStream(entry);
             output = new  FileOutputStream(outFile);
             int  temp = 0 ;
             while ((temp = input.read()) != - 1 ){
                 output.write(temp);
             }
             input.close();
             output.close();
         }
     }
}

【运行结果】：

被解压的文件：

解压之后再D盘下会出现一个temp文件夹，里面内容：

PushBackInputStream回退流

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import  java.io.ByteArrayInputStream;
import  java.io.IOException;
import  java.io.PushbackInputStream;
 
/**
  * 回退流操作
  * */
public  class  PushBackInputStreamDemo{
     public  static  void  main(String[] args) throws  IOException{
         String str = "hello,rollenholt" ;
         PushbackInputStream push = null ;
         ByteArrayInputStream bat = null ;
         bat = new  ByteArrayInputStream(str.getBytes());
         push = new  PushbackInputStream(bat);
         int  temp = 0 ;
         while ((temp = push.read()) != - 1 ){
             if (temp == ',' ){
                 push.unread(temp);
                 temp = push.read();
                 System.out.print( "(回退"  + ( char ) temp + ") " );
             } else {
                 System.out.print(( char ) temp);
             }
         }
     }
}

【运行结果】：

hello(回退,) rollenholt

?
1
2
3
4
5
6
7
8
/**
  * 取得本地的默认编码
  * */
public  class  CharSetDemo{
     public  static  void  main(String[] args){
         System.out.println( "系统默认编码为："  + System.getProperty( "file.encoding" ));
     }
}

【运行结果】：

系统默认编码为：GBK

 

乱码的产生：

?
import  java.io.File;
import  java.io.FileOutputStream;
import  java.io.IOException;
import  java.io.OutputStream;
 
/**
  * 乱码的产生
  * */
public  class  CharSetDemo2{
     public  static  void  main(String[] args) throws  IOException{
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         OutputStream out = new  FileOutputStream(file);
         byte [] bytes = "你好" .getBytes( "ISO8859-1" );
         out.write(bytes);
         out.close();
     }
}

【运行结果】：

??

 

一般情况下产生乱码，都是由于编码不一致的问题。

对象的序列化

对象序列化就是把一个对象变为二进制数据流的一种方法。

一个类要想被序列化，就行必须实现java.io.Serializable接口。虽然这个接口中没有任何方法，就如同之前的cloneable接口一样。实现了这个接口之后，就表示这个类具有被序列化的能力。

先让我们实现一个具有序列化能力的类吧：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import  java.io.*;
/**
  * 实现具有序列化能力的类
  * */
public  class  SerializableDemo implements  Serializable{
     public  SerializableDemo(){
         
     }
     public  SerializableDemo(String name, int  age){
         this .name=name;
         this .age=age;
     }
     @Override
     public  String toString(){
         return  "姓名：" +name+ "  年龄：" +age;
     }
     private  String name;
     private  int  age;
}

这个类就具有实现序列化能力，

在继续将序列化之前，先将一下ObjectInputStream和ObjectOutputStream这两个类

先给一个ObjectOutputStream的例子吧：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import  java.io.Serializable;
import  java.io.File;
import  java.io.FileOutputStream;
import  java.io.IOException;
import  java.io.ObjectOutputStream;
 
/**
  * 实现具有序列化能力的类
  * */
public  class  Person implements  Serializable{
     public  Person(){
 
     }
 
     public  Person(String name, int  age){
         this .name = name;
         this .age = age;
     }
 
     @Override
     public  String toString(){
         return  "姓名："  + name + "  年龄："  + age;
     }
 
     private  String name;
     private  int  age;
}
/**
  * 示范ObjectOutputStream
  * */
public  class  ObjectOutputStreamDemo{
     public  static  void  main(String[] args) throws  IOException{
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         ObjectOutputStream oos = new  ObjectOutputStream( new  FileOutputStream(
                 file));
         oos.writeObject( new  Person( "rollen" , 20 ));
         oos.close();
     }
}

【运行结果】：

当我们查看产生的hello.txt的时候，看到的是乱码，呵呵。因为是二进制文件。

虽然我们不能直接查看里面的内容，但是我们可以使用ObjectＩｎｐｕｔＳｔｒｅａｍ类查看：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.ObjectInputStream;
 
/**
  * ObjectInputStream示范
  * */
public  class  ObjectInputStreamDemo{
     public  static  void  main(String[] args) throws  Exception{
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         ObjectInputStream input = new  ObjectInputStream( new  FileInputStream(
                 file));
         Object obj = input.readObject();
         input.close();
         System.out.println(obj);
     }
}

【运行结果】

姓名：rollen  年龄：20

 

到底序列化什么内容呢？

其实只有属性会被序列化。

Externalizable接口

被Serializable接口声明的类的对象的属性都将被序列化，但是如果想自定义序列化的内容的时候，就需要实现Externalizable接口。

当一个类要使用Externalizable这个接口的时候，这个类中必须要有一个无参的构造函数，如果没有的话，在构造的时候会产生异常，这是因为在反序列话的时候会默认调用无参的构造函数。

现在我们来演示一下序列化和反序列话：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
package  IO;
 
import  java.io.Externalizable;
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.FileOutputStream;
import  java.io.IOException;
import  java.io.ObjectInput;
import  java.io.ObjectInputStream;
import  java.io.ObjectOutput;
import  java.io.ObjectOutputStream;
 
/**
  * 序列化和反序列化的操作
  * */
public  class  ExternalizableDemo{
     public  static  void  main(String[] args) throws  Exception{
         ser(); // 序列化
         dser(); // 反序列话
     }
 
     public  static  void  ser() throws  Exception{
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         ObjectOutputStream out = new  ObjectOutputStream( new  FileOutputStream(
                 file));
         out.writeObject( new  Person( "rollen" , 20 ));
         out.close();
     }
 
     public  static  void  dser() throws  Exception{
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         ObjectInputStream input = new  ObjectInputStream( new  FileInputStream(
                 file));
         Object obj = input.readObject();
         input.close();
         System.out.println(obj);
     }
}
 
class  Person implements  Externalizable{
     public  Person(){
 
     }
 
     public  Person(String name, int  age){
         this .name = name;
         this .age = age;
     }
 
     @Override
     public  String toString(){
         return  "姓名："  + name + "  年龄："  + age;
     }
 
     // 复写这个方法，根据需要可以保存的属性或者具体内容，在序列化的时候使用
     @Override
     public  void  writeExternal(ObjectOutput out) throws  IOException{
         out.writeObject( this .name);
         out.writeInt(age);
     }
 
     // 复写这个方法，根据需要读取内容 反序列话的时候需要
     @Override
     public  void  readExternal(ObjectInput in) throws  IOException,
             ClassNotFoundException{
         this .name = (String) in.readObject();
         this .age = in.readInt();
     }
 
     private  String name;
     private  int  age;
}

【运行结果】：

姓名：rollen  年龄：20

本例中，我们将全部的属性都保留了下来，

Serializable接口实现的操作其实是吧一个对象中的全部属性进行序列化，当然也可以使用我们上使用是Externalizable接口以实现部分属性的序列化，但是这样的操作比较麻烦，

当我们使用Serializable接口实现序列化操作的时候，如果一个对象的某一个属性不想被序列化保存下来，那么我们可以使用transient关键字进行说明：

下面举一个例子：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package  IO;
 
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.FileOutputStream;
import  java.io.ObjectInputStream;
import  java.io.ObjectOutputStream;
import  java.io.Serializable;
 
/**
  * 序列化和反序列化的操作
  * */
public  class  serDemo{
     public  static  void  main(String[] args) throws  Exception{
         ser(); // 序列化
         dser(); // 反序列话
     }
 
     public  static  void  ser() throws  Exception{
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         ObjectOutputStream out = new  ObjectOutputStream( new  FileOutputStream(
                 file));
         out.writeObject( new  Person1( "rollen" , 20 ));
         out.close();
     }
 
     public  static  void  dser() throws  Exception{
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         ObjectInputStream input = new  ObjectInputStream( new  FileInputStream(
                 file));
         Object obj = input.readObject();
         input.close();
         System.out.println(obj);
     }
}
 
class  Person1 implements  Serializable{
     public  Person1(){
 
     }
 
     public  Person1(String name, int  age){
         this .name = name;
         this .age = age;
     }
 
     @Override
     public  String toString(){
         return  "姓名："  + name + "  年龄："  + age;
     }
 
     // 注意这里
     private  transient  String name;
     private  int  age;
}

【运行结果】：

姓名：null  年龄：20

最后在给一个序列化一组对象的例子吧：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
import  java.io.File;
import  java.io.FileInputStream;
import  java.io.FileOutputStream;
import  java.io.ObjectInputStream;
import  java.io.ObjectOutputStream;
import  java.io.Serializable;
 
/**
  * 序列化一组对象
  * */
public  class  SerDemo1{
     public  static  void  main(String[] args) throws  Exception{
         Student[] stu = { new  Student( "hello" , 20 ), new  Student( "world" , 30 ),
                 new  Student( "rollen" , 40 ) };
         ser(stu);
         Object[] obj = dser();
         for ( int  i = 0 ; i < obj.length; ++i){
             Student s = (Student) obj[i];
             System.out.println(s);
         }
     }
 
     // 序列化
     public  static  void  ser(Object[] obj) throws  Exception{
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         ObjectOutputStream out = new  ObjectOutputStream( new  FileOutputStream(
                 file));
         out.writeObject(obj);
         out.close();
     }
 
     // 反序列化
     public  static  Object[] dser() throws  Exception{
         File file = new  File( "d:"  + File.separator + "hello.txt" );
         ObjectInputStream input = new  ObjectInputStream( new  FileInputStream(
                 file));
         Object[] obj = (Object[]) input.readObject();
         input.close();
         return  obj;
     }
}
 
class  Student implements  Serializable{
     public  Student(){
 
     }
 
     public  Student(String name, int  age){
         this .name = name;
         this .age = age;
     }
 
     @Override
     public  String toString(){
         return  "姓名：  "  + name + "  年龄："  + age;
     }
 
     private  String name;
     private  int  age;
}

【运行结果】：

姓名：  hello  年龄：20

姓名：  world  年龄：30

姓名：  rollen  年龄：40


你可能感兴趣的:(java中的IO整理)

  • 关于沟通这件事，项目经理不需要每次都面对面进行 流程大师兄
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • mysql禁用远程登录 igotyback mysql
    去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • 向内而求 陈陈_19b4
    10月27日，阴。阅读书目:《次第花开》。作者:希阿荣博堪布，是当今藏传佛家宁玛派最伟大的上师法王，如意宝晋美彭措仁波切颇具影响力的弟子之一。多年以来，赴海内外各地弘扬佛法，以正式授课、现场开示、发表文章等多种方法指导佛学弟子修行佛法。代表作《寂静之道》、《生命这出戏》、《透过佛法看世界》自出版以来一直是佛教类书籍中的畅销书。图片发自App金句:1.佛陀说，一切痛苦的根源在于我们长期以来对自身及外
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • 水平垂直居中的几种方法（总结） LJ小番茄 CSS_玄学语言htmljavascript前端csscss3
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
  • 每日一题——第八十二题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将一个控制台输入的字符串中的所有元音字母复制到另一字符串中#include#include#include#include#defineMAX_INPUT1024boolisVowel(charp);intmain(){charinput[MAX_INPUT];charoutput[MAX_INPUT];printf("请输入一串字符串：\n");fgets(input,sizeof(inp
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • WPF中的ComboBox控件几种数据绑定的方式 互联网打工人no1 wpfc#
    一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
  • 第四天旅游线路预览——从换乘中心到喀纳斯湖 陟彼高冈yu 基于Googleearthstudio的旅游规划和预览旅游
    第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
  • linux sdl windows.h,Windows下的SDL安装 奔跑吧linux内核 linuxsdlwindows.h
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
  • 直抒《紫罗兰永恒花园外传》 雷姆的黑色童话
    没看过《紫罗兰永恒花园》的我莫名的看完了《紫罗兰永恒花园外传》，又莫名的被故事中的姐妹之情狠狠地感动了的一把。感动何在：困苦中相依为命的姐妹二人被迫分离，用一个人的自由换取另一个人的幸福。之后，虽相隔不知几许依旧心心念念彼此牵挂。这种深深的姐妹情谊就是令我为之动容的所在。贝拉和泰勒分别影片开始，海天之间一个孩童凭栏眺望，手中拿着折旧的信纸。镜头一转，挑灯伏案的薇尔莉特正在打字机前奋笔疾书。这些片段
  • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
  • Google earth studio 简介 陟彼高冈yu 旅游
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
  • 直返最高等级与直返APP：无需邀请码的返利新体验 古楼
    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
  • 读《人世间》有感 一0一
    这个寒假，就如同朋友圈中的一段话：一闭眼，一睁眼假期还有5天，在一闭眼一睁眼假期还有12天；再一闭眼一睁眼假期还有20天；不敢睡，不敢睡啊……受疫情影响，这个假期变得漫长又煎熬，我也无时无刻不关注着疫情的变化。当然这样的一个假期，我还真得要感谢周翔，因为他有个爱看书的习惯，所以家里有不少他看过的书，可以让我随意挑选，因此也让我的假期不至于那么无所事事。这次我选了一本梁晓声的《人世间》，作为一名语文
  • SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQLServer数据库sqlserver
    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 【加密社】Solidity 中的事件机制及其应用 加密社 闲侃区块链智能合约区块链
    加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
  • Java实现的基于模板的网页结构化信息精准抽取组件：HtmlExtractor yangshangchuan 信息抽取HtmlExtractor精准抽取信息采集
    HtmlExtractor是一个Java实现的基于模板的网页结构化信息精准抽取组件，本身并不包含爬虫功能，但可被爬虫或其他程序调用以便更精准地对网页结构化信息进行抽取。   HtmlExtractor是为大规模分布式环境设计的，采用主从架构，主节点负责维护抽取规则，从节点向主节点请求抽取规则，当抽取规则发生变化，主节点主动通知从节点，从而能实现抽取规则变化之后的实时动态生效。 如
  • java编程思想 -- 多态 百合不是茶 java多态详解
    一: 向上转型和向下转型 面向对象中的转型只会发生在有继承关系的子类和父类中（接口的实现也包括在这里）。父类：人    子类：男人向上转型： Person p = new Man() ; //向上转型不需要强制类型转化向下转型： Man man =
  • [自动数据处理]稳扎稳打,逐步形成自有ADP系统体系 comsci dp
          对于国内的IT行业来讲,虽然我们已经有了"两弹一星",在局部领域形成了自己独有的技术特征,并初步摆脱了国外的控制...但是前面的路还很长....       首先是我们的自动数据处理系统还无法处理很多高级工程...中等规模的拓扑分析系统也没有完成,更加复杂的
  • storm 自定义 日志文件 商人shang stormclusterlogback
    Storm中的日志级级别默认为INFO，并且，日志文件是根据worker号来进行区分的，这样，同一个log文件中的信息不一定是一个业务的，这样就会有以下两个需求出现： 1. 想要进行一些调试信息的输出 2. 调试信息或者业务日志信息想要输出到一些固定的文件中   不要怕，不要烦恼，其实Storm已经提供了这样的支持，可以通过自定义logback 下的 cluster.xml 来输
  • Extjs3 SpringMVC使用 @RequestBody 标签问题记录 21jhf
    springMVC使用 @RequestBody(required = false) UserVO userInfo 传递json对象数据，往往会出现http 415，400,500等错误，总结一下需要使用ajax提交json数据才行，ajax提交使用proxy，参数为jsonData，不能为params；另外，需要设置Content-type属性为json，代码如下： （由于使用了父类aaa
  • 一些排错方法 文强chu 方法
    1、java.lang.IllegalStateException: Class invariant violation at org.apache.log4j.LogManager.getLoggerRepository(LogManager.java:199)at org.apache.log4j.LogManager.getLogger(LogManager.java:228) at o
  • Swing中文件恢复我觉得很难 小桔子 swing
           我那个草了！老大怎么回事，怎么做项目评估的？只会说相信你可以做的，试一下，有的是时间！        用java开发一个图文处理工具，类似word，任意位置插入、拖动、删除图片以及文本等。文本框、流程图等，数据保存数据库，其余可保存pdf格式。ok,姐姐千辛万苦，
  • php 文件操作 aichenglong PHP读取文件写入文件
    1 写入文件 @$fp=fopen("$DOCUMENT_ROOT/order.txt", "ab"); if(!$fp){ echo "open file error" ; exit; } $outputstring="date:"." \t tire:".$tire."
  • MySQL的btree索引和hash索引的区别 AILIKES 数据结构mysql算法
    Hash 索引结构的特殊性，其 检索效率非常高，索引的检索可以一次定位，不像B-Tree 索引需要从根节点到枝节点，最后才能访问到页节点这样多次的IO访问，所以 Hash 索引的查询效率要远高于 B-Tree 索引。     可能很多人又有疑问了，既然 Hash 索引的效率要比 B-Tree 高很多，为什么大家不都用 Hash 索引而还要使用 B-Tree 索引呢
  • JAVA的抽象--- 接口 --实现 百合不是茶
    抽象 接口 实现接口   //抽象 类 ,方法   //定义一个公共抽象的类 ,并在类中定义一个抽象的方法体 抽象的定义使用abstract   abstract class A 定义一个抽象类 例如： //定义一个基类 public abstract class A{     //抽象类不能用来实例化，只能用来继承 //
  • JS变量作用域实例 bijian1013 作用域
    <script> var scope='hello'; function a(){ console.log(scope); //undefined var scope='world'; console.log(scope); //world console.log(b);
  • TDD实践（二） bijian1013 javaTDD
    实践题目：分解质因数 Step1： 单元测试： package com.bijian.study.factor.test; import java.util.Arrays; import junit.framework.Assert; import org.junit.Before; import org.junit.Test; import com.bijian.
  • [MongoDB学习笔记一]MongoDB主从复制 bit1129 mongodb
    MongoDB称为分布式数据库，主要原因是1.基于副本集的数据备份， 2.基于切片的数据扩容。副本集解决数据的读写性能问题，切片解决了MongoDB的数据扩容问题。   事实上，MongoDB提供了主从复制和副本复制两种备份方式，在MongoDB的主从复制和副本复制集群环境中，只有一台作为主服务器，另外一台或者多台服务器作为从服务器。 本文介绍MongoDB的主从复制模式，需要指明
  • 【HBase五】Java API操作HBase bit1129 hbase
    import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseConfiguration; import org.apache.hadoop.hbase.HColumnDescriptor; import org.apache.ha
  • python调用zabbix api接口实时展示数据 ronin47
    zabbix api接口来进行展示。经过思考之后，计划获取如下内容：     1、  获得认证密钥     2、  获取zabbix所有的主机组     3、  获取单个组下的所有主机     4、  获取某个主机下的所有监控项  
  • jsp取得绝对路径 byalias 绝对路径
    在JavaWeb开发中，常使用绝对路径的方式来引入JavaScript和CSS文件，这样可以避免因为目录变动导致引入文件找不到的情况，常用的做法如下： 一、使用${pageContext.request.contextPath} 　　代码” ${pageContext.request.contextPath}”的作用是取出部署的应用程序名，这样不管如何部署，所用路径都是正确的。
  • Java定时任务调度：用ExecutorService取代Timer bylijinnan java
    《Java并发编程实战》一书提到的用ExecutorService取代Java Timer有几个理由，我认为其中最重要的理由是： 如果TimerTask抛出未检查的异常，Timer将会产生无法预料的行为。Timer线程并不捕获异常，所以 TimerTask抛出的未检查的异常会终止timer线程。这种情况下，Timer也不会再重新恢复线程的执行了;它错误的认为整个Timer都被取消了。此时，已经被
  • SQL 优化原则 chicony sql
    一、问题的提出 　在应用系统开发初期，由于开发数据库数据比较少，对于查询SQL语句，复杂视图的的编写等体会不出SQL语句各种写法的性能优劣，但是如果将应用系统提交实际应用后，随着数据库中数据的增加，系统的响应速度就成为目前系统需要解决的最主要的问题之一。系统优化中一个很重要的方面就是SQL语句的优化。对于海量数据，劣质SQL语句和优质SQL语句之间的速度差别可以达到上百倍，可见对于一个系统
  • java 线程弹球小游戏 CrazyMizzz java游戏
    最近java学到线程，于是做了一个线程弹球的小游戏，不过还没完善 这里是提纲 1.线程弹球游戏实现 1.实现界面需要使用哪些API类 JFrame JPanel JButton FlowLayout Graphics2D Thread Color ActionListener ActionEvent MouseListener Mouse
  • hadoop jps出现process information unavailable提示解决办法 daizj hadoopjps
    hadoop jps出现process information unavailable提示解决办法   jps时出现如下信息： 3019 -- process information unavailable3053 -- process information unavailable2985 -- process information unavailable2917 --
  • PHP图片水印缩放类实现 dcj3sjt126com PHP
    <?php class Image{ private $path; function __construct($path='./'){ $this->path=rtrim($path,'/').'/'; } //水印函数，参数：背景图，水印图，位置，前缀,TMD透明度 public function water($b,$l,$pos
  • IOS控件学习：UILabel常用属性与用法 dcj3sjt126com iosUILabel
    参考网站： http://shijue.me/show_text/521c396a8ddf876566000007 http://www.tuicool.com/articles/zquENb http://blog.csdn.net/a451493485/article/details/9454695 http://wiki.eoe.cn/page/iOS_pptl_artile_281
  • 完全手动建立maven骨架 eksliang javaeclipseWeb
    建一个 JAVA 项目 ： mvn archetype:create -DgroupId=com.demo -DartifactId=App [-Dversion=0.0.1-SNAPSHOT] [-Dpackaging=jar] 建一个 web 项目 ： mvn archetype:create -DgroupId=com.demo -DartifactId=web-a
  • 配置清单 gengzg 配置
    1、修改grub启动的内核版本 vi /boot/grub/grub.conf 将default 0改为1 拷贝mt7601Usta.ko到/lib文件夹 拷贝RT2870STA.dat到 /etc/Wireless/RT2870STA/文件夹 拷贝wifiscan到bin文件夹，chmod 775 /bin/wifiscan 拷贝wifiget.sh到bin文件夹，chm
  • Windows端口被占用处理方法 huqiji windows
    以下文章主要以80端口号为例，如果想知道其他的端口号也可以使用该方法..........................1、在windows下如何查看80端口占用情况?是被哪个进程占用?如何终止等.        这里主要是用到windows下的DOS工具,点击"开始"--"运行",输入&
  • 开源ckplayer 网页播放器， 跨平台(html5, mobile)，flv, f4v, mp4, rtmp协议. webm, ogg, m3u8 ！ 天梯梦 mobile
    CKplayer，其全称为超酷flv播放器，它是一款用于网页上播放视频的软件，支持的格式有：http协议上的flv,f4v,mp4格式，同时支持rtmp视频流格 式播放，此播放器的特点在于用户可以自己定义播放器的风格，诸如播放/暂停按钮，静音按钮，全屏按钮都是以外部图片接口形式调用，用户根据自己的需要制作 出播放器风格所需要使用的各个按钮图片然后替换掉原始风格里相应的图片就可以制作出自己的风格了，
  • 简单工厂设计模式 hm4123660 java工厂设计模式简单工厂模式
           简单工厂模式（Simple Factory Pattern）属于类的创新型模式，又叫静态工厂方法模式。是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。
  • maven笔记 zhb8015 maven
    跳过测试阶段： mvn package -DskipTests 临时性跳过测试代码的编译： mvn package -Dmaven.test.skip=true   maven.test.skip同时控制maven-compiler-plugin和maven-surefire-plugin两个插件的行为，即跳过编译，又跳过测试。   指定测试类 mvn test
  • 非mapreduce生成Hfile，然后导入hbase当中 Stark_Summer maphbasereduceHfilepath实例
    最近一个群友的boss让研究hbase，让hbase的入库速度达到5w+/s，这可愁死了，4台个人电脑组成的集群，多线程入库调了好久，速度也才1w左右，都没有达到理想的那种速度，然后就想到了这种方式，但是网上多是用mapreduce来实现入库，而现在的需求是实时入库，不生成文件了，所以就只能自己用代码实现了，但是网上查了很多资料都没有查到，最后在一个网友的指引下，看了源码，最后找到了生成Hfile
  • jsp web tomcat 编码问题 王新春 tomcatjsppageEncode
    今天配置jsp项目在tomcat上，windows上正常，而linux上显示乱码，最后定位原因为tomcat 的server.xml 文件的配置，添加 URIEncoding 属性： <Connector port="8080" protocol="HTTP/1.1" connectionTi
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他