java基础-4-CSDN博客

本文链接：https://blog.csdn.net/jks2r/article/details/122799747

1.IO流

输入流：分为两种情况：一种是字节输入流和字符输入流。
输出流：分为两种情况：一种是字节输出流和字符输出流。

字节输入流：InputStream
直接的子类FileInputStream，FileInputStream不具备缓冲的效果，要具备缓冲效果咋办
借助于一个叫BufferedInputStream。

字节输出流：OutputStream
直接子类FileOutpuStream 文件字节输出流
输出流是干嘛？内存-》磁盘
在java代码里面写一个字符串，写入到磁盘中某一个文件中
FileOutpuStream没有缓冲，如果想要加缓冲效果，需要加缓冲流BufferedOutputStream 字符输入流：
   Reader
   有一个孙子类叫FileReader
   专门处理文本类型的，一个非常方便的类，但是他处理音频视频图片是不行的，有可能出错
   底层依旧是使用字节进行读取的，但是中间会进行解码操作变成字符，但是一旦解码失败。读取数据将会失败。所以以后开发中不用Reader,老老实实的使用字节输入流不要用字符流
   FileReader是不具备缓冲的效果的，BufferedReader 让其具有缓冲效果
   输入流从磁盘-》内存
   比如磁盘上面有一个文件1.txt 可以将数据读取到内存java代码里面
   int read()
读一个字符
int read(char[] cbuf, int off, int len)
将字符读入数组的一部分。
String readLine() 字符输出流
   Writer子类FileWriter
   FileWriter不具备缓冲效果的，借助于BufferedWriter

2.常用类

2.1StringBuffer类

线程安全，可变的字符序列。字符串缓冲区就像一个String，但可以修改。在任何时间点，它包含一些特定的字符序列，但可以通过某些方法调用来更改序列的长度和内容。

String类拼接是开辟另外一个内存，StringBuffer直接在缓冲区域的后面直接添加

StringBuilder（线程不安全的）比StringBuffer（线程安全的）快比String快开发中遇到的String类型的数据偏多吗，所以用String用的比较多

2.2枚举类

Java中枚举类是一个特殊的类，一般是表示一组常量，一年的4个季节。一年12个月份。一个星期有7天。方向东西南北等

public static final int a = 20;java 声明常量的方式可以使用枚举代替常量

2.3包装类

每个基本数据类型在java中都有与之对应的包装类

为啥有包装类，包装类下面提供了很多的方法，让咱们对基本数据类型进行增删改查的操作上

int====>Integer byte===>Byte short====>Short long====>Long float====>Float

double ===>Double char===>Charater boolean===>Boolean

除了int 和char 其他的包装了都是首字母大写

1.JDK1.5之后有装箱和拆箱之说

装箱：将基本数据类型转为包装类对象

拆箱：将包装类对象转为基本数据类型

2.***Value();将包装类对象转为基本数据类型的

3.parse();将字符串转为基本数据类型【重点开发要用！！！】

4.valueOf();将基本数据类型转为包装类【开发中也会用】

3.线程

进程是需要通过系统的分配，获取系统当前的CPU，内存，显卡，网络等这些资源

1.独立性

2.互斥性

线程是组成进程的最小基本单位，每一个进程至少得有一个线程

线程的运行支撑起来进程的运行

人是一个进程细胞就是线程

线程具有什么特性：

1.抢占式运行【重点】

CPU在执行的时候，是按照时间片进行执行的。单位的时间片是相互抢占的 40ms

qq下面比如有两个线程，一个线程抢到资源 40ms以后这两个线程再次抢占资源，谁抢的算谁的

可以一直执行下面，咱们有的电脑卡的原因，你这个进程下面线程没有抢过别的软件的线程

你这个应用程序的线程在等待，显示会卡

2.资源共享性

一个应用程序中的线程可以共享当前的资源。比如CPU，内存，网络

Java程序：

一个java程序就是一个进程 Demo1main主函数属一个应用程序

一个java应用程序至少有两个线程：

1.main主函数线程

2.jvm 垃圾回收

进程和线程的区别

进程是一个完整的程序

线程是进程里面的执行的一个功能。

一个应用程序是由多个线程组成的

进程申请是系统的资源

线程申请是进程的资源

多个线程在执行的时候，cpu会根据每个线程分配的时间片聊来随机抢占执行

每个线程最多占用的时间片大概是20ms，过了时间片，就切换到其他线程了

并发和并行

并发：同时发生，轮流交替执行

并行:真正意义上的同时执行

创建线程的两个方式

第一种创建方式

Thread类：

1.声明一个Thread的子类，重写run方法

2.调用start开启线程

class MyThread1 extends Thread {
   @Override
   public void run() {
       for (int i = 0; i < 100; i++) {
           System.out.println("我是Mythread1线程里面的代码");
       }
   }
}
class MyThread2 extends Thread {
   @Override
   public void run() {
       for (int i = 0; i < 100; i++) {
           System.out.println("我是Mythread2线程里面的代码");
       }
   }
}
public class Demo1 {
   public static void main(String[] args) {
       //main一个线程
       //实例化出来一个线程对象
       MyThread1 myThread1 = new MyThread1();
       //通过调用start方法开启线程一定是start方法
       myThread1.start();
       MyThread2 myThread2 = new MyThread2();
       myThread2.start();
       //4个线程 2个myThread 1main 1jvm 垃圾回收器
       for (int i = 0; i < 100; i++) {
           System.out.println("我是main主函数线程");
       }

   }

}

第二种创建方式【开发中用的】

1.写一个类去实现Runnable接口，实现run方法

2.实例化Thread类，然后构造器的参数是一个实现Runnable接口的对象

class MyThread4 implements Runnable {

   @Override
   public void run() {
       // TODO Auto-generated method stub
       for (int i = 0; i < 100; i++) {
           System.out.println("MyThread" + i);
       } } }
public class Demo2 {
   public static void main(String[] args) {
       //第二种写法
       Thread thread = new Thread(new MyThread4());
       thread.start();//开启线程
       for (int i = 0; i < 100; i++) {
           System.out.println("main:" + i);
       }
   }}

线程的生命周期

线程创建好以后，开启线程start 方法，可运行状态，运行状态，阻塞状态，消亡

创建开启线程： start()

可运行状态：线程在抢占在等待，如果抢到的话就接着往下执行，如果没有抢到就等待

运行状态：真正的执行线程下面run方法

阻塞状态：锁，sleep, wait

消亡状态：线程执行结束以后

4.锁

synchronised Java 的关键字同步锁
咱们线程是不安全的，随机抢占的。能不能让其线程有规律的执行呢？
可以的就是加锁。一个线程抢到资源以后，加上锁以后，这个线程先执行结束，会自动的释放锁
其他线程会进行抢占
用法：
   1.修饰一个代码块
   2.修饰一个方法
   3.修饰一个静态方法
   4.修饰一个类