Java进阶语法之输入输出线程反射

冷不防 2024-03-30 08:54 100阅读 0赞

## 1. 文件复制 ##

import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class Java_IO_File_Copy {
        
        public static void main(String[] args) {
        
            // TODO Java IO - 文件复制
    
            // TODO 数据源文件对象
            File srcFile = new File("E:\\Code\\Java\\Test\\word.txt");
            // TODO 数据目的地文件对象（自动生成）
            File destFilt = new File("E:\\Code\\Java\\Test\\word.txt.copy");
    
            // TODO 文件输入流（管道对象）
            FileInputStream in = null;
            // TODO 文件输出流（管道对象）
            FileOutputStream out = null;
            // TODO 文件输入流（管道对象）
            try{
        
                in = new FileInputStream(srcFile);
                out = new FileOutputStream(destFilt);
                int data = -1;
                while((data = in.read()) != -1){
        
                    // TODO 打开阀门，流转数据（输出）
                    out.write(data);
                }
            }catch(IOException e){
        
                throw new RuntimeException(e);
            }finally{
        
                if( in != null){
        
                    try{
        
                        in.close();
                    } catch (IOException e){
        
                        throw new RuntimeException(e);
                    }
                }
                if( out != null){
        
                    try{
        
                        out.close();
                    } catch (IOException e){
        
                        throw new RuntimeException(e);
                    }
                }
            }
        }
    }

## 2. 字符流 ##

import java.io.*;
    
    public class Java_File_Copy_String {
        
        public static void main(String[] args) {
        
            // TODO Java IO - 文件复制
    
            // TODO 数据源文件对象
            File srcFile = new File("E:\\Code\\Java\\Test\\word.txt");
            // TODO 数据目的地文件对象（自动生成）
            File destFilt = new File("E:\\Code\\Java\\Test\\word.txt.copy");
    
            // TODO 字符输入流（管道对象）
            BufferedReader reader = null;
            // TODO 字符输出流（管道对象）
            PrintWriter writer = null;
    
            try{
        
                reader = new BufferedReader(new FileReader(srcFile));
                writer = new PrintWriter(destFilt);
    
                // TODO 打开阀门，流转数据（输入）
                // 读取文件中的一行数据（字符串）
                String line = null;
    
                while((line = reader.readLine()) != null){
        
                    System.out.println(line);
                    writer.println(line);
                }
                // 编写数据
                writer.flush();
    
            } catch(IOException e){
        
                throw new RuntimeException(e);
            } finally{
        
                if( reader != null){
        
                    try{
        
                        reader.close();
                    } catch(IOException e){
        
                        throw new RuntimeException(e);
                    }
                }
                if( writer != null){
        
                    writer.close();
                }
            }
        }
    }

## 3. 进程总结 ##

1.  咱们自己的程序就是一个进程
2.  进程的名字就是执行的类的名字

## 4. 线程 ##

public class Java_Thread {
        
        public static void main(String[] args) {
        
            // TODO 线程
            // Thread t = new Thread();
            MyThread t = new MyThread();
    
            // TODO 启动线程
            t.start();
    
            // Thread是线程类
            // currentThread方法用于获取当前正在运行的线程
            // getName方法用于获取线程的名称
            // main方法运行main线程中
            System.out.println(Thread.currentThread().getName());
        }
    }
    
    // TODO 声明自定义线程类
    class MyThread extends Thread{
        
        // 重写运行指令
    
        public void run(){
        
            System.out.println("MyThread:" + Thread.currentThread().getName());
        }
    
    }

1.  Java程序在运行的时候默认就会产生一个进程
2.  这个进程会有一个主线程
3.  代码都在主线程中执行  
    ![在这里插入图片描述][7d681a3d95034abda8e50261eab48d50.png]

public class Java_Thread {
        
        public static void main(String[] args) throws Exception{
        
            // TODO 线程 - 执行方式（串行，并发）
            // 串行执行: 多个线程连接成串，然后按照顺序执行
            // 并发执行：多个线程是独立，谁抢到了CPU得执行权，谁就能执行
    
            MyThread1 t1 = new MyThread1();
            MyThread2 t2 = new MyThread2();
    
            // TODO 启动线程
            t1.start();
            t2.start();
    
            // 将线程连接成串
            t1.join();
            t2.join();
    
            System.out.println("main线程执行完毕");
        }
    }
    
    // TODO 第一个线程
    class MyThread1 extends Thread{
        
        // 重写运行指令
    
        public void run(){
        
            System.out.println("MyThread-1:" + Thread.currentThread().getName());
        }
    
    }
    
    // TODO 第二个线程
    class MyThread2 extends Thread{
        
        // 重写运行指令
    
        public void run(){
        
            System.out.println("MyThread-2:" + Thread.currentThread().getName());
        }
    
    }

使用Thread.sleep()来使线程休眠

// TODO 构建线程对象时，可以只把逻辑传递给这个对象
    //      传递逻辑时，需要遵循规则：（）-> {逻辑}
    Thread t = new Thread(() -> {
        
            System.out.println("线程执行");
    });
    
    t.start();

// TODO 构建线程对象时，可以只把逻辑传递给这个对象
    //      传递逻辑时，需要遵循规则：（）-> {逻辑}
    Thread t = new Thread(new Runnable() {
        
            @Override
            public void run() {
        
                    System.out.println("线程执行");
            }
    });
    t.start();

## 5. 线程 ##

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Java_Thread_Pool {
        
        public static void main(String[] args) {
        
            // TODO 线程 - 线程池
            // 所谓的线程池，其实就是线程对象的容器
            // 可以根据需要，在启动时，创建一个或者多个线程对象
            // Java中有4种比较常见的线程池
            // 1. 创建固定数量的线程对象
            //    ExecutorService是线程服务对象
            // ExecutorService executorService = Executors.newFixedThreadPool(3);
            // 2. 根据需求的动态创建线程
            // ExecutorService executorService = Executors.newCachedThreadPool();
            // 3. 单一线程
            // ExecutorService executorService = Executors.newSingleThreadExecutor();
            // 4. 定时调度线程
            ExecutorService executorService = Executors.newScheduledThreadPool(3);
            
            for( int i = 0; i < 5; i ++){
        
                executorService.submit(new Runnable() {
        
                    @Override
                    public void run() {
        
                        System.out.println(Thread.currentThread().getName());
                    }
                });
            }
        }
    }

## 6. Wait & Sleep ##

1.  名字  
    wait：等待  
    sleep：休眠
2.  从属关系  
    wait：Object, 成员方法  
    sleep: Thread, 静态方法
3.  使用方式  
    wait：只

## 7. 线程安全 ##

所谓的线程安全问题，其实就是多个线程在并发执行时，修改了共享内存中共享对象的属性，导致的数据冲突问题。

## 8. 类加载器 ##

**Java中的类主要分为3种：**

1.  Java核心类库中的类：String, Object
2.  JVM软件平台开发商
3.  自己写的类，User，Child

**类加载器也有3种**

1.  BootClassLoader：启动类加载器（加载类时，采用操作系统平台语言实现）
2.  PlatformClassLoader：平台类加载器
3.  AppClassLoader：应用类加载器

参考资料：[7天搞定Java基础，Java零基础极速入门][7_Java_Java]

[7d681a3d95034abda8e50261eab48d50.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/1747a81fd6a249fa9683c58b7f634f86.png
[7_Java_Java]: https://www.bilibili.com/video/BV1o841187iP/?p=140&spm_id_from=333.1007.top_right_bar_window_history.content.click&vd_source=a1af903e57688df870625021f7f3a7eb