学习java第六周总结_fileoutputstream是线程安全的吗-优快云博客

本文链接：https://blog.youkuaiyun.com/qihaojinqiuma/article/details/126450373

本文概述了Java中包装类的基础用法、装箱拆箱概念，Math类和Random类的数学运算，以及文件流、输入输出流的处理，深入讲解了线程的创建、调度与同步。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本周学习了实用类中剩余的包装类、输入输出流，以及线程。

包装类

http://t.csdn.cn/rc77Lhttp://t.csdn.cn/rc77L

包装类常用方法

XXXValue():包装类转换成基本类型
toString :以字符串形式返回包装对象表示的基本类型数据(基本类型->字符串)
parseXXX()：把字符串转换为相应的基本数据类型数据（Character除外）（字符串->基本类型
valueOf()
所有包装类都有如下方法（基本类型->包装类）
public static Type valueOf(type value)
除Character类外，其他包装类都有如下方法（字符串->包装类）
public static Type valueOf(String s)

装箱和拆箱

装箱：基本类型转换为包装类的对象
拆箱：包装类对象转换为基本类型的值

        byte num1 = 10;
//		Byte byte1 = new Byte(num1);
		
		//装箱：基本数据类型直接赋值给包装类类型的对象
		Byte byte1 = num1;
		
		//拆箱：包装类型数据直接赋值给基本类型的变量
		Integer int1  = new Integer("13");
		int num2 = int1;
		
		//相互之间可以运算
		Integer int2 = new Integer("255");
		int num3=300;
		int result=int2+num3;
		Integer int3=int2+num3;

包装类的特点

JDK1.5后，允许基本数据类型和包装类型进行混合数学运算
包装类并不是用来取代基本数据类型的
在基本数据类型需要用对象表示时使用

Math类

java.lang.Math类提供了常用的数学运算方法和两个静态常量E（自然对数的底数）和PI（圆周率）

        double pi =Math.PI;
		System.out.println(pi);
		
		System.out.println(Math.max(100, 200));
		System.out.println(Math.min(99, 199));
		System.out.println(Math.abs(-10));
		
		System.out.println(Math.floor(9.4));//返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。
		
		System.out.println(Math.ceil(9.1));//返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。
		
		System.out.println(Math.round(10.1));//四舍五入
		
		//随机数方法:随机返回一个介于0.0（包括）~1.0（不包括）之间的double类型的数据
		double num1=Math.random();
		System.out.println(num1);

Random类

生成随机数的其他方式
java.util.Random类
用同一个种子值来初始化两个Random 对象，然后用每个对象调用相同的方法，得到的随机数也是相同的

 // 创建Random类对象
		Random random = new Random();
		int result  = random.nextInt();
		System.out.println(result);
		System.out.println(random.nextBoolean());
 
		//创建random对象
		Random random2= new Random(10);
		System.out.println(random2.nextInt());
		
		Random random3 = new Random();
		System.out.println(random3.nextInt(10));//随机生成一个[0,10)的数
		
		Random r1= new Random(100);
		Random r2= new Random(100);
		System.out.println(r1.nextInt());
		System.out.println(r2.nextInt());
	}

Stirng类

String类位于java.lang包中，具有丰富的方法计算字符串的长度、比较字符串、连接字符串、提取字符串

String类提供了length()方法，确定字符串的长度

返回字符串中的字符数

String类提供了equals( )方法，比较存储在两个字符串对象的内容是否一致
==”和equals()的区别
==:判断两个字符串在内存中的地址，即判断是否是同一个字符串对象
equals():检查组成字符串内容的字符是否完全一致

字符串比较的其他方法

使用equalsIgnoreCase()方法
使用toLowerCase()方法
使用toUpperCase()方法

字符串连接

方法1：使用“+”
方法2：使用String类的concat()方法

字符串常用提取方法

public int indexOf(int ch)
public int indexOf(String value)
public int lastIndexOf(int ch)
public int lastIndexOf(String value)
public String substring(int index)

提取从位置索引开始的字符串部分

public String substring(int beginindex, int endindex)
提取beginindex和endindex之间的字符串部分

public String trim()

返回一个前后不含任何空格的调用字符串的副本
搜索第一个出现的字符ch（或字符串value），如果没有找到，返回-1
搜索最后一个出现的字符ch（或字符串value），如果没有找到，返回-1

StingBuffer类

对字符串频繁修改（如字符串连接）时，使用StringBuffer类可以大大提高程序执行效率
StringBuffer声明
StringBuffer strb = new StringBuffer();
StringBuffer strb = new StringBuffer("aaa");
StringBuffer的使用
sb.toString(); //转化为String类型
sb.append("**"); //追加字符串
sb.insert (1, "**"); //插入字符串
String类&StringBuffer类
经常改变内容的字符串最好不要使用String
String是不可变对象 StringBuffer是可变的字符串
字符串经常改变的情况可使用StringBuffer，更高效
JDK5.0后提供了StringBuilder，等价StringBuffer

操作日期时间

获取当前日期

java.util.Date类：表示日期和时间

提供操作日期和时间各组成部分的方法 java.text.SimpleDateFormat类

java.util.Calendar
Calendar类是一个抽象类，不能直接实例化，可以通过该类中一个静态方法创建其引用

输入输出流

http://t.csdn.cn/Om7yhhttp://t.csdn.cn/Om7yh

文件

什么是文件
       相关记录或放在一起的数据的集合
   文件一般存储在哪里
       硬盘、光盘、软盘
   Java程序如何访问文件属性
       JAVA API ：java.io.File 类

file类

boolean exists( ) 判断文件或目录是否存在
boolean isFile( ) 判断是否是文件
boolean isDirectory( ) 判断是否是目录
String getPath( ) 返回此对象表示的文件的相对路径名
String getAbsolutePath( ) 返回此对象表示的文件的绝对路径名
String getName( ) 返回此对象表示的文件或目录的名称
boolean delete( ) 删除此对象指定的文件或目录
boolean createNewFile( ) 创建名称的空文件，不创建文件夹
long length() 返回文件的长度，单位为字节, 如果文件不存在，则返回 0L

流

http://t.csdn.cn/2ZFhEhttp://t.csdn.cn/2ZFhE

Java流的分类

InputStream及其子类

InputStream类常用方法

int read( )
int read(byte[] b)
int read(byte[] b,int off,int len)
void close( )
int available()：可以从输入流中读取的字节数目

FileInputStream常用的构造方法

FileInputStream(File file)
FileInputStream(String name)

使用FileInputStream 读文本文件

引入相关の类
import java.io.IOException;
import java.io.FileInputStream;
构造文件输入流
FileInputStream fis= new FileInputStream("c:\\test.txt");
读取文本文件的数据
fis.available();
fis.read();
关闭文件流对象
fis.close();

DataInputStream类

FileInputStream的子类与FileInputStream类结合使用读取二进制文件

使用 DataInputStream 读二进制文件
引入相关的类
import java.io.FileInputStream;
import java.io.DataInputStream;
构造数据输入流对象
FileInputStream fis=new FileInputStream("C:\\HelloWorld.class");
DataInputStream dis=new DataInputStream(fis);
调用read()方法读取二进制数据
dis.read ();
关闭数据输入流
dis.close();

OutpurStream及其子类

OutputStream类常用方法

void write(int c)
void write(byte[] buf)
void write(byte[] b,int off,int len)
void close()
void flush()：强制把缓冲区的数据写到输出流中

FileOutputStream常用的构造方法

FileOutputStream (File file)
FileOutputStream(String name)
FileOutputStream(String name,boolean append)
1.前两种构造方法在向文件写数据时将覆盖文件中原有的内容
2.创建FileOutputStream实例时，如果相应的文件并不存在，则会自动创建一个空的文件

使用FileOutputStream 写文本文件

引入相关の类
import java.io.IOException;
import java.io.FileOutputStream;
构造文件输出流
FileOutputStream fos = new FileOutputStream("text.txt");
读取文本文件的数据
String str ="好好学习Java";
byte[] words = str.getBytes();
fos.write(words, 0, words.length);
关闭文件流对象
fos.close();

DataOutputStream类

FileOutputStream的子类与FileOutputStream类结合使用写二进制文件

使用 DataOutputStream写二进制文件
引入相关的类
import java.io.FileOutputStream;
import java.io.DataOutputStream;
构造数据输入流对象
FileOutputStream outFile=new FileOutputStream("C:\\temp.class");
DataOutputStream out=newDataOutputStream(outFile);
调用write()方法读取二进制数据
out.write();
关闭数据输入流
out.close();

Reader及其子类

Reader类常用方法

int read( )
int read(char[] c)
read(char[] c,int off,int len)
void close( )

子类InputStreamReader常用的构造方法

InputStreamReader(InputStream in)
InputStreamReader(InputStream in,String charsetName)

FileReader类是InputStreamReader的子类

FileReader(File file)
FileReader(String name)
该类只能按照本地平台的字符编码来读取数据，用户不能指定其他的字符编码类型
System.out.println(System.getProperty("file.encoding")); 获得本地平台的字符编码类型

使用FileReader读取文件

引入相关的类
import java.io.Reader;
import java.io.FileReader;
import java.io.IOExceprion;
创建FileReader对象
Reader fr= new FileReader("D:\\myDoc\\简介.txt");
读取文本文件的数据
fr.read();
关闭相关的流对象
fr.close();

BufferedReader类

BufferedReader类是Reader类的子类
BufferedReader类带有缓冲区
按行读取内容的readLine()方法
BufferedReader常用的构造方法
BufferedReader(Reader in)
子类BufferedReader特有的方法
readLine();

Writer及其子类

Writer类常用方法

write(String str)
write(String str,int off,int len)
void close()
void flush()

子类OutputStreamWriter常用的构造方法

OutputStreamWriter(OutputStream out)
OutputStreamWriter(OutputStream out,String charsetName)

FileWriter类是OutputStreamWriter的子类

FileWriter (File file)
FileWriter (String name)
该类只能按照本地平台的字符编码来写数据，用户不能指定其他的字符编码类型

使用FileWriter写文件

引入相关的类
import java.io.Reader;
import java.io.FileWriter;
import java.io.IOException;
创建FileReader对象
Writer fw= new FileWriter("D:\\myDoc\\简介.txt");
写文本文件
fw.write();
关闭相关的流对象
fw.close();

BufferedWriter类

BufferedWriter类是Writer类的子类
BufferedWriter类带有缓冲区
BufferedWriter常用的构造方法
BufferedWriter(Writer out)

使用BufferedWriter写文件

引入相关的类
import java.io.FileWriter ;
import java.io.BufferedWriter ;
import java.io.IOException;
创建BufferedWriter对象和fileWriter对象
FileWriter fw=new FileWriter("C:\\myTest.txt");
BufferedWriter bw=new BufferedWriter(fw);
调用write()方法写数据
bw.write("hello");
流对象的清空和关闭flush()和close()
bw.flush();
fw.close();

线程

http://t.csdn.cn/E8L6Zhttp://t.csdn.cn/E8L6Z http://t.csdn.cn/LwHoghttp://t.csdn.cn/LwHog

进程和线程

进程
       应用程序的执行实例
       有独立的内存空间和系统资源
   线程
       CPU调度和分派的基本单位
       进程中执行运算的最小单位，可完成一个独立的顺序控制流程

多线程

如果在一个进程中同时运行了多个线程，用来完成不同的工作，则称之为“多线程
多个线程交替占用CPU资源，而非真正的并行执行

主线程

    Thread类
       Java提供了java.lang.Thread类支持多线程编程
   主线程
       main()方法即为主线程入口
       产生其他子线程的线程
       必须最后完成执行，因为它执行各种关闭动作

线程的创建和启动

在Java中创建线程的两种方式
继承java.lang.Thread类
实现java.lang.Runnable接口
使用线程的步骤
定义线程
创建线程对象
启动线程
终止线程

继承Thread类创建线程

定义MyThread类继承Thread类
重写run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程
多个线程交替执行，不是真正的“并行”
线程每次执行时长由分配的CPU时间片长度决定

实现Runnable接口创建线程

定义MyRunnable类实现Runnable接口
实现run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程

比较两种创建线程的方式

继承Thread类
编写简单，可直接操作线程
适用于单继承
实现Runnable接口
避免单继承局限性
便于共享资源

线程调度

线程调度指按照特定机制为多个线程分配CPU的使用权
void setPriority(int newPriority) 更改线程的优先级
static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠
void join() 等待该线程终止
static void yield() 暂停当前正在执行的线程对象，并执行其他线程
void interrupt() 中断线程
boolean isAlive() 测试线程是否处于活动状态