`

Java 常用IO流的举例系列之一

javaIO 
阅读更多
由于项目的原因，自己好久都没有接触Java了，怕自己会什么都忘记，所以还是时不时写写，废话不多说，现在开始

第一个：InputStream的实现类：FileInputStream

由于它是一个接口，因此不对其进行举例，直接看它的子类吧，直接例子：

代码1： 
package com.fit.test.test04;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class FileStreamDemo {

	public static void main(String[] args) {
		
		
		InputStream fis = null;

		try {
			fis = new FileInputStream("E:\\work\\test\\t.txt");
			
			int i = 0;

			while ((i = fis.read()) != -1) {
				System.out.print((char)i);
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (fis != null) {
					fis.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
		}

	}

}


此代码要运行成功，E:\work\test\t.txt这个文件要存在；运行结果如下： 

package com.fit.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;


out.flush();
out.close();




第二个：OutputStream的实现类：FileOutputStream

既然我们能把文件读出来，那同样的，我们也能利用文件写相关的类把文件给写出来，代码如下：
代码2： 
package com.fit.test.test04;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class FileStreamDemo {

	public static void main(String[] args) {

		InputStream fis = null;
		OutputStream fos = null;
		
		try {
			fis = new FileInputStream("E:\\work\\test\\t.txt");
			fos = new FileOutputStream("E:\\work\\test\\t1.txt");
			int i = 0;

			while ((i = fis.read()) != -1) {
				fos.write(i);
			}
                        fos.flush();

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (fis != null) {
					fis.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
			
			try {
				if (fos != null) {
					fos.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
		}

	}

}


运行之后，E:\work\test\下有一个t1.txt这个文件，和t.txt文件一模一样。


好了，我们现在把读取的文件做一点小小的改变，加入几个汉字，看能不能读取出来，并且正常展示，此时我们还用代码1。

运行结果如下： 
package com.fit.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;

out.println("?ó????2");
out.println("??????????????2");

out.flush();
out.close();


发现了什么？乱码，不错，这是因为Java在读取的汉字的时候把汉字给拆开了，所以我们要改变读取的方式，用InputStreamReader进行一个包装。


第三个：Reader的子类：InputStreamReader

代码3： 

package com.fit.test.test04;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

public class FileStreamReaderDemo {

	public static void main(String[] args) {
		
		
		InputStreamReader fis = null;

		try {
			fis = new InputStreamReader(new FileInputStream("E:\\work\\test\\t.txt"));
			
			int i = 0;

			while ((i = fis.read()) != -1) {
				System.out.print((char)i);
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (fis != null) {
					fis.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
		}

	}

}



运行结果如下： 

package com.fit.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;

out.println("大家好2");
out.println("这是一个测试！2");

out.flush();
out.close();


好了，现在是不是正常展示了？同样的，我们仍然可以把这些含有汉字的文本写入到文件中。

第四个：Writer的子类：OutputStreamWriter
代码4： 
package com.fit.test.test04;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class FileStreamDemo {

	public static void main(String[] args) {

		InputStream fis = null;
		OutputStream fos = null;
		
		try {
			fis = new FileInputStream("E:\\work\\test\\t.txt");
			fos = new FileOutputStream("E:\\work\\test\\t1.txt");
			int i = 0;

			while ((i = fis.read()) != -1) {
				fos.write(i);
			}
			fos.flush();

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (fis != null) {
					fis.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
			
			try {
				if (fos != null) {
					fos.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
		}

	}

}


运行之后，E:\work\test\下有一个t2.txt这个文件，和t.txt文件一模一样。


其实代码2也能实现和代码4一样的功能，但是效率上可能会慢点，但是比较通用，如果要想提高效率的话，那我们在代码2的基础上再加一层封装。

第五个：FilterInputStream的子类：OutputStreamWriter
代码5： 

package com.fit.test.test04;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class BufferInputStreamDemo {

	public static void main(String[] args) {

		InputStream fis = null;
		OutputStream fos = null;
		BufferedInputStream bis = null;
		
		try {
			fis = new FileInputStream("E:\\work\\test\\t.txt");
			fos = new FileOutputStream("E:\\work\\test\\t1.txt");
			bis = new BufferedInputStream(fis);
			int i = 0;

			while ((i = bis.read()) != -1) {
				fos.write(i);
			}
			fos.flush();

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (bis != null) {
					bis.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
			
			try {
				if (fos != null) {
					fos.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
		}

	}

}


运行结果也是正常的，但是一般情况下，我们用了BufferedInputStream，那么相应的，我们就最好去用，上述例子我执行是正常的，但是不能保证数据量大的时候还是正常的，个人对这块也不是很深入了解，如果有人知道，可以告诉我，大家共同进步。

第六个：FilterOutputStream的子类：OutputStreamWriter
和五个例子是对应的。
代码6： 

package com.fit.test.test04;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class BufferOutputStreamDemo {

	public static void main(String[] args) {

		InputStream fis = null;
		OutputStream fos = null;
		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;
		
		try {
			fis = new FileInputStream("E:\\work\\test\\t.txt");
			fos = new FileOutputStream("E:\\work\\test\\t1.txt");
			bis = new BufferedInputStream(fis);
			bos = new BufferedOutputStream(fos);
			int i = 0;

			while ((i = bis.read()) != -1) {
				bos.write(i);
			}
			bos.flush();

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (bis != null) {
					bis.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
			
			try {
				if (bos != null) {
					bos.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
		}

	}

}



上述涉及到了用FileInputStream读取原始字节流，但是JDK为我们封装了一个更方便的读取文件的类，FileReader，用于读取字符流。


第七个：InputStreamReader的子类：FileReader

代码7： 

package com.fit.test.test04;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;

public class FileReaderDemo {

	public static void main(String[] args) {

		Reader reader = null;
		
		try {
			reader = new FileReader("E:\\work\\test\\t.txt");
			int i = 0;

			while ((i = reader.read()) != -1) {
				System.out.print((char)i);
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (reader != null) {
					reader.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
			
		}

	}

}


运行结果： 

package com.fit.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;

out.println("大家好2");
out.println("这是一个测试！2");

out.flush();
out.close();



有FileReader，那么对应的应该也有FileWriter吧。


第八个：OutputStreamWriter的子类：FileWriter
直接代码：
代码8： 

package com.fit.test.test04;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class FileWriterDemo {

	public static void main(String[] args) {

		Reader reader = null;
		Writer writer = null;
		
		try {
			reader = new FileReader("E:\\work\\test\\t.txt");
			writer = new FileWriter("E:\\work\\test\\t3.txt");
			int i = 0;

			while ((i = reader.read()) != -1) {
				writer.write(i);
			}
			writer.flush();

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (reader != null) {
					reader.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
			
			try {
				if (writer != null) {
					writer.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
			
		}

	}

}



上述的代码在功能上没有问题，但是在性能上却存在缺陷，通常，Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求。因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和 InputStreamReader）。例如，
BufferedReader in = new BufferedReader(new FileReader("foo.in"));
将缓冲指定文件的输入。如果没有缓冲，则每次调用 read() 或 readLine() 都会导致从文件中读取字节，并将其转换为字符后返回，而这是极其低效的。
通过用合适的 BufferedReader 替代每个 DataInputStream，可以对将 DataInputStream 用于文字输入的程序进行本地化。


第九个：Reader的子类：BufferedReader

代码9： 

package com.fit.test.test04;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class BufferReaderDemo {

	public static void main(String[] args) {

		Reader reader = null;
		
		try {
			reader = new BufferedReader(new FileReader("E:\\work\\test\\t.txt"));
			int i = 0;

			while ((i = reader.read()) != -1) {
				System.out.print((char)i);
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (reader != null) {
					reader.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
			
		}

	}

}


运行结果肯定是正确的，还是和之前的一样，既然有BufferedReader，那么肯定有BufferedWriter。



第十个：Writer的子类：BufferedWriter

代码10： 

package com.fit.test.test04;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class BufferWriterDemo {

	public static void main(String[] args) {

		Reader reader = null;
		Writer writer = null;
		
		try {
			reader = new BufferedReader(new FileReader("E:\\work\\test\\t.txt"));
			writer = new BufferedWriter(new FileWriter("E:\\work\\test\\t5.txt"));
			int i = 0;
			
			while ((i = reader.read()) != -1) {
				writer.write(i);
			}
			writer.flush();

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {
			try {
				if (reader != null) {
					reader.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
			
			try {
				if (writer != null) {
					writer.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}
			
		}

	}

}



其实JDK中有提到一个示例：
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("foo.out")));


那么根据上述示例，我们代码10就可以做如下的改动了：

替换
writer = new BufferedWriter(new FileWriter("E:\\work\\test\\t5.txt"));

为
writer = new PrintWriter(new BufferedWriter(new FileWriter("E:\\work\\test\\t6.txt")));



第十一个：OutputStream的子类：DataOutputStream

数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。

代码11： 

package com.fit.test.test04;

import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataOutputStreamDemo {

	public static void main(String[] args) {

		DataOutputStream out = null;
		try {
			out = new DataOutputStream(new FileOutputStream("E:\\work\\test\\myfloat.txt"));

			for (int i = 0; i < 10; i++) {
				out.writeDouble(Math.random() * 100);
			}
			out.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {

			try {
				if (out != null) {
					out.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}

		}

	}

}


第十二个：InputStream的子类：DataInputStream

数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。

DataInputStream 对于多线程访问不一定是安全的。 线程安全是可选的，它由此类方法的使用者负责。

代码12： 

package com.fit.test.test04;

import java.io.DataInputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class DataInputStreamDemo {

	public static void main(String[] args) {

		DataInputStream in = null;
		try {
			in = new DataInputStream(new FileInputStream(
					"E:\\work\\test\\myfloat.txt"));

			while (true) {
				double d = in.readDouble();
				System.out.println(d);
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (EOFException e) {
			System.out.println("读取结束了");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("发生异常了");
		} finally {

			try {
				if (in != null) {
					in.close();
				}
			} catch (IOException e1) {
				e1.printStackTrace();
				System.out.println("关闭流异常");
			}

		}

	}

}


此时注意：在read的时候如果此输入流在读取这八个字节之前到达末尾。则此时会抛出EOFException异常。


DataInputStream和DataOutputStream的应用举例。

代码： 

package com.fit.test.test04;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class DataStreamDemo {

	public static void main(String[] args) throws Exception {

		File file = new File("E:\\work\\test\\cnt");
		if (!file.exists()) {
			DataOutputStream out = new DataOutputStream(new FileOutputStream(
					file));
			out.writeInt(1);
			out.flush();
			out.close();
			System.out.println("本程序第1次运行！");
			return;
		}

		DataInputStream in = new DataInputStream(new FileInputStream(file));

		int cnt = in.readInt();
		in.close();
		cnt++;

		DataOutputStream out = new DataOutputStream(new FileOutputStream(file));
		out.writeInt(cnt);
		out.flush();
		out.close();
		System.out.println("本程序第" + cnt + "次运行！");

	}
}



第十三个：InputStream的子类：DataInputStream

ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。可以使用 ObjectInputStream 读取（重构）对象。通过在流中使用文件可以实现对象的持久存储。如果流是网络套接字流，则可以在另一台主机上或另一个进程中重构对象。

只能将支持 java.io.Serializable 接口的对象写入流中。每个 serializable 对象的类都被编码，编码内容包括类名和类签名、对象的字段值和数组值，以及从初始对象中引用的其他所有对象的闭包。


代码13： 
package com.fit.test.test04;

import java.io.Serializable;

public class Tiger implements Serializable {
	/**
	 * 注意此类必须实现可序列化接口，否则在流化的时候会报错
	 */
	private static final long serialVersionUID = 1L;

	private int bh;
	private String name;
	private String sex;

	public Tiger(int bh, String name, String sex) {
		super();
		this.bh = bh;
		this.name = name;
		this.sex = sex;
	}

	public Tiger() {
		super();
	}

	public int getBh() {
		return bh;
	}

	public void setBh(int bh) {
		this.bh = bh;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
}


package com.fit.test.test04;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class ObjectOutputStreamDemo {
	/**
	 * @param args
	 * @throws Exception
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception {

		ObjectOutputStream out = new ObjectOutputStream(

		new FileOutputStream("E:\\work\\test\\tigers")

		);

		for (int i = 1; i <= 100; i++) {

			Tiger tiger = new Tiger(i, "老虎" + i, i % 2 == 0 ? "雌" : "雄");
			out.writeObject(tiger);
		}

		out.flush();
		out.close();

	}
}



第十四个：InputStream的子类：DataInputStream

ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。

ObjectOutputStream 和 ObjectInputStream 分别与 FileOutputStream 和 FileInputStream 一起使用时，可以为应用程序提供对对象图形的持久存储。ObjectInputStream 用于恢复那些以前序列化的对象。其他用途包括使用套接字流在主机之间传递对象，或者用于编组和解组远程通信系统中的实参和形参。

ObjectInputStream 确保从流创建的图形中所有对象的类型与 Java 虚拟机中显示的类相匹配。使用标准机制按需加载类。

只有支持 java.io.Serializable 或 java.io.Externalizable 接口的对象才能从流读取。

代码14： 

package com.fit.test.test04;

import java.io.EOFException;
import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class ObjectInputStreamDemo {
	/**
	 * @param args
	 * @throws Exception
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception {

		ObjectInputStream in = new ObjectInputStream(

		new FileInputStream("E:\\work\\test\\tigers")

		);

		try {
			while (true) {
				Tiger tiger = (Tiger) in.readObject();
				System.out.println(tiger.getBh() + "," + tiger.getName() + ","
						+ tiger.getSex());
			}
		} catch (EOFException e) {
			in.close();
		}

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

	}
}



1,老虎1,雄
2,老虎2,雌
3,老虎3,雄
4,老虎4,雌
..........




1.OutputStreamWriter和InputStreamReader在读取文件的时候是可以指定编码的，例如： 

public static void main(String[] args) throws Exception {
		
		
		Reader reader=new InputStreamReader(
						new FileInputStream("f:/my2.txt"),
						"UTF-8"
					);
		
		int k=0;
		while((k=reader.read())!=-1){
			System.out.print((char)k);
		}
		
		reader.close();

	}


public static void main(String[] args) throws Exception {
		
		
		BufferedReader reader=new BufferedReader(
			new InputStreamReader(
						new FileInputStream("f:/my2.txt"),
						"UTF-8"
			)
		);
		
		PrintWriter out=new PrintWriter(
			new OutputStreamWriter(
				new FileOutputStream("f:/my9.txt"),
				"GBK"
			)
		);
		
		/*int k=0;
		while((k=reader.read())!=-1){
			out.write(k);
		}*/
		
		String line=null;
		while((line=reader.readLine())!=null){
			out.println(line);
		}
		
		reader.close();
		out.flush();
		out.close();

	}



其实FileInputStream和FileOutputStream在读取的时候“也是可以指定编码的”,当然是变相的哦。

代码：(注意代码有缺陷) 

InputStream in = new FileInputStream("E:\\work\\test\\t6.txt");
		byte[] b = new byte[in.available()];
		in.read(b);
		in.close();
		String str = new String(b, "UTF-8");
		System.out.println(str);

		byte[] b2 = str.getBytes();// unicode--->GBk(平台默认)
		// byte[] b2=str.getBytes("UTF-8");

		OutputStream out = new FileOutputStream("E:\\work\\test\\t7.txt");
		out.write(b2);
		out.flush();
		out.close();



写了这么多，纯粹是为了备忘，现在的编程语言和框架太多了，不去记录一下，时间长不用了，很容易忘记的，此文章仅作备忘，全文以举例为主，写的比较凌乱，欢迎大家指正。关于其他几个流，以及上述涉及到的流的一些其他用法，将在后续的文章中涉及。

分享到：
| 线程安全和可重入性以及线程安全函数
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java初学者输入输出流常用方法及简介

    简介输入输出流意义及分类，举例常用文件读取与写入方式

    java自学之道

    第3章 Java常用算法 3.1递归算法 3.2冒泡排序算法 3.3 快速排序算法 3.4选择排序算法 3.5直接插入算法 3.6希尔排序算法 3.7 二分查找算法 3.8 二叉树 3.9 图的实现 3.10 生产者消费者的实现 3.11 银行家算法 3.12 ...

    疯狂JAVA讲义

    1.5 第一个Java程序 12 1.5.1 编辑Java源代码 12 1.5.2 编译Java程序 13 学生提问：当我们使用编译C程序时，不仅需要指定存放目标文件的位置，也需要指定目标文件的文件名，这里使用javac编译Java程序时怎么不...

    Java常见面试题.pdf

    12. 解释 Java 中的集合框架，并举例常用的集合类。 13. 什么是泛型？如何使用泛型？ 14. 解释 Java 中的反射机制。 15. 如何连接和操作数据库（如 MySQL）？ 16. 什么是 JVM（Java 虚拟机）？它的作用是什么？ 17. ...

    java 面试题 总结

    assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为...

    超级有影响力霸气的Java面试题大全文档

    assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为...

    经历BAT面试后总结的【高级Java后台开发面试指南】，纯净干货无废话，针对高频面试点

    Java基础 JVM原理 集合 多线程 IO 问题排查 Web框架、数据库 Spring MySQL Redis 通用基础 操作系统 网络通信协议 排序算法 常用设计模式 从URL到看到网页的过程 分布式 CAP理论 锁 事务 消息队列 协调器 ID生成方式...

    Struts2-2.3.16 全jar包

    支持Struts2 搭框架中基本上最常用的所有的jar包。 我用的是struts2.2.3.16(不管用struts2的哪个版本，道理都一样，找对应的包就行了) 例如你建一Web Project，名为Struts2 导入项目所需要的jar包，放入/Struts2/...

    freemarker总结

    JAVA模版引擎Freemarker常用标签(一) 1. if指令 这是一个典型的分支控制指令,该指令的作用完全类似于Java语言中的if,if指令的语法格式如下: &lt;#if condition&gt;... &lt;#elseif condition&gt;... &lt;#elseif condition&gt;......

    net学习笔记及其他代码应用

    要请求垃圾收集，可以调用下面的方法之一： System.gc() Runtime.getRuntime().gc() 37.String s = new String(\"xyz\");创建了几个String Object? 答：两个对象，一个是“xyx”,一个是指向“xyx”的引用对象s。...

    网管教程 从入门到精通软件篇.txt

    JAR：Java档案文件（一种用于applet和相关文件的压缩文件） JAVA：Java源文件 JFF，JFIF，JIF：JPEG文件 JPE，JPEG，JPG：JPEG图形文件 JS：javascript源文件 JSP：HTML网页，其中包含有对一个Java servlet...

    Toad 使用快速入门

     把鼠标定位到表/视图/存储过程名称之上，按F4，可以打开对象描述窗口，方便的查看表和视图的定义，存储过程的源代码，  非常容易对SQL语句的分析其执行计划：单击工具栏上的 按钮就可以看到Explain Plan的...

Magicbox
Global site tag (gtag.js) - Google Analytics