`
king_tt
  • 浏览: 2234696 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

think in java interview-高级开发人员面试宝典(八)

 
阅读更多

面经出了7套，收到许多读者的Email，有许多人说了，这些基础知识是不是为了后面进一步的”通向架构师的道路“做准备的？


对的，你们没有猜错，就是这样的，我一直在酝酿后面的”通向架构师的道路“如何开章。


说实话，我已经在肚子里准备好的后面的”通向架构师的道路“的内容自己觉得如果一下子全拿出来的话，很多人吃不消，因为架构越来越复杂，用到的知识越来越多，而且很多都是各知识点的混合应用。


所以，先以这几套面经来铺路，我们把基础打实了，才能把大楼造的更好。因为，一个架构师首先他是一个程序员，他的基础知识必须非常的扎实，API对于架构师来说已经不太需要eclipse的code insight(即在eclipse编辑器里打一个小点点就可以得到后面的函数），尤其是一些常用的JAVA API来说，是必须熟记于心的。


下面我们继续来几天面经，顺带便复习一下JAVA和数据库的一些基础。


Java IO流的复习


大家平时J2EE写多了，JAVA的IO操作可能都已经生疏了，面试时如果来上这么几道，是不是有点”其实这个问题很简单，可是我就是想不起来“的感觉啊？


呵呵！


JAVA的IO操作太多，我这边挑腾迅，盛大和百度的几道面试题，并整理出答案来供大家参考。


InputFromConsole

这个最简单不过了，从console接受用户输入的字符，如和用户有交互的命令行。


如果你不复习的话，嘿嘿，还真答不出，来看：

package org.sky.io;

public class InputFromConsole {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception {
		int a = 0;
		byte[] input = new byte[1024];
		System.in.read(input);
		System.out.println("your input is: " + new String(input));

	}

}

ListDir

列出给出路径下所有的目录，包括子目录

package org.sky.io;

import java.io.*;

public class ListMyDir {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String fileName = "D:" + File.separator + "tomcat2";
		File f = new File(fileName);
		File[] fs = f.listFiles();
		for (int i = 0; i < fs.length; i++) {
			System.out.println(fs[i].getName());
		}

	}

}


咦，上面这个程序只列出了一层目录，我们想连子目录一起List出来怎么办？


ListMyDirWithSubDir

package org.sky.io;

import java.io.*;

public class ListMyDirWithSubDir {

	/**
	 * @param args
	 */
	public 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);
			}
		}
	}

	public static void main(String[] args) {
		String fileName = "D:" + File.separator + "tomcat2";
		File f = new File(fileName);
		ListMyDirWithSubDir listDir = new ListMyDirWithSubDir();
		listDir.print(f);

	}
}


InputStreamDemo

从外部读入一个文件


package org.sky.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

public class InputStreamDemo {
	public void readFile(String fileName) {
		File srcFile = new File(fileName);
		InputStream in = null;
		try {
			in = new FileInputStream(srcFile);
			byte[] b = new byte[(int) srcFile.length()];
			for (int i = 0; i < b.length; i++) {
				b[i] = (byte) in.read();
			}
			System.out.println(new String(b));
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (in != null) {
					in.close();
					in = null;
				}
			} catch (Exception e) {
			}
		}
	}

	public static void main(String[] args) {
		InputStreamDemo id = new InputStreamDemo();
		String src = "D:" + File.separator + "hello.txt";
		id.readFile(src);
	}

}


OutputStreamDemo

讲完了InputStream来讲OutputStream，输出内容至外部的一个文件

package org.sky.io;

import java.io.*;

public class OutputStreamDemo {

	public void writeWithByte() {
		String fileName = "D:" + File.separator + "hello.txt";
		OutputStream out = null;
		File f = new File(fileName);
		try {
			out = new FileOutputStream(f, true);
			String str = "   [Publicity ministry of ShangHai Municipal committee of CPC]";
			byte[] b = str.getBytes();
			out.write(b);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (out != null) {
					out.close();
					out = null;
				}
			} catch (Exception e) {
			}
		}
	}

	public void writeWithByteArray() {
		String fileName = "D:" + File.separator + "hello.txt";
		OutputStream out = null;
		File f = new File(fileName);
		try {
			out = new FileOutputStream(f, true);
			String str = "   [hello with byte yi ge ge xie]";
			byte[] b = str.getBytes();
			for (int i = 0; i < b.length; i++) {
				out.write(b[i]);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (out != null) {
					out.close();
					out = null;
				}
			} catch (Exception e) {
			}
		}
	}

	public static void main(String[] args) {
		OutputStreamDemo od = new OutputStreamDemo();
		od.writeWithByte();
		od.writeWithByteArray();

	}

}

这个Demo里分别用了”writeWithByte“和 ”writeWithByteArray“两种方法，注意查看


CopyFile

我们讲完了InputStream和OutputStream，我们就可以自己实现一个File Copy的功能了，来看

package org.sky.io;

import java.io.*;

public class CopyFile {

	public void copy(String src, String des) {
		File srcFile = new File(src);
		File desFile = new File(des);
		InputStream in = null;
		OutputStream out = null;
		try {
			in = new FileInputStream(srcFile);
			out = new FileOutputStream(desFile);
			byte[] b = new byte[(int) srcFile.length()];
			for (int i = 0; i < b.length; i++) {
				b[i] = (byte) in.read();
			}
			out.write(b);
			System.out.println("copied [" + srcFile.getName() + "]    with    "
					+ srcFile.length());
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (out != null) {
					out.close();
					out = null;
				}
			} catch (Exception e) {
			}
			try {
				if (in != null) {
					in.close();
					in = null;
				}
			} catch (Exception e) {
			}
		}
	}

	public static void main(String[] args) {
		CopyFile cp = new CopyFile();
		String src = "D:" + File.separator + "UltraEdit.zip";
		String des = "D:" + File.separator + "UltraEdit_Copy.zip";
		long sTime = System.currentTimeMillis();
		cp.copy(src, des);
		long eTime = System.currentTimeMillis();
		System.out.println("Total spend: " + (eTime - sTime));
	}

}

运行后显示：


来看我们被Copy的这个文件的大小：


也不大，怎么用了7秒多？

原是我们没有使用Buffer这个东西，即缓冲，性能会相差多大呢？来看


BufferInputStreamDemo

package org.sky.io;

import java.io.*;

public class BufferInputStreamDemo {

	/**
	 * @param args
	 */
	public void copy(String src, String des) {
		File srcFile = new File(src);
		File desFile = new File(des);
		BufferedInputStream bin = null;
		BufferedOutputStream bout = null;
		try {
			bin = new BufferedInputStream(new FileInputStream(srcFile));
			bout = new BufferedOutputStream(new FileOutputStream(desFile));
			byte[] b = new byte[1024];
			while (bin.read(b) != -1) {
				bout.write(b);
			}
			bout.flush();
			System.out.println("copied [" + srcFile.getName() + "]    with    "
					+ srcFile.length());
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (bout != null) {
					bout.close();
					bout = null;
				}
			} catch (Exception e) {
			}
			try {
				if (bin != null) {
					bin.close();
					bin = null;
				}
			} catch (Exception e) {
			}
		}
	}

	public static void main(String[] args) {
		BufferInputStreamDemo bd = new BufferInputStreamDemo();
		String src = "D:" + File.separator + "UltraEdit.zip";
		String des = "D:" + File.separator + "UltraEdit_Copy.zip";
		long sTime = System.currentTimeMillis();
		bd.copy(src, des);
		long eTime = System.currentTimeMillis();
		System.out.println("Total spend: " + (eTime - sTime));

	}

}
我们Copy同样一个文件，用了多少时间呢？来看！

丫只用了14毫秒，CALL！！！


ByteArrayDemo

来看看使用ByteArray输出文件吧

package org.sky.io;

import java.io.*;

public class ByteArrayDemo {

	/**
	 * @param args
	 */
	public void testByteArray() {
		String str = "HOLLYJESUS";
		ByteArrayInputStream input = null;
		ByteArrayOutputStream output = null;
		try {
			input = new ByteArrayInputStream(str.getBytes());
			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);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (output != null) {
					output.close();
					output = null;
				}
			} catch (Exception e) {
			}
			try {
				if (input != null) {
					input.close();
					input = null;
				}
			} catch (Exception e) {
			}
		}
	}

	public static void main(String[] args) {
		ByteArrayDemo bd = new ByteArrayDemo();
		bd.testByteArray();

	}

}

RandomAccess

有种输出流叫Random，你们还记得吗？学习时记得的，工作久了，HOHO，忘了，它到底有什么特殊的地方呢？来看：


package org.sky.io;

import java.io.*;

public class RandomAccess {
	public void writeToFile() {
		String fileName = "D:" + File.separator + "hello.txt";
		RandomAccessFile randomIO = null;
		try {

			File f = new File(fileName);
			randomIO = new RandomAccessFile(f, "rw");
			randomIO.writeBytes("asdsad");
			randomIO.writeInt(12);
			randomIO.writeBoolean(true);
			randomIO.writeChar('A');
			randomIO.writeFloat(1.21f);
			randomIO.writeDouble(12.123);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (randomIO != null) {
					randomIO.close();
					randomIO = null;
				}
			} catch (Exception e) {
			}
		}
	}

	public static void main(String[] args) {
		RandomAccess randomA = new RandomAccess();
		randomA.writeToFile();
	}
}

它输出后的文件是怎么样的呢？



PipeStream

这个流很特殊，我们在线程操作时，两个线程都在运行，这时通过发送一个指令让某个线程do something，我们在以前的jdk1.4中为了实现这样的功能，使用的就是这个PipeStream


先来看两个类，一个叫SendMessage，即发送一个指令。一个叫ReceiveMessage，用于接受指令。

SendMessage

package org.sky.io;

import java.io.*;

public class SendMessage implements Runnable {
	private PipedOutputStream out = null;

	public PipedOutputStream getOut() {
		return this.out;
	}

	public SendMessage() {
		this.out = new PipedOutputStream();
	}

	public void send() {

		String msg = "start";
		try {
			out.write(msg.getBytes());
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (out != null) {
					out.close();
					out = null;
				}
			} catch (Exception e) {
			}
		}
	}

	public void run() {
		try {
			System.out.println("waiting for signal...");
			Thread.sleep(2000);
			send();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

ReceiveMessage

package org.sky.io;

import java.io.*;

public class ReceiveMessage implements Runnable {
	private PipedInputStream input = null;

	public PipedInputStream getInput() {
		return this.input;
	}

	public ReceiveMessage() {
		this.input = new PipedInputStream();
	}

	private void receive() {

		byte[] b = new byte[1000];
		int len = 0;
		String msg = "";
		try {
			len = input.read(b);
			msg = new String(b, 0, len);
			if (msg.equals("start")) {
				System.out
						.println("received the start message, receive now can do something......");
				Thread.interrupted();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (input != null) {
					input.close();
					input = null;
				}
			} catch (Exception e) {
			}
		}
	}

	public void run() {
		try {
			receive();
		} catch (Exception e) {
		}
	}
}

如何使用这两个类呢？


TestPipeStream

package org.sky.io;

public class TestPipeStream {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		SendMessage send = new SendMessage();
		ReceiveMessage receive = new ReceiveMessage();
		try {
			send.getOut().connect(receive.getInput());
			Thread t1 = new Thread(send);
			Thread t2 = new Thread(receive);
			t1.start();
			t2.start();

		} catch (Exception e) {
			e.printStackTrace();
		}

	}

}

注意这边有一个send.getOut().connect(receive.getInput());


这个方法就把两个线程”connect“起来了。


Serializable的IO操作


把一个类序列化到磁盘上，怎么做？


先来看我们要序列化的一个Java Bean


Person

package org.sky.io;

import java.io.Serializable;

public class Person implements Serializable {

	private String name = "";
	private String age = "";
	private String personId = "";

	public String getName() {
		return name;
	}

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

	public String getAge() {
		return age;
	}

	public void setAge(String age) {
		this.age = age;
	}

	public String getPersonId() {
		return personId;
	}

	public void setPersonId(String personId) {
		this.personId = personId;
	}

	public String getCellPhoneNo() {
		return cellPhoneNo;
	}

	public void setCellPhoneNo(String cellPhoneNo) {
		this.cellPhoneNo = cellPhoneNo;
	}

	private String cellPhoneNo = "";
}

下面来看序列化的操作

SerializablePersonToFile

package org.sky.io;

import java.io.*;
import java.util.*;

public class SerializablePersonToFile {

	/**
	 * @param args
	 */
	private List<Person> initList() {
		List<Person> userList = new ArrayList<Person>();
		Person loginUser = new Person();
		loginUser.setName("sam");
		loginUser.setAge("30");
		loginUser.setCellPhoneNo("13333333333");
		loginUser.setPersonId("111111111111111111");
		userList.add(loginUser);
		loginUser = new Person();
		loginUser.setName("tonny");
		loginUser.setAge("31");
		loginUser.setCellPhoneNo("14333333333");
		loginUser.setPersonId("111111111111111111");
		userList.add(loginUser);
		loginUser = new Person();
		loginUser.setName("jim");
		loginUser.setAge("28");
		loginUser.setCellPhoneNo("15333333333");
		loginUser.setPersonId("111111111111111111");
		userList.add(loginUser);
		loginUser = new Person();
		loginUser.setName("Simon");
		loginUser.setAge("30");
		loginUser.setCellPhoneNo("17333333333");
		loginUser.setPersonId("111111111111111111");
		userList.add(loginUser);
		return userList;
	}

	private  void serializeFromFile() {
		FileInputStream fs = null;
		ObjectInputStream ois = null;
		try {
			fs = new FileInputStream("person.txt");
			ois = new ObjectInputStream(fs);
			List<Person> userList = (ArrayList<Person>) ois.readObject();
			for (Person p : userList) {
				System.out.println(p.getName() + "   " + p.getAge() + "   "
						+ p.getCellPhoneNo() + "   " + p.getCellPhoneNo());
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		} finally {
			try {
				if (ois != null) {
					ois.close();
				}
			} catch (Exception e) {
			}
			try {
				if (fs != null) {
					fs.close();
				}
			} catch (Exception e) {
			}
		}
	}

	private void serializeToFile() {
		List<Person> userList = new ArrayList<Person>();
		userList = initList();
		FileOutputStream fs = null;
		ObjectOutputStream os = null;
		try {
			fs = new FileOutputStream("person.txt");
			os = new ObjectOutputStream(fs);
			os.writeObject(userList);
		} catch (Exception ex) {
			ex.printStackTrace();
		} finally {
			try {
				if (os != null) {
					os.close();
				}
			} catch (Exception e) {
			}
			try {
				if (fs != null) {
					fs.close();
				}
			} catch (Exception e) {
			}
		}
	}

	public static void main(String[] args) {
		SerializablePersonToFile sf = new SerializablePersonToFile();
		sf.serializeToFile();
		sf.serializeFromFile();
	}

}

这边先把Person输出到Person.txt，再从Person.txt里反序列化出这个Person的Java Bean。


先讲这么些吧！

Java的流操作还有很多，这些是经常会被面试到的，很基础，因此经常被考到。

以前听一个读IT的同学说过，这些IO操作，就算没有Eclipse编辑器的话，用文本编辑器也应该能够写出来，你写不出只能代表你的基础太弱了。




分享到：
| 鲍尔默在微软最大的遗憾？
评论
发表评论

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

相关推荐

    Think-in-JAVA-4th-Edition

    ### 《Think-in-JAVA-4th-Edition》核心知识点概览 #### 一、书籍简介 《Thinking in Java》是一本由Bruce Eckel撰写的经典Java编程书籍，被誉为是学习Java的最佳参考资料之一。该书适合具有一定Java基础的学习者...

    think-in-java

    《Think in Java》是Java编程领域的一本经典著作，由Bruce Eckel撰写，中文版的出现使得更多中国程序员能够深入理解和掌握Java编程语言的核心概念。这本书以其深入浅出的讲解方式，深受程序员们的喜爱，是许多初学者...

    java学习-think in java

    think in java 文档

    Think in Java3

    《Think in Java 3》是一本深受欢迎的Java编程指南，由Bruce Eckel撰写，它以其详尽的解释和丰富的示例闻名。这本书是许多Java初学者和专业开发者的重要参考资料，旨在帮助读者深入理解Java语言的核心概念和机制。...

    Think in java第三版代码

    《Think in Java》是Java编程领域的一本经典著作，由Bruce Eckel撰写，深受程序员喜爱。这本书通过深入浅出的方式讲解了Java语言的核心概念和技术，包括面向对象编程、数据结构、算法以及网络编程等多个方面。"Think...

    think in java source code

    《Think in Java》是Bruce Eckel的经典编程教材，它深入浅出地讲解了Java语言的基础概念和高级特性。源码整理则为读者提供了实践和学习的机会，帮助理解书中的示例和理论。以下是对《Think in Java》源码中一些重要...

    Think in java 源码构建编译

    Think in java 源码构建编译

    think in java 练习

    《Think in Java》是 Bruce Eckel 的经典著作，它深入浅出地讲解了Java编程语言的核心概念和技术。这本书强调理解编程思想，而不仅仅是学习语法。练习题是学习过程中的重要部分，它们帮助我们巩固理论知识，提升实际...

    think in java 英文第四版 高清完整PDF版

    java think in java （英文第四版）至今为止 被认为是java教程之中权威作品之一

    think-in-java.pdf

    作者：贯穿本书，我试图在您的大脑里建立一个模型——或者说一个“知识结构”。这样可加深对语言的理解。若遇到难解之处，应学会把它填入这个模型的对应地方，然后自行演绎出答案。事实上，学习任何语言时，脑海里有...

    Think In Java 4(完美高清中文版).

    《Think In Java 4》是Java编程领域里一本极具影响力的著作，由资深程序员 Bruce Eckel 编著。这本书以其深入浅出的讲解方式和全面的知识覆盖而闻名，被誉为Java学习者的经典读物。中文版的完美高清版本为国内读者...

    java 初学入门--think in java

    Java初学入门——《Think in Java》精要 在编程世界中，Java是一种广泛应用的面向对象的编程语言，尤其在企业级应用开发中占据主导地位。对于初学者来说，掌握Java的基本概念和语法是至关重要的。《Think in Java》...

    Think Data Structures in Java azw3

    Think Data Structures in Java 英文azw3 本资源转载自网络，如有侵权，请联系上传者或csdn删除 本资源转载自网络，如有侵权，请联系上传者或csdn删除

    thinkinjava源码-Think-In-Java-Code:ThinkingInJava（第四版）书中源码以及课后练习代码

    Think-In-Java-Code Thinking In Java 书中源码以及课后练习代码(从第7章开始随着看书的进度一步步更新) 第七章 复用类 7.1 组合语法 7.2 继承语法 7.2.1 初始化基类 7.3 代理 7.4 结合使用组合和继承 7.4.1 确保...

    ThinkSystem RAID 530-8i驱动forsever2016or2012

    《ThinkSystem RAID 530-8i驱动在Server 2016及2012中的应用详解》 在IT行业中，服务器硬件的稳定性和性能是至关重要的，特别是存储设备，它直接关系到数据的安全性和系统运行效率。联想ThinkSystem系列服务器以其...

    think in java 4 源码 eclipse工程版

    think in java 第四版 源码以及作业 eclipse版本 包含jar包 可以直接导入eclipse

    Think in Java(中文版)-chm格式

    1.11 Java和因特网 1.11.1 什么是Web？ 1.11.2 客户端编程 1.11.3 服务器端编程 1.11.4 一个独立的领域：应用程序 1.12 分析和设计 1.12.1 不要迷失 1.12.2 阶段0：拟出一个计划 1.12.3 阶段1：要制作什么？...

    think in java4源代码

    《Think in Java 4》是Java编程领域的一部经典之作，由Bruce Eckel撰写，它以其深入浅出的讲解方式和丰富的示例代码深受程序员喜爱。这个压缩包包含的就是这本书的全部源代码，旨在帮助读者更好地理解和实践书中所...

    Think in JAVA 编程思想 第四版 清晰扫描版

    《Think in JAVA 编程思想》是Java编程领域的一本经典著作，由Bruce Eckel撰写。第四版作为该书的最新版本，包含了作者对Java语言深入的理解和丰富的编程经验，旨在帮助读者理解面向对象编程的核心理念，并提升编程...

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