JavaSE 有这一篇就够（呕心狂敲41k字，只为博君一点赞！）（三）

        //指明详细的路径以及目录名
        File directory =new File("E:/demo");
        directory.mkdir();//mkdir用来创建单级文件夹
 
        File directorise =new File("E:/demo/demo1/demo2");
        directorise.mkdirs();//mkdirs用来创建多级文件夹

import java.io.File;
import java.io.IOException;
 
public class Review1 {
    public static void main(String[] args) throws IOException {
        //指明详细的路径以及目录名
        File directory =new File("E:/IO");
        search(directory);
    }
    //创建一个方法用来遍历目录里的文件
    public static void search(File file){
        File[] files =file.listFiles();获取到当前给定目录的子级文件/文件夹
        for (File f:files){
            if (f.isFile()){//若是文件,直接输出
                System.out.println(f);
            }else {
                  search(f);//若是目录,继续向下查找,直到遇到文件
            }
        }
    }
    
}

 public static void main(String[] args) throws IOException {
       
        FileInputStream inputStream1 =new FileInputStream("D:/ddd.docx");//输入流
        FileOutputStream outputStream1 =new FileOutputStream("E:/eee.docx");//输出流
        int a =0 ;
        while((a=inputStream1.read())!=-1){//只要a!=-1说明还未读完
            outputStream1.write(a);//写内容(以字节为单位)
        }
        //关闭通道,否则文件一直处于打开(占用)状态
        inputStream1.close();
        outputStream1.close();
    }

public static void main(String[] args) throws IOException {
        FileInputStream inputStream =new FileInputStream("D:/demo1.txt");
        FileOutputStream outputStream=new FileOutputStream("E:/IO.txt");
        byte[] bytes =new byte[10];
        //read(bytes) 一次读byte数组长度个字节,文件内容读取完后返回-1
        //size:每次实际往数组中装入的元素的个数
 
        int size =0;
        while((size=inputStream.read(bytes))!=-1){
        //一次向外写出一个byte数组长度个字节内容,从指定位置开始写，写size个
            outputStream.write(bytes,0,size);
        }
        inputStream.close();
        outputStream.close();
    }

 public static void main(String[] args) throws IOException {
        FileReader reader =new FileReader("E:/char1.txt");
        FileWriter writer =new FileWriter("E:/char2.txt");
        int b = 0;
        while((b=reader.read())!=-1) {
            System.out.println(b);//打印字符编码
            writer.write(b);
        }
        reader.close();
        writer.close();
    }

public static void main(String[] args) throws IOException {
        FileReader reader =new FileReader("E:/char1.txt");
        //保留原来的内容，在原内容基础上向后追加(续写)
        FileWriter writer =new FileWriter("E:/char2.txt",true);
        BufferedReader bufferedReader =new BufferedReader(reader);
        BufferedWriter bufferedWriter =new BufferedWriter(writer);
 
        String line = null ;
        while((line=bufferedReader.readLine())!=null){//只要每次读取不为空,则读取一行
            bufferedWriter.write(line);//写一行
            bufferedWriter.newLine();//插入换行符
        }
        bufferedReader.close();
        bufferedWriter.flush();
        bufferedWriter.close();//记得在读写完毕后关闭通道
 
    }

 public static void main(String[] args) throws IOException {
        FileInputStream inputStream = new FileInputStream("D:/demo1.txt");
        //封装的是一个节点流对象，可以提供缓冲功能，称为处理流/包装流
        BufferedInputStream bufferedInputStream =new BufferedInputStream(inputStream,20);
        FileOutputStream outputStream =new FileOutputStream("E:/IO.txt");
        BufferedOutputStream bufferedOutputStream =new BufferedOutputStream(outputStream,20);
 
        int size =0;
        byte[] bytes =new byte[10];
        while ((size=bufferedInputStream.read(bytes))!=-1){
            bufferedOutputStream.write(bytes,0,size);
        }
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }

import java.io.Serializable;
 
//如果一个类需要被序列化到文件中,那么这个类就需要实现Serializable接口
public class Student implements Serializable {
    private String name;
    private int age;
 
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

       //对象输出 (对象的序列化)
        Student student =new Student("小魏",20);//创建对象
        FileOutputStream fileOutputStream  = new FileOutputStream("E:/obj.txt");
        ObjectOutput output = new ObjectOutputStream(fileOutputStream);
        output.writeObject(student);
        output.flush();
        output.close();

  public static void main(String[] args) throws IOException, ClassNotFoundException {
        //对象输出 (对象的序列化)
        /*
        Student student =new Student("小魏",20);//创建对象
        FileOutputStream fileOutputStream  = new FileOutputStream("E:/obj.txt");
        ObjectOutput output = new ObjectOutputStream(fileOutputStream);
        output.writeObject(student);
        output.flush();
        output.close();
        */
        //对象输入 (对象的反序列化)
        FileInputStream inputStream  = new FileInputStream("E:/obj.txt");
        ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
        Student student = (Student) objectInputStream.readObject();//强制类型转换
        System.out.println(student);//打印对象信息
 
        objectInputStream.close();//记得关闭流通道
    }

public static void main(String[] args) {
        /* 
        int a = 10;
        int b =0 ;
        System.out.println(a/b);
        System.out.println("*****"); 
        */  //ArithmeticException 算术异常
 
       /* 
        int[] c=new int[2];
        c[3] = 0; 
        */   //ArrayIndexOutOfBoundsException 数组索引越界
 
       /* 
       String s = "abc";
        s.charAt(4);
        */   //StringIndexOutOfBoundsException 字符串索引越界
 
        /* 
        Object o = new Integer(10);
        String so = (String) o;
        */  //ClassCastException 类型转换异常
 
        /* 
        Integer.parseInt("abc"); 
        */  //NumberFormatException 数字格式化异常
 
        /*
        String ss = null;
        ss.length(); 
        */  //NullPointerException 使用null中的方法称为空指针异常      
    }

 public static void main(String[] args) {
        int a =10;
        int b = 0;
        try{
            int c = a/b;
        }catch (ArithmeticException aindex){
            aindex.printStackTrace();  //打印异常信息到控制台
            /* 一般在开发调试阶段使用，供开发人员定位异常问题 */
            System.out.println("算术异常");
        }
    }

public static void main(String[] args) {
        try {
            String s =null;
            s.length();
 
            int num =Integer.parseInt("1a");
 
            int[] b =new int[5];
            for (int i = 0; i <=b.length ; i++) {
                System.out.println(b[i]);
            }
        } catch (ArrayIndexOutOfBoundsException aindex) {
            aindex.printStackTrace();//打印异常信息
            System.out.println("数组索引越界,越界索引:"+aindex.getMessage());
            //getMessage()得到异常原因
        }catch (NumberFormatException nex){
            nex.printStackTrace();
            System.out.println("数字格式化异常:"+nex.getMessage());
        }catch (Exception e){//在具体捕获类型后catch Exception,可以捕获任意类型，但是必须放在最后面
            e.printStackTrace();
            System.out.println("系统繁忙~请稍后再试！");
        }
        System.out.println("继续执行后续程序");
 
    }

public static void main(String[] args) {
        int[] a = new int[5];
        try {
            for (int i = 0; i <= a.length; i++) {
                System.out.println(a[i]);
            }
        }catch (NumberFormatException nex){
            nex.printStackTrace();
            System.out.println("数字格式化异常:"+nex.getMessage());
        }finally {
            System.out.println("继续执行后续程序");
        }
    }

public static void main(String[] args) throws IOException {
       
        FileInputStream inputStream =null;
        try{
            inputStream =new FileInputStream("F:/demo.txt");
                    //文件若找不到，就会出现异常
        }catch (FileNotFoundException e){
            e.printStackTrace();
            System.out.println("文件找不到异常");
        }finally {
            //确保在出现异常时，仍然可以把流对象关闭掉
            if (inputStream!=null){
                inputStream.close();
            }
        }
    }

        try {
            //创建服务器对象
            ServerSocket serverSocket =new ServerSocket(8888);//(端口)
            System.out.println("服务器启动成功！");
            //监听客户端是否发送链接请求服务器
            Socket socket= serverSocket.accept();//等待监听客户端的连接
            System.out.println("有客户连接到了服务器！");
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            //创建客户端
            Socket socket = new Socket("127.0.0.1",8888);// ("服务器的IP",端口)
        } catch (IOException e) {
            e.printStackTrace();
        }

    public static void main(String[] args) {
        //创建客户端
        try {
            Socket socket=new Socket("127.0.0.1",8888);//服务器的IP  端口
            String s="你好世界";
            OutputStream outputStream=socket.getOutputStream();
            outputStream.write(s.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

     public static void main(String[] args) {
        //创建服务器对象
        try {
            ServerSocket serverSocket =new ServerSocket(8888);
            System.out.println("服务器启动成功！");
            //监听客户端是否发送链接请求服务器
            Socket socket = serverSocket.accept();//监听客户端的连接
            System.out.println("有客户端连接到了服务器");
            //后续操作...
            InputStream inputStream=socket.getInputStream();
            byte[] bytes =new byte[100];
            int size =inputStream.read(bytes);
            String s =new String(bytes,0,size);
            System.out.println(s);
 
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("服务器启动失败，端口已被占用");
        }
 
 
    }

 /*
    服务器
     */
    static Scanner scanner =new Scanner(System.in);
    public static void main(String[] args) {
        try {
            //创建服务器
            ServerSocket server = new ServerSocket(20049);
            System.out.println("服务器启动成功!");
            //监听客户端的连接
            Socket socket = server.accept();
            System.out.println("有客户端连接到了服务器!");
            //服务器接收客户端的消息
            while (true) {
                DataInputStream inputStream = new DataInputStream(socket.getInputStream());
                String string = inputStream.readUTF();
                System.out.println("服务器:" + string);
                //向客户端发送消息
                System.out.println("---->客户端:");
                String str = scanner.next();
                DataOutputStream dataOutputStream = new DataOutputStream(socket.getOutputStream());
                dataOutputStream.writeUTF(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }

public class Demo1 extends Thread{//继承Thread类
    @Override
    public void run() {//重写run方法
        for (int i = 1; i <= 200; i++) {
            System.out.println("run"+i);
        }
    }
}

public class Demo2 implements Runnable {//实现Runnable接口
    @Override
    public void run() {//重写run方法
        for (int i = 0; i < 200; i++) {
            System.out.println("自定义线程");
        }
    }
}

public class MyThread extends Thread{//我们使用了继承Thread的方法
    static int num =10;   //票总数10,且为共享资源,要用static修饰
    static String obj = new String();//可以是任意类对象,但必须唯一。
/*  synchronized(同步锁对象) {
         同步代码块
    }                         */
 
    @Override
    public void run() {//线程要执行的代码块要写在run()中
        while (true){
            synchronized (obj){//加锁,一次只能执行一个线程
                if(num>0){
                    try {
                        Thread.sleep(800);//此处加入休眠为了让运行结果更明显,也可不加
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"买到了第"+num+"张票");
                    num--;  //每抢一张票,总数num(10)就减1
                }else{
                    break;
                }
            }
        }
    }
}

 
public static void main(String[] args) {
        //创建两个线程，分别对应两个窗口
        MyThread myThread1 = new MyThread();
        myThread1.setName("窗口1");//线程1
        myThread1.start();
 
        MyThread myThread2 = new MyThread();
        myThread2.setName("窗口2");//线程2
        myThread2.start();
    }