public class HelloWorld {
	public static void main(String[] args) {
		int i = 0;
		String greetings[] = { "HelloWorld!", "No,I mean it!", "HeELLO WORLD!!" };
		while (i < 4) {
			System.out.println(greetings[i]);
			i++;
		}
	}
}

HelloWorld!
No,I mean it!
HELLO WORLD!!
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
	at HelloWorld.main(HelloWorld.java:6)

public void openThisFile(String fileName) throws java.io.FileNotFoundException{
    //code for method
}
public void getCustomerInfo()throws java.io.FileNotFoundException{
    //do something
    this.openThisFile("customer.txt");
    //do something
}

try{
    statement(s)
}catch(exceptiontype name){
    statement(s)
}finally{
    statement(s)
}

java.lang.ArithmeticException
java.lang.ArrayIndexOutOfBoundsException
java.lang.StringIndexOutOfBoundsException

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;

public class Redirecting {
	public static void main(String[] args) throws IOException {
		BufferedInputStream in = new BufferedInputStream(new FileInputStream("Redirecting.java"));// 构造一个输入流备用，这个输入流直接关联到磁盘文件，此处使用java源代码
		PrintStream out = new PrintStream(new BufferedOutputStream(new FileOutputStream("test.out")));// 构造一个输出流对象，这个输出流对象直接关联到磁盘文件，此处随便起一个名字，text.out自然也是文本文件
		System.setIn(in);// 调用setIn方法，将标准输入流重新定向到in
		System.setOut(out);// 调用setOut方法，将标准输出流重新定向到out
		System.setErr(out);// 关联标准输出错误流
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));// 构造有缓冲的输入流，可以使输入的效率更高一些，但是BufferedReader本身并不执行读磁盘文件的操作，只是一个处理流，因此我们需要一个真正读取文件信息的节点流作为参数来构造缓冲的BufferedReader，因此将System.in作为参数传给InputStreamReader，InputStreamReader是面向字节的流和面向字符的流的桥梁。此处的System.in已经是重定向到磁盘文件的输入流了
		String s;
		while ((s = br.readLine()) != null) {
			System.out.println(s);//out经过了重定向，所以输出到磁盘文件
		}
		in.close();
		out.close();
	}
}

import java.io.*;

public class FileWriterTester {
	public static void main(String[] args) throws IOException {
		// main 方法中声明抛出IO异常
		String fileName = "Hello.txt";//相对路径名，在当前工作文件夹下的文件
		FileWriter writer = new FileWriter(fileName);//创建FileWriter输出流对象writer
		writer.write("Hello!\n");
		writer.write("This is my first text file,\n");
		writer.write("You can see how this is done.\n");
		writer.write("输入一行中文也可以\n");
		writer.close();//关闭文件
	}
}

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterTester {
	public static void main(String[] args) {
		String fileName = "Hello.txt";
		try {
			FileWriter writer = new FileWriter(fileName, true);
			writer.write("Hello!\n");
			writer.write("This is my first text file,\n");
			writer.write("You can see how this is done");
			writer.write("输入一行中文也可以\n");
			writer.close();
		} catch (IOException iox) {
			System.out.println("Problem writing" + fileName);
		}
	}
}

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class FileWriterTester {
	public static void main(String[] args) throws IOException {
		String fileName = "Hello.txt";
		BufferedWriter out = new BufferedWriter(new FileWriter(fileName));
		out.write("Hello!");
		out.newLine();
		out.write("This is another text file using BufferedWriter");
		out.newLine();
		out.write("So I can us a common way to start a new line");
		out.close();
	}
}

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

public class BuffereddReaderTester {
	public static void main(String[] args) {
		String fileName = "Hello.txt", line;
		//文本访问操作有可能产生异常，因此用try-catch块
        try {
			BufferedReader in = new BufferedReader(new FileReader(fileName));
			line = in.readLine();
			while (line != null) {
				System.out.println(line);
				line = in.readLine();
			}
			in.close();
		} catch (IOException iox) {
			System.out.println("Problem reading " + fileName);
		}
	}
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyMaker {
	String sourceName, destName;
	// 以下两个引用将要指向读写
	BufferedReader source;
	BufferedWriter dest;
	String line;

	private boolean openFiles() {
		// try-catch捕获异常
		try {
			source = new BufferedReader(new FileReader(sourceName));
		} catch (IOException iox) {
			System.out.println("Problem opening " + sourceName);
			return false;
		}
		try {
			dest = new BufferedWriter(new FileWriter(destName));
		} catch (IOException iox) {
			System.out.println("Problem opening " + destName);
			return false;
		}
		return true;
	}

	private boolean copyFiles() {
		try {
			line = source.readLine();
			while (line != null) {
				dest.write(line);
				dest.newLine();// 跨平台换行符
				line = source.readLine();
			}
		} catch (IOException iox) {
			System.out.println("Problem reading or writing");
			return false;
		}
		return true;
	}

	private boolean closeFiles() {
		boolean retVal = true;// 满足但出口，符合结构化程序设计思想
		try {
			source.close();
		} catch (IOException iox) {
			System.out.println("Problem closing " + sourceName);
			retVal = false;
		}
		try {
			dest.close();
		} catch (IOException iox) {
			System.out.println("Problem closing " + destName);
			retVal = false;
		}
		return retVal;
	}

	public boolean copy(String src, String dst) {
		sourceName = src;
		destName = dst;
		// 若返回值结果为真说明三个操作都正确完成了，否则说明出现了错误
		return openFiles() && copyFiles() && closeFiles();
	}
}

public class FileCopy {
	public static void main(String[] args) {
		if (args.length == 2) {// 参数个数正确
			new CopyMaker().copy(args[0], args[1]);
		} else {
			System.out.println("Please Enter File Names");
		}
		// eclipse输入命令行参数的方法可以参考https://blog.csdn.net/weixin_43896318/article/details/101846956
	}
}

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

//将三个int型数字255/0/-1写入数据文件data1.dat
public class FileOutputstreamTester {
	public static void main(String[] args) {
		String fileName = "data1.dat";
		int value0 = 255;
		int value1 = 0;
		int value2 = -1;
		try {
			// FileOutputStream是原生字节流，只能识别写出的是字节，不能识别int,double
			// DataOutputStream可以将字节处理成某种类型的数据
			DataOutputStream out = new DataOutputStream(new FileOutputStream(fileName));
			out.writeInt(value0);
			out.writeInt(value1);
			out.writeInt(value2);
			out.close();
			System.out.println("Finished writing");
		} catch (IOException iox) {
			System.out.println("Problem writing " + fileName);
		}
	}
}

DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(fileName)));

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

public class BufferedOutputStreamTester {
	// 没有捕获异常所以声明抛出了异常
	public static void main(String[] args) throws IOException {
		String fileName = "mixedTypes.dat";
		// 原生字节输出流->缓冲
		DataOutputStream dataOut = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(fileName)));
		dataOut.writeInt(0);
		// dataOut.size()返回的是一共写了多少字节而非当前
		System.out.println(dataOut.size() + "bytes have been written.");
		dataOut.writeDouble(31.2);
		System.out.println(dataOut.size() + "bytes have been written.");
		dataOut.writeBytes("JAVA");
		System.out.println(dataOut.size() + "bytes have been written.");
		dataOut.close();
	}
}

4bytes have been written.
12bytes have been written.
16bytes have been written.

public class FileOutputStreamTester2 {
	public static void main(String[] args) throws IOException {
		DataOutputStream out = new DataOutputStream(new FileOutputStream("trytry.dat"));
		out.writeByte(-1);// 应该写入2个F(8个1)
		out.close();
		DataInputStream in = new DataInputStream(new FileInputStream("trytry.dat"));
		int a = in.readByte();
		System.out.println(Integer.toHexString(a));
		System.out.println(a);
		in.skip(-1);// 往后一个位置，以便下面重新读出
		a = in.readUnsignedByte();
		System.out.println(Integer.toHexString(a));
		System.out.println(a);
		in.close();
	}
}

ffffffff
-1
ff
255

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class DataInputStreamTester {
	public static void main(String[] args) {
		String fileName = "data1.dat";
		int sum = 0;
		try {
			DataInputStream instr = new DataInputStream(new BufferedInputStream(new FileInputStream(fileName)));
			sum += instr.readInt();
			sum += instr.readInt();
			sum += instr.readInt();
			System.out.println("The sum is: " + sum);
			instr.close();
		} catch (IOException iox) {
			System.out.println("Problem reading " + fileName);
		}
	}
}

254

public class DataInputStreamTester {
	public static void main(String[] args) {
		String fileName = "data1.dat";
		long sum = 0;
		try {
			DataInputStream instr = new DataInputStream(new BufferedInputStream(new FileInputStream(fileName)));
			try {
				while (true) {
					sum += instr.readInt();
				}
			} catch (EOFException eof) {
				System.out.println("The sum is:" + sum);
				instr.close();
			}
		} catch (IOException iox) {
			System.out.println("IO Problems with " + fileName);
		}
	}
}
//使用了嵌套try-catch块

import java.io.FileInputStream;
import java.io.IOException;

public class InputStreamTester {
	public static void main(String[] args) throws IOException {
		FileInputStream s = new FileInputStream("Hello.txt");
		int c;
		while ((c = s.read()) != -1) {
			System.out.write(c);
		}
		s.close();
	}
}
//说明：read()方法读取一个字节，转化为[0,255]间的一个整数，返回一个int。如果读到了文件末尾，则返回-1.
//write(int)方法写一个字节的低8位，忽略高24位（高低需要看大端小端）

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyBytes {
	public static void main(String[] args) {
		DataInputStream instr;
		DataOutputStream outstr;
		if (args.length != 2) {
			System.out.println("Please enter file names");
			return;
		}
		try {
			instr = new DataInputStream(new BufferedInputStream(new FileInputStream(args[0])));
			outstr = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(args[1])));
			try {
				int data;
				while (true) {
					data = instr.readUnsignedByte();
					outstr.writeByte(data);
				}
			} catch (EOFException eof) {
				outstr.close();
				instr.close();
				return;
			}
		} catch (FileNotFoundException nfx) {//先捕获比较具体的文件未找到异常
			System.out.println("Problem opening files");
		} catch (IOException iox) {//再捕获比较一般的异常
			System.out.println("IO Problems");
		}
	}
}

//创建文件Hello.txt，如果存在则删除旧文件，不存在则直接创建新的
import java.io.File;

public class FileTester {
	public static void main(String[] args) {
		File f = new File("Hello.txt");
		if (f.exists()) {
			f.delete();
		} else {
			try {
				f.createNewFile();
			} catch (Exception e) {
				System.out.println(e.getMessage());
			}
		}
	}
}

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class NewCopyBytes {
	public static void main(String[] args) {
		DataInputStream instr;
		DataOutputStream outstr;
		if (args.length != 2) {
			System.out.println("Please enter file names");
			return;
		}
		// 确定文件都存在，否则给用户提示
		File inFile = new File(args[0]);
		File outFile = new File(args[1]);
		if (outFile.exists()) {
			System.out.println(args[1] + " already exists");
			return;
		}
		if (!inFile.exists()) {
			System.out.println(args[0] + " does not exist");
			return;
		}
		try {
			instr = new DataInputStream(new BufferedInputStream(new FileInputStream(args[0])));
			outstr = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(args[1])));
			try {
				int data;
				while (true) {
					data = instr.readUnsignedByte();
					outstr.writeByte(data);
				}
			} catch (EOFException eof) {
				outstr.close();
				instr.close();
				return;
			}
		} catch (FileNotFoundException nfx) {
			System.out.println("Problem opening files");
		} catch (IOException iox) {
			System.out.println("IO Problems");
		}
	}
}

//将文本文件Hello.txt压缩为文件test.gz，再解压该文件，显示其中内容，并另存为newHello.txt
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

public class GZIPTester {
	public static void main(String[] args) throws IOException {
		// 构建原生字节文件输入流对象
		FileInputStream in = new FileInputStream("Hello.txt");
		// 在普通输入流外接GZIPOutputStream对象
		GZIPOutputStream out = new GZIPOutputStream(new FileOutputStream("test.gz"));
		System.out.println("Writing compressing file from Hello.txt to test.gz");
		// 以下实现文件复制
		int c;
		while ((c = in.read()) != -1) {
			out.write(c);// 写压缩文件
		}
		in.close();
		out.close();
		System.out.println("Reading file from test.gz to monitor");
		// InputStreamReader:面向字节的流和面向字符的流的桥梁 BufferedReader实现按行读
		BufferedReader in2 = new BufferedReader(
				new InputStreamReader(new GZIPInputStream(new FileInputStream("test.gz"))));
		String s;
		while ((s = in2.readLine()) != null) {
			System.out.println(s);
		}
		in2.close();
		System.out.println("Writing decompression to newHello.txt");
		GZIPInputStream in3 = new GZIPInputStream(new FileInputStream("test.gz"));
		FileOutputStream out2 = new FileOutputStream("newHello.txt");
		while ((c = in3.read()) != -1) {
			out2.write(c);
		}
		in3.close();
		out2.close();
	}
}

//从命令行输入若干个文件名，将所有文件压缩为"test.zip"，再从此压缩文件中解压并显示
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

public class ZipOutputStreamTester {
	public static void main(String[] args) throws IOException {
		ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream("test.zip")));
		int len = args.length;
		for (int i = 0; i < len; i++) {
			System.out.println("Writing file " + args[i]);
			BufferedInputStream in = new BufferedInputStream(new FileInputStream(args[i]));
			out.putNextEntry(new ZipEntry(args[i]));
			int c;
			while ((c = in.read()) != -1) {
				out.write(c);
			}
			in.close();
		}
		out.close();
		System.out.println("Reading File");
		// 解压缩流<-缓冲流<-二进制流
		ZipInputStream in2 = new ZipInputStream(new BufferedInputStream(new FileInputStream("test.zip")));
		ZipEntry ze;
		// 逐个文件判断
		while ((ze = in2.getNextEntry()) != null) {
			System.out.println("Reading File " + ze.getName());
			int x;
			// 读的同时解压缩了
			while ((x = in2.read()) != -1) {
				System.out.write(x);
			}
			System.out.println();
		}
		in2.close();
	}
}

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

public class Unzip {
	byte doc[] = null;// 存储解压缩数据的缓冲字节数组
	String Filename = null;// 压缩文件名字字符串
	String UnZipPath = null;// 解压缩路径字符串

	public Unzip(String filename, String unZipPath) {
		this.Filename = filename;
		this.UnZipPath = unZipPath;
		this.setUnZipPath(this.UnZipPath);
	}

	public Unzip(String filename) {
		this.Filename = new String(filename);
		this.UnZipPath = null;
		this.setUnZipPath(this.UnZipPath);
	}

	private void setUnZipPath(String unZipPath) {
		if (unZipPath.endsWith("\\")) {
			this.UnZipPath = new String(unZipPath);
		} else {
			this.UnZipPath = new String(unZipPath + "\\");
		}
	}

	public void doUnZip() {
		try {
			ZipInputStream zipis = new ZipInputStream(new FileInputStream(Filename));
			ZipEntry fEntry = null;
			while ((fEntry = zipis.getNextEntry()) != null) {
				if (fEntry.isDirectory()) {// 是路径则创建路径
					checkFilePath(UnZipPath + fEntry.getName());// 判断路径是否存在
				} else {// 是文件则解压缩文件
					String fname = new String(UnZipPath + fEntry.getName());
					try {
						FileOutputStream out = new FileOutputStream(fname);
						doc = new byte[512];// 一次多读一些字节
						int n;
						while ((n = zipis.read(doc, 0, 512)) != -1) {// 返回值是实际读到的字符数，文件末尾即-1
							out.write(doc, 0, n);
						}
						out.close();
						out = null;
						doc = null;
					} catch (Exception ex) {

					}
				}
			}
			zipis.close();
		} catch (IOException ioe) {
			System.out.println(ioe);
		}
	}

	private void checkFilePath(String dirName) throws IOException {
		File dir = new File(dirName);
		if (!dir.exists()) {
			dir.mkdirs();// 创建所有缺失的目录
		}
	}
}

public class UnZipTester {
	public static void main(String[] args) {
		String zipFile = args[0];// 第一个参数为zip文件名
		String unZipPath = args[1] + "\\";// 第二个参数为指定解压缩路径
		Unzip myZip = new Unzip(zipFile, unZipPath);
		myZip.doUnZip();
	}
}

import java.io.Serializable;

// 创建一个书籍对象，并把它输出到一个文件book.dat中，然后再把该对象读出来，在屏幕上显示对象信息
public class Book implements Serializable {
	// Serializable接口知识标志对象可以被序列化，事实上里面是空的
	int id;
	String name;
	String author;
	double price;

	public Book(int id, String name, String author, double price) {
		this.id = id;
		this.name = name;
		this.author = author;
		this.price = price;
	}
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializableTester {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		Book book = new Book(100032, "Java Programming Skills", "Wang Sir", 30.0);
		// 在普通的输出流之外加一个ObjectOutputStream，以便可以写出对象
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("book.dat"));
		oos.writeObject(book);
		oos.close();
		book = null;
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("book.dat"));
		// 需要额外的文档记录我们究竟写入了什么对象
		book = (Book) ois.readObject();
		ois.close();
		System.out.println("ID is:" + book.id);
		System.out.println("name is:" + book.name);
		System.out.println("author is:" + book.author);
		System.out.println("price is:" + book.price);
	}
}

ID is:100032
name is:Java Programming Skills
author is:Wang Sir
price is:30.0

public class Employee {
	char[] name = { '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000' };
	int age;

	public Employee(String name, int age) throws IOException {
		if (name.toCharArray().length > 8) {
			System.arraycopy(name.toCharArray(), 0, this.name, 0, 8);
		} else {
			System.arraycopy(name.toCharArray(), 0, this.name, 0, name.toCharArray().length);
		}
		this.age = age;
	}
}

import java.io.RandomAccessFile;

public class RandomAccessFileTester {
	String Filename;

	public RandomAccessFileTester(String Filename) {
		this.Filename = Filename;
	}

	public void writeEmployee(Employee e, int n) throws Exception {
		RandomAccessFile ra = new RandomAccessFile(Filename, "rw");
		ra.seek(n * 20);
		for (int i = 0; i < 8; i++) {
			ra.writeChar(e.name[i]);
		}
		ra.writeInt(e.age);
		ra.close();
	}

	public void readEmployee(int n) throws Exception {
		char buf[] = new char[8];
		RandomAccessFile ra = new RandomAccessFile(Filename, "r");
		ra.seek(n * 20);
		for (int i = 0; i < 8; i++) {
			buf[i] = ra.readChar();
		}
		System.out.println("name:");
		System.out.println(buf);
		System.out.println("age:" + ra.readInt());
		ra.close();
	}

	public static void main(String[] args) throws Exception {
		RandomAccessFileTester t = new RandomAccessFileTester("temp/1.txt");
		Employee e1 = new Employee("zhangSantt", 23);
		Employee e2 = new Employee("李晓珊", 33);
		Employee e3 = new Employee("王华", 19);
		t.writeEmployee(e1, 0);
		t.writeEmployee(e3, 2);
		System.out.println("第一个雇员信息：");
		t.readEmployee(0);
		System.out.println("第三个雇员信息：");
		t.readEmployee(2);
		System.out.println("第二个雇员信息：");
		t.readEmployee(1);
	}
}