`

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常用API举例

    4. **IO流**：Java的IO流分为字节流和字符流，如FileInputStream和FileOutputStream处理字节数据，BufferedReader和PrintWriter处理字符数据。`read()`和`write()`用于读写数据，`close()`关闭流。例如： ```java ...

    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 实例课间

    在Java中，输入和输出是通过流（Stream）的概念实现的，这是一个抽象化的概念，允许程序以统一的方式处理各种类型的输入和输出源。 10.1 输入与输出基础 Java的输入输出功能主要依赖于`java.io`包中的类。流是数据...

    Java常用类与基础API-String的理解与不可变性

    ### Java常用类与基础API-String的理解与不可变性 #### 一、字符串相关类之不可变字符序列：String ##### (1) 对String类的理解(以JDK8为例说明) **1. 环境** 本文档使用JDK 8进行演示。JDK 8的环境设置确保了...

    广州今年最新java面试题

    Java作为一款广泛应用的编程语言，其面试题涵盖了多个方面，包括基础知识、面向对象、集合框架、多线程、异常处理、IO流、网络编程、数据库操作、设计模式以及JVM优化等。对于在广州求职Java开发岗位的应聘者来说，...

    Java常见你面试题、笔试题（含答案）

    10. **常用类、包、接口举例**： - 类：ArrayList、HashMap、Thread、File、Socket - 包：java.util、java.io、java.net、java.awt、javax.swing - 接口：Runnable、Comparator、Serializable、Iterable 11. **...

    java程序员面试集合

    在Java面试中，有几个关键的知识点是面试官常常关注的，这些知识点涵盖了语言基础、集合框架、多线程、异常处理、IO流、设计模式以及JVM优化等多个方面。 首先，我们要了解Java的基础知识。这包括但不限于语法特性...

    java面试宝典花期银行的

    Java编程语言作为软件开发领域的主流技术之一，深受企业和开发者青睐，尤其在银行等金融行业的应用广泛。花旗银行作为全球知名金融机构，其面试对Java技术的要求自然严谨且深入。本资源集合了花旗银行面试中关于Java...

    笔试面试(复习资料大全)Java笔试题_20071220.doc

    以上只是Java笔试题中的一部分核心知识点，实际的Java学习还包括面向对象编程、集合框架、IO流、多线程、网络编程、反射、注解等广泛内容。掌握这些知识不仅有助于通过面试，更能在实际开发中游刃有余。对于Java...

    疯狂JAVA讲义

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

    应聘Java笔试时可能出现问题及其答案

    在准备Java程序员的笔试环节时，考生可能会遇到各种各样的技术问题，这些问题涵盖了Java语言的基础、进阶特性、多线程、集合框架、IO流、网络编程、异常处理、数据库连接以及设计模式等多个方面。以下是一些可能的...

    125条常见的java面试笔试题汇总

    - Java的IO流模型，包括字节流和字符流的区别。 - 文件的读写操作，如FileReader、FileWriter和BufferedReader。 - 流的关闭与异常处理。 11. **多线程** - 创建线程的两种方式：继承Thread类和实现Runnable...

    2022年java华为面试题.docx

    6. 常用的类、包、接口举例： 类：ArrayList、HashMap、Thread、File、Socket； 包：java.util、java.io、java.net、java.awt、javax.swing； 接口：Runnable、Comparable、Iterator、Cloneable、Serializable。 ...

    java程序员面试题3---java华为面试题.

    以上只是面试中可能遇到的部分Java相关问题，完整的准备还需要涵盖其他领域，如集合框架、IO流、多线程、网络编程、设计模式等。对于Java程序员来说，不断学习和提升自己的技术能力是保持竞争力的关键。

    java经典题目 共22页

    - `java.io`：支持输入/输出流操作，如文件读写。 - `java.sql`：用于与数据库交互的标准API。 - `java.awt`：提供基本的图形用户界面（GUI）组件。 - `java.net`：支持网络通信的功能。 ### 4. Java中的标识符及其...

    java华为面试题

    6. **常用的类、包、接口举例** - 类：ArrayList, HashMap, FileInputStream, Exception, Thread - 包：java.util, java.io, java.lang, java.awt, java.net - 接口：Runnable, Comparable, Comparator, ...

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