FileInputStream fis = new FileInputStream("乌合之众.txt");  
    //创建一个文件输入流对象，并关联aaa.txt
    int b;                                                  
    //定义变量，记录每次读到的字节
    while((b = fis.read()) != -1) {                         
    //将每次读到的字节赋值给b并判断是否是-1
        System.out.println(b);                              
        //打印每一个字节
    }
    
    fis.close();                                            
//关闭流释放资源

        FileInputStream fis = new FileInputStream("李志 - 梵高先生.flac");
        FileOutputStream fos = new FileOutputStream("梵高先生.flac");
        int len;
        byte arr[] = new byte[8*1024];
        //自定义字节数组
        while((len=fis.read(arr))!=-1){
            fos.write(arr， 0， len);
            //写出字节数组写出有效个字节个数
        }
        fis.close();
        fos.close();

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("李志 - 梵高先生.flac"));
        //创建缓冲区对FileInputStream对象的装饰
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("2004-梵高先生.flac"));
        //创建缓冲区对FileOutputStream对象的装饰
int b;
while((b = bis.read()) != -1) {     
    bos.write(b);
}
        
bis.close();//只关装饰后的对象即可
bos.close();

FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("from.txt");
            fos = new FileOutputStream("to.txt");
            int b;
            while((b = fis.read()) != -1) {
                fos.write(b);
            }
        } finally {
            try {
                if(fis != null)
                    fis.close();
            }finally {
                if(fos != null)
                    fos.close();
            }
        }

try(
    FileInputStream fis = new FileInputStream("from.txt");
    FileOutputStream fos = new FileOutputStream("to.txt");
){
    int b;
    
    while((b = fis.read()) != -1) {
        fos.write(b);
    }
    
}

Scanner sc = new Scanner(System.in);
System.out.println("请输入一个文件路径");
String line = sc.nextLine();                //将键盘录入的文件路径存储在line中
File file = new File(line);                 //封装成File对象
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(file.getName());
int len;
byte[] arr = new byte[8192];                //定义缓冲区
while((len = fis.read(arr)) != -1) {
    fos.write(arr，0，len);
}
fis.close();
fos.close();

Scanner sc = new Scanner(System.in);
FileOutputStream fos = new FileOutputStream("text.txt");
System.out.println("请输入:");
while(true) {
    String line = sc.nextLine();
    if("quit".equals(line))
        break;
    fos.write(line.getBytes());
    fos.write("\r\n".getBytes());
}
fos.close();

FileWriter fw = new FileWriter("to.txt");
fw.write("write");
fw.close();

FileReader fr = new FileReader("from.txt");
FileWriter fw = new FileWriter("to.txt");
int ch;
while((ch = fr.read()) != -1) {
    fw.write(ch);
}
fr.close();
fw.close();

FileReader fr = new FileReader("form.txt");          
//创建字符输入流，关联aaa.txt
FileWriter fw = new FileWriter("to.txt");          
//创建字符输出流，关联bbb.txt
int len;
char[] arr = new char[1024*8];                      
//创建字符数组
while((len = fr.read(arr)) != -1) {                 
//将数据读到字符数组中
    fw.write(arr， 0， len);                          
    //从字符数组将数据写到文件上
}
fr.close();
//关流释放资源
fw.close(); 

BufferedReader br = new BufferedReader(new FileReader("form.txt")); 
//创建字符输入流对象，关联aaa.txt 
BufferedWriter bw = new BufferedWriter(new FileWriter("to.txt")); 
//创建字符输出流对象，关联bbb.txt
int ch;             
while((ch = br.read()) != -1) {
//read一次，会先将缓冲区读满，从缓冲去中一个一个的返给临时变量ch
    bw.write(ch);
    //write一次，是将数据装到字符数组，装满后再一起写出去
}
    
br.close(); 
//关流
bw.close();  

BufferedReader br = new BufferedReader(new FileReader("aaa.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("bbb.txt"));
String line; 
while((line = br.readLine()) != null) {
   bw.write(line); 
   //bw.write(""); //只支持windows系统 
   bw.newLine(); //跨平台的 
}
br.close();
bw.close(); 

LineNumberReader lnr = new LineNumberReader(new FileReader("form.txt")); 
String line; 
lnr.setLineNumber(100); //设置行号 
while((line = lnr.readLine()) != null) {
    System.out.println(lnr.getLineNumber() + ":" + line);//获取行号 
}
lnr.close(); 

interface Coder {
    public void code(); 
 }

 class XPersion implements Coder {
        private Persion s;                      
        //被包装的类的引用
        public XPersion (Persion s) {       
        //构造方法将被包装的对象作为参数传入
            this.s = s;
        }
        @Override
        public void code() {
        //对其原有功能进行升级
            s.code();
            System.out.println("Get cervical spondum buff");
            System.out.println("......");
            System.out.println("sudden death");
            System.out.println("......");
        }
        
    } 

BufferedReader br =  new BufferedReader(new InputStreamReader(new FileInputStream("UTF-8.txt")， "UTF-8"));
BufferedWriter bw =  new BufferedWriter(new OutputStreamWriter(new FileOutputStream("GBK.txt")， "GBK")); 
int ch; 
while((ch = br.read()) != -1) { 
    bw.write(ch); 
}
br.close();
bw.close();

FileInputStream fis1 = new FileInputStream("a.txt");            
//创建输入流对象,关联a.txt
FileInputStream fis2 = new FileInputStream("b.txt");            
//创建输入流对象,关联b.txt
SequenceInputStream sis = new SequenceInputStream(fis1, fis2);  
//将两个流整合成一个流
FileOutputStream fos = new FileOutputStream("c.txt");           
//创建输出流对象,关联c.txt
        
int b;
while((b = sis.read()) != -1) {                                 
//用整合后的输入流
    fos.write(b);                                               
    //写到指定文件上
}
        
sis.close();
fos.close(); 

FileInputStream fis = new FileInputStream("a.txt");
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int b;
while((b = fis.read()) != -1) {
    baos.write(b);
}
            
//byte[] newArr = baos.toByteArray();               
//将内存缓冲区中所有的字节存储在newArr中
//System.out.println(new String(newArr));
System.out.println(baos);
fis.close();

FileInputStream fis = new FileInputStream("a.txt");             
//创建字节输入流,关联a.txt
ByteArrayOutputStream baos = new ByteArrayOutputStream();       
//创建内存输出流
byte[] arr = new byte[5];                                       
//创建字节数组,大小为5
int len;
while((len = fis.read(arr)) != -1) {                            
//将文件上的数据读到字节数组中
    baos.write(arr, 0, len);                                    
    //将字节数组的数据写到内存缓冲区中
}
System.out.println(baos);                                       
//将内存缓冲区的内容转换为字符串打印
fis.close();

public class ObjectOutputStream {
    /**
     * @param args
     * @throws IOException 
     * 将对象写出,序列化
     */
     
    public static void main(String[] args) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e.txt"));//创建对象输出流
        oos.writeObject(p1);
        oos.writeObject(p2);
        oos.close();
    }
}

Person p1 = new Person("Tom", 20);
Person p2 = new Person("Jerry", 22);
Person p3 = new Person("Jack", 10);
Person p4 = new Person("Herry", 20);
ArrayList<Person> list = new ArrayList<>();
list.add(p1);
list.add(p2);
list.add(p3);
list.add(p4);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("f.txt"));
oos.writeObject(list);                                  
//写出集合对象
oos.close();

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("f.txt"));
ArrayList<Person> list = (ArrayList<Person>)ois.readObject();   
//泛型在运行期会被擦除,索引运行期相当于没有泛型
//想去掉黄色可以加注解@SuppressWarnings("unchecked")
for (Person person : list) {
    System.out.println(person);
}
        
ois.close();

PrintStream ps = System.out;
ps.println(97);                 
//底层用的是Integer.toString(x),将x转换为数字字符串打印
ps.println("a string");
ps.println(new Person("Tom", 20));
Person p = null;
ps.println(p);                  //如果是null,就返回null,如果不是null,就调用对象的toString()

PrintWriter pw = new PrintWriter(new FileOutputStream("g.txt"), true);
//如果为 true，则 println、printf 或 format 方法将刷新输出缓冲区
pw.write(97);
pw.print("Hello");
pw.println("你好");
pw.close();

System.setIn(new FileInputStream("a.txt"));             
//修改标准输入流
System.setOut(new PrintStream("b.txt"));                
//修改标准输出流
InputStream in = System.in;                             
//获取标准输入流
PrintStream ps = System.out;                            
//获取标准输出流
int b;
while((b = in.read()) != -1) {                          
//从a.txt上读取字节
    ps.write(b);                                        
    //将数据写到b.txt上
}
in.close();
ps.close();

System.setIn(new FileInputStream("png.png"));       
//改变标准输入流
System.setOut(new PrintStream("copy.png"));         
//改变标准输出流
InputStream is = System.in;                         
//获取标准输入流
PrintStream ps = System.out;                        
//获取标准输出流
int len;
byte[] arr = new byte[1024 * 8];
while((len = is.read(arr)) != -1) {
    ps.write(arr, 0, len);
}
is.close();
ps.close();

DataOutputStream dos = new DataOutputStream(new FileOutputStream("b.txt"));
dos.writeInt(998);
dos.writeInt(1998);
dos.writeInt(2998);
dos.close();

DataInputStream dis = new DataInputStream(new FileInputStream("b.txt"));
int x = dis.readInt();
int y = dis.readInt();
int z = dis.readInt();
System.out.println(x);
System.out.println(y);
System.out.println(z);
dis.close();

Properties prop = new Properties();
prop.put("abc", 123);
System.out.println(prop);

Properties prop = new Properties();
prop.setProperty("name", "Tom");
prop.setProperty("tel", "18000000000");
//System.out.println(prop);
Enumeration<String> en = (Enumeration<String>) prop.propertyNames();
while(en.hasMoreElements()) {
    String key = en.nextElement();              //获取Properties中的每一个键
    String value = prop.getProperty(key);       //根据键获取值
    System.out.println(key + "="+ value);
}

Properties prop = new Properties();
prop.load(new FileInputStream("config.properties"));        
//将文件上的键值对读取到集合中
prop.setProperty("tel", "18912345678");
prop.store(new FileOutputStream("config.properties"), null);
//第二个参数是对列表参数的描述,可以给值,也可以给null
System.out.println(prop);
Output:
{tel=18912345678}