lanshengsheng2012
lanshengsheng2012

java中的IO整理

http://www.cnblogs.com/rollenholt/archive/2011/09/11/2173787.html

写在前面：本文章基本覆盖了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关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
  • eclipse maven IXHONG eclipse
    eclipse中使用maven插件的时候，运行run as maven build的时候报错 -Dmaven.multiModuleProjectDirectory system propery is not set. Check $M2_HOME environment variable and mvn script match.   可以设一个环境变量M2_HOME指
  • timer cancel方法的一个小实例 alleni123 多线程timer
    package com.lj.timer; import java.util.Date; import java.util.Timer; import java.util.TimerTask; public class MyTimer extends TimerTask { private int a; private Timer timer; pub
  • MySQL数据库在Linux下的安装 ducklsl mysql
    1.建好一个专门放置MySQL的目录 /mysql/db数据库目录 /mysql/data数据库数据文件目录 2.配置用户，添加专门的MySQL管理用户 >groupadd mysql ----添加用户组 >useradd -g mysql mysql ----在mysql用户组中添加一个mysql用户 3.配置，生成并安装MySQL >cmake -D
  • spring------>>cvc-elt.1: Cannot find the declaration of element Array_06 springbean
    将-------- <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3
  • maven发布第三方jar的一些问题 cugfy maven
    maven中发布 第三方jar到nexus仓库使用的是 deploy:deploy-file命令 有许多参数，具体可查看 http://maven.apache.org/plugins/maven-deploy-plugin/deploy-file-mojo.html 以下是一个例子： mvn  deploy:deploy-file -DgroupId=xpp3
  • MYSQL下载及安装 357029540 mysql
        好久没有去安装过MYSQL，今天自己在安装完MYSQL过后用navicat for mysql去厕测试链接的时候出现了10061的问题，因为的的MYSQL是最新版本为5.6.24，所以下载的文件夹里没有my.ini文件，所以在网上找了很多方法还是没有找到怎么解决问题，最后看到了一篇百度经验里有这个的介绍，按照其步骤也完成了安装，在这里给大家分享下这个链接的地址
  • ios TableView cell的布局 张亚雄 tableview
      cell.imageView.image = [UIImage imageNamed:[imageArray objectAtIndex:[indexPath row]]];           CGSize itemSize = CGSizeMake(60, 50);   &nbs
  • Java编码转义 adminjun java编码转义
    import java.io.UnsupportedEncodingException; /** * 转换字符串的编码 */ public class ChangeCharset { /** 7位ASCII字符，也叫作ISO646-US、Unicode字符集的基本拉丁块 */ public static final Strin
  • Tomcat 配置和spring aijuans spring
    简介 Tomcat启动时，先找系统变量CATALINA_BASE，如果没有，则找CATALINA_HOME。然后找这个变量所指的目录下的conf文件夹，从中读取配置文件。最重要的配置文件：server.xml 。要配置tomcat，基本上了解server.xml，context.xml和web.xml。 Server.xml --  tomcat主
  • Java打印当前目录下的所有子目录和文件 ayaoxinchao 递归File
    其实这个没啥技术含量，大湿们不要操笑哦，只是做一个简单的记录，简单用了一下递归算法。   import java.io.File; /** * @author Perlin * @date 2014-6-30 */ public class PrintDirectory { public static void printDirectory(File f
  • linux安装mysql出现libs报冲突解决 BigBird2012 linux
    linux安装mysql出现libs报冲突解决 安装mysql出现 file /usr/share/mysql/ukrainian/errmsg.sys from install of MySQL-server-5.5.33-1.linux2.6.i386 conflicts with file from package mysql-libs-5.1.61-4.el6.i686  
  • jedis连接池使用实例 bijian1013 redisjedis连接池jedis
    实例代码： package com.bijian.study; import java.util.ArrayList; import java.util.List; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoo
  • 关于朋友 bingyingao 朋友兴趣爱好维持
      成为朋友的必要条件：    志相同，道不合，可以成为朋友。譬如马云、周星驰一个是商人，一个是影星，可谓道不同，但都很有梦想，都要在各自领域里做到最好，当他们遇到一起，互相欣赏，可以畅谈两个小时。     志不同，道相合，也可以成为朋友。譬如有时候看到两个一个成绩很好每次考试争做第一，一个成绩很差的同学是好朋友。他们志向不相同，但他
  • 【Spark七十九】Spark RDD API一 bit1129 spark
    aggregate package spark.examples.rddapi import org.apache.spark.{SparkConf, SparkContext} //测试RDD的aggregate方法 object AggregateTest { def main(args: Array[String]) { val conf = new Spar
  • ktap 0.1 released bookjovi kerneltracing
    Dear, I'm pleased to announce that ktap release v0.1, this is the first official release of ktap project, it is expected that this release is not fully functional or very stable and we welcome bu
  • 能保存Properties文件注释的Properties工具类 BrokenDreams properties
            今天遇到一个小需求：由于java.util.Properties读取属性文件时会忽略注释，当写回去的时候，注释都没了。恰好一个项目中的配置文件会在部署后被某个Java程序修改一下，但修改了之后注释全没了，可能会给以后的参数调整带来困难。所以要解决这个问题。     &nb
  • 读《研磨设计模式》-代码笔记-外观模式-Facade bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /* * 百度百科的定义： * Facade（外观）模式为子系统中的各类（或结构与方法）提供一个简明一致的界面， * 隐藏子系统的复杂性，使子系统更加容易使用。他是为子系统中的一组接口所提供的一个一致的界面 * * 可简单地
  • After Effects教程收集 cherishLC After Effects
    1、中文入门 http://study.163.com/course/courseMain.htm?courseId=730009 2、videocopilot英文入门教程（中文字幕） http://www.youku.com/playlist_show/id_17893193.html 英文原址： http://www.videocopilot.net/basic/ 素
  • Linux Apache 安装过程 crabdave apache
    Linux Apache 安装过程   下载新版本： apr-1.4.2.tar.gz（下载网站：http://apr.apache.org/download.cgi） apr-util-1.3.9.tar.gz（下载网站：http://apr.apache.org/download.cgi） httpd-2.2.15.tar.gz（下载网站：http://httpd.apac
  • Shell学习 之 变量赋值和引用 daizj shell变量引用赋值
    本文转自：http://www.cnblogs.com/papam/articles/1548679.html Shell编程中，使用变量无需事先声明，同时变量名的命名须遵循如下规则： 首个字符必须为字母（a-z，A-Z） 中间不能有空格，可以使用下划线（_） 不能使用标点符号 不能使用bash里的关键字（可用help命令查看保留关键字） 需要给变量赋值时，可以这么写：
  • Java SE 第一讲（Java SE入门、JDK的下载与安装、第一个Java程序、Java程序的编译与执行） dcj3sjt126com javajdk
    Java SE 第一讲： Java SE：Java Standard Edition Java ME: Java Mobile Edition Java EE：Java Enterprise Edition Java是由Sun公司推出的（今年初被Oracle公司收购）。 收购价格：74亿美金 J2SE、J2ME、J2EE JDK：Java Development
  • YII给用户登录加上验证码 dcj3sjt126com yii
    1、在SiteController中添加如下代码： /** * Declares class-based actions. */ public function actions() { return array( // captcha action renders the CAPTCHA image displ
  • Lucene使用说明 dyy_gusi Lucenesearch分词器
    Lucene使用说明 1、lucene简介 1.1、什么是lucene     Lucene是一个全文搜索框架，而不是应用产品。因此它并不像baidu或者googleDesktop那种拿来就能用，它只是提供了一种工具让你能实现这些产品和功能。 1.2、lucene能做什么     要回答这个问题，先要了解lucene的本质。实际
  • 学习编程并不难,做到以下几点即可! gcq511120594 数据结构编程算法
    不论你是想自己设计游戏，还是开发iPhone或安卓手机上的应用，还是仅仅为了娱乐，学习编程语言都是一条必经之路。编程语言种类繁多，用途各 异，然而一旦掌握其中之一，其他的也就迎刃而解。作为初学者，你可能要先从Java或HTML开始学，一旦掌握了一门编程语言，你就发挥无穷的想象，开发 各种神奇的软件啦。 1、确定目标 学习编程语言既充满乐趣，又充满挑战。有些花费多年时间学习一门编程语言的大学生到
  • Java面试十问之三：Java与C++内存回收机制的差别 HNUlanwei javaC++finalize()堆栈内存回收
    大家知道， Java 除了那 8 种基本类型以外，其他都是对象类型（又称为引用类型）的数据。 JVM 会把程序创建的对象存放在堆空间中，那什么又是堆空间呢？其实，堆（ Heap）是一个运行时的数据存储区，从它可以分配大小各异的空间。一般，运行时的数据存储区有堆（ Heap）和堆栈（ Stack），所以要先看它们里面可以分配哪些类型的对象实体，然后才知道如何均衡使用这两种存储区。一般来说，栈中存放的
  • 第二章 Nginx+Lua开发入门 jinnianshilongnian nginxlua
    Nginx入门 本文目的是学习Nginx+Lua开发，对于Nginx基本知识可以参考如下文章： nginx启动、关闭、重启 http://www.cnblogs.com/derekchen/archive/2011/02/17/1957209.html agentzh 的 Nginx 教程 http://openresty.org/download/agentzh-nginx-tutor
  • MongoDB windows安装 基本命令 liyonghui160com
      windows安装    安装目录：   D:\MongoDB\   新建目录   D:\MongoDB\data\db   4.启动进城：   cd D:\MongoDB\bin   mongod -dbpath D:\MongoDB\data\db   &n
  • Linux下通过源码编译安装程序 pda158 linux
    一、程序的组成部分 　　Linux下程序大都是由以下几部分组成： 　　二进制文件：也就是可以运行的程序文件 　　库文件：就是通常我们见到的lib目录下的文件 　　配置文件：这个不必多说，都知道 　　帮助文档：通常是我们在linux下用man命令查看的命令的文档 　　 二、linux下程序的存放目录 　　linux程序的存放目录大致有三个地方： 　　/etc, /b
  • WEB开发编程的职业生涯４个阶段 shw3588 编程Web工作生活
    觉得自己什么都会 2007年从学校毕业，凭借自己原创的ASP毕业设计，以为自己很厉害似的，信心满满去东莞找工作，找面试成功率确实很高，只是工资不高，但依旧无法磨灭那过分的自信，那时候什么考勤系统、什么OA系统、什么ERP，什么都觉得有信心，这样的生涯大概持续了约一年。 根本不是自己想的那样 2008年开始接触很多工作相关的东西，发现太多东西自己根本不会，都需要去学，不管是asp还是js，
  • 遭遇jsonp同域下变作post请求的坑 vb2005xu jsonp同域post
    今天迁移一个站点时遇到一个坑爹问题,同一个jsonp接口在跨域时都能调用成功,但是在同域下调用虽然成功,但是数据却有问题. 此处贴出我的后端代码片段 $mi_id = htmlspecialchars(trim($_GET['mi_id '])); $mi_cv = htmlspecialchars(trim($_GET['mi_cv ']));  贴出我前端代码片段: $.aj
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他