Java进阶之路05-(IO流2.多线程)

文中关键字:IO流2 合并流 打印流 序列化 属性集合类 多线程




一次读取一个字节数组的方式要比一次读取一个字节方式高效.
一次读取一个字节数组,相当于构造一个缓冲区,有没有比一次读取一个字节数组还要高效的流
答:有,字节缓冲流(字节缓冲输入流,字节缓冲输出流)
--------------------------------------------------------------------------------
先来看一下计算机是如何存储中文的?
当前平台默认编码集 :GBK 一个中文两个字节
第一个字节:一定是负数
第二个字节:一般是负数,可能也会是正数,不会影响的结果.
例:主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//定义一个字符串
String str = "你好" ;

//转成字节数组
byte[] bys = str.getBytes() ;
System.out.println(Arrays.toString(bys));
//[-60, -29, -70, -61]
}
--------------------------------------------------------------------------------
字节缓冲输入流
* public BufferedInputStream(InputStream in):默认缓冲区大小构造缓冲输入流对象
* public BufferedInputStream(InputStream in,int size):指定缓冲区大小构造缓冲输入流对象
* public int read()从输入流中读取数据的下一个字节
* public int read(byte[] b,int off,int len)从此字节输入流中给定偏移量处开始将各字节读取到指定的 byte 数组中。 
* 会抛出异常:throws IOException
* 
*在使输入流的时候,
* 两种方式读取(一次读取一个字节/一次读取一个字节数在)同一个文件,只能用一种方式,否则,会出现错误!
--------------------------------------------------------------------------------
/*字节缓冲输出流:
* 构造方式:
* (第一种开发中) public BufferedOutputStream(OutputStream out):采用的默认的缓冲区大小(足够大了) ,来构造一个字节缓冲输出流对象
* public BufferedOutputStream(OutputStream out,int size):指定size缓冲区大小构造缓冲输出流对象
* IllegalArgumentException - 如果 size <= 0
* 
* 写数据的方式:
* 一次写一个字节
* write(int by)
* 一次写一个字节数组的一部分
* write(byte[] b, int off, int len) 
* 
* 方法:
* void flush() ;刷新缓冲区的流(输出流中必须要做的一项)
*
* 面试题:
* 字节缓冲输出流它的构造方法为什么不能直接传递路径/文件?
* 缓冲输入流/缓冲输出流,它只是在底层内部提供一个缓冲区的数组,

* 底层实现文件的复制/读取/写入这些操作都依赖于基本流对象来操作

         *  (InputStream/OutputStream/FileInputStream/FileOutputstream)

*/
--------------------------------------------------------------------------------
存储文件
* IO流:永久存储(耗时)
* 数据库:永久存储
* 
* 基本的字节流
* 文件字节输入流/文件字节输出流
* 高效的字节流(缓冲流)
* 
* 操作一个视频文件,来测试速度问题
* 基本的字节流一次读取一个字节 ://耗时:85772毫秒
* 基本的字节流一次读取一个字节数组 :共耗时:216毫秒
* 
* 高效的字节流一次读取一个字节      :共耗时:682毫秒
* 高效的字节流一次读取一个字节数组:共耗时:49毫秒
* 
*StringBuffer:提供了一个字符串缓冲区 (可以在缓冲区中不断追加字符串)
*/
例题测试:
导包:
import java.io.BufferedInputStream;
主函数代码如下:(将代码复制到你所创建的类中就可运行)  
public static void main(String[] args) throws Exception {
long start = System.currentTimeMillis() ;

// method1("e:\\abc.mp4","copy1.mp4") ;
// method2("e:\\abc.mp4","copy2.mp4") ;
// method3("e:\\abc.mp4","copy3.mp4") ;
method4("e:\\abc.mp4","copy4.mp4") ;

long end = System.currentTimeMillis() ;

System.out.println("共耗时:"+(end-start)+"毫秒");
}

//高效的流一次读取一个字节数组
private static void method4(String src, String dest) throws Exception {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src))  ;
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest)) ;

//一次读取一个字节数组
byte[] bys = new byte[1024] ; 
int len = 0 ;
while((len=bis.read(bys))!=-1) {
bos.write(bys, 0, len);
}

bis.close();
bos.close();
}


//高效的字节流一次读取一个字节
private static void method3(String src, String dest) throws Exception {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src))  ;
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest)) ;

//一次读个字节
int by = 0 ;
while((by=bis.read())!=-1) {
bos.write(by);
}
//释放资源
bis.close();
bos.close();
}


//基本的字节流一次读取一个字节数组
private static void method2(String src, String dest) throws Exception {
//封装文件
FileInputStream fis = new FileInputStream(src) ;
FileOutputStream fos = new FileOutputStream(dest) ;

//读写操作
byte[] bys = new byte[1024] ;//相当于一个缓冲区
int len = 0 ;
while((len=fis.read(bys))!=-1) {
fos.write(bys, 0, len);
}

//释放资源
fis.close();
fos.close();

}


//基本的字节流一次读取一个字节
private static void method1(String src, String dest) throws Exception {
//封装源文件和目标文件
FileInputStream fis = new FileInputStream(src) ;
FileOutputStream fos = new FileOutputStream(dest) ;

//读写操作
int by = 0 ;
while((by=fis.read())!=-1) {
//写
fos.write(by);
}

//释放资源
fis.close();
fos.close();

}
--------------------------------------------------------------------------------
使用字节流一次读取一个字节的方式,会造成中文乱码--->Java提供了一个字符流(专门用来解决中文乱码问题)
导包:
import java.io.FileInputStream;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {

//封装文件
//一次读取一个字节的方式
FileInputStream fis = new FileInputStream("a.txt") ;

//读数据
int by = 0 ;
while((by=fis.read())!=-1) {

System.out.print((char)by);

                        //因为默认使用的是gbk编码格式,一个中文对应了两个字节,而对每一个字节进行解析时会出现错误

}

//释放资源
fis.close();

}
--------------------------------------------------------------------------------
/**
* 字符流:
* 字符输入流:Reader
* 字符输出流:Writer
* 字符输出流/字符输入流:都是抽象类
* 使用一个子类:转换流
* 
* 字符输出流的构造方法
* public OutputStreamWriter(OutputStream out):使用默认的编码格式构造一个字符转换输出流对象
* public OutputStreamWriter(OutputStream out, Charset cs):使用指定编码格式构造一个字符转换输出流对象
* 
* 转换流的构成=字节流+编码格式(平台默认/指定)
* 
* 
* 转换流的对象的创建,格式比较长,非常麻烦,Java--->转换流的便捷类
* Reader:抽象类:字符输入流
* inputStreamReader(字符转换输入流 :inputStream+编码格式)
* 便捷类:FileReader,这个类可以直接对文件进行操作
* 
* Writer:抽象类:字符输出流
* outputStreamWriter(字符转换输出流:outputStream+编码格式)
* 便捷类:FileWriter,这个类可以直接对文件进行操作
* 
* 需求:将a.txt文件中的内容进行复制,复制到当前项目下(b.txt)
*/
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;

public static void main(String[] args) throws Exception {

//创建一个字符输出流对象
// Writer writer = new OutputStreamWriter(new FileOutputStream("w.txt")) ;//多态
OutputStreamWriter osw = 
new OutputStreamWriter(
new FileOutputStream("osw.txt"), "gbk"
);

//写数据
osw.write("中国");

//释放资源
osw.close();
}
--------------------------------------------------------------------------------
/**
* 需求:将a.txt文件中的内容进行复制,复制到当前项目下(b.txt)
* 
* 文本文件:优先采用字符流
* 
* 源文件:a.txt---->Reader---->InputStreamReader---->FileReader
* 目的的文件:b.txt--->Writer-->OutputStreamWriter---->FileWriter
*/
 导包:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {

//方式1:转换流的方式
//封装源文件和目的地文件
/*InputStreamReader isr = new InputStreamReader(
new FileInputStream("a.txt")) ;
OutputStreamWriter osw = new OutputStreamWriter(
new FileOutputStream("b.txt")) ;

//复制操作
//一次读取一个字符数组
char[] chs = new char[1024] ;
int len = 0 ;
while((len=isr.read(chs))!=-1) {
//写
osw.write(chs, 0, len);
}
//释放资源
osw.close();
isr.close();

System.out.println("-----------------------");*/

//方式2:使用便捷类进行操作
FileReader fr = new FileReader("a.txt") ;
FileWriter fw = new FileWriter("b.txt") ;

//一次读取一个字符数组
//一次读取一个字符数组
char[] chs2 = new char[1024] ;
int len2 = 0 ;
while((len2=fr.read(chs2))!=-1) {
//写
fw.write(chs2, 0, len2);
}

fr.close();
fw.close();
}
--------------------------------------------------------------------------------
/**
* 编码和解码:前后的编码格式要一致!
* 编码:
* 简单理解:将能看懂的东西--->看不懂的东西
* 解码:
* 看不懂的东西---能看懂的东西
* 
* 举例: 谍战片
*
* 今天老地方见...
* 编码:
* 今---->字节---->二进制数据
* 
* 解码:二进制数据-->十进制数据--->字节---->字符串
* 今
* 
* 编码: 将字符串变成一个字节数组
* public byte[] getBytes() :平台默认编码集(默认的是Gbk)
*   public byte[] getBytes(Charset charset) ;"指定编码格式
* 
* 解码:将字节数组--->字符串
* public String(byte[] bytes) :使用平台默认编码集(gbk)
* public String(byte[] bytes,Charset charset):用指定的编码格式来解码
*/
导包:
import java.util.Arrays;
主函数代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {

//定义一个字符串
String str ="你好" ;

//编码和解码:前后必须一致

//编码
// byte[] bys = str.getBytes() ;
byte[] bys = str.getBytes("utf-8") ;//-28, -67, -96, -27, -91, -67]
System.out.println(Arrays.toString(bys));//[-60, -29, -70, -61]
System.out.println("------------------");

//解码
// public String(byte[] bytes) :使用平台默认编码集(gbk)
// String s = new String(bys) ;
// String s = new String(bys,"gbk") ;//一个中文对应三个字节
String s = new String(bys,"utf-8") ;//一个中文对应三个字节
System.out.println(s);
}
--------------------------------------------------------------------------------
字符转换输入流:InputStreamReader
InputStreamReader(InputStream in) :构造一个字符转换输入流,默认编码
public InputStreamReader(InputStream in,Charset cs) 构造一个字符转换输入流,指定编码
字符转换输入流=字节流+编码格式
 
InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"),"gbk") ;
创建一个字符转换输入流isr,使用匿名内部类的方式将osw.txt文件转换为抽象类
--------------------------------------------------------------------------------
/**
*字符输入流读数据的方法:
* int read(char[] chs):读取一个字符数组
* int read():读取单个字符 
*/
导包:
import java.io.FileReader;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {
//读取当前项目下的StringDemo.java文件
FileReader fr = new FileReader("StringDemo.java") ;

//一次读取一个字符
// int ch = 0 ;
// while((ch=fr.read())!=-1) {
// System.out.print((char)ch);
// }

//一次读取一个字符数组
char[] chs = new char[1024] ;
int len = 0 ;
while((len=fr.read(chs))!=-1) {
System.out.println(new String(chs,0,len));
}

//释放资源
fr.close();
}
--------------------------------------------------------------------------------
/**
*字符输出流写数据的功能:
* public void write(int c):写单个字符 
* public void write(char[] cbuf):写字符数组
* public abstract void write(char[] cbuf, int off,  int len):写字符数组的一部分
* public void write(String str):写字符串
* public void write(String str,int off, int len):写字符串的某一部分
*
*flush和close方法的区别?
* close:关闭该流,关闭该流对象以及它关联 的资源文件,关闭之后,不能再对流对象进行操作了,否则会有异常

* flush:刷新该流,为了防止一些文件(图片文件/音频文件),缺失,或者没有加载到流对象中,刷新了该流,还是可以对该流对

         *      象进行操作

*
*字符缓冲输入流/字符缓冲输出流
*
*杂七杂八的流(properties:属性集合类/合并流/序列化Serializable/内存操作流)
*/
导包:
import java.io.FileWriter;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {

//创建字符输出流对象
FileWriter fw = new FileWriter("fw.txt") ;
fw.write("我爱高圆圆", 0, 3);


fw.flush();
//字符流中的close:关闭该流的同时,之前一定要刷新流
fw.close();
  }
--------------------------------------------------------------------------------
/**
* 
*先使用字符缓冲输出流写数据,在使用字符缓冲输入读数据,显示控制台上
*
*字符缓冲输出流:
* 特有功能:public void newLine():写入一个行的分隔符号
*
*字符缓冲输入流:
* 特有功能:public String readLine():一次读取一行
*/
导包:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {

// write();

//读数据
BufferedReader br = new BufferedReader(new FileReader("bw2.txt")) ;

//一次读取一个字符/一次读取一个字符数组(最基本的两种方式)
//第一次读取
/*String line = br.readLine() ;
System.out.println(line);
line = br.readLine() ;
System.out.println(line);
line = br.readLine() ;
System.out.println(line);
line = br.readLine() ;
System.out.println(line);*/

//代码在重复 ,改进
String line = null ;
while((line=br.readLine())!=null) {
System.out.println(line);
}

//释放资源
br.close();
}


private static void write() throws IOException {
//字符缓冲输出流读数据
BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt")) ;

//写数据
for(int x = 0 ; x <10 ; x ++) {
//写数据
bw.write("hello"+x);
//之前的换行
// bw.write("\r\n"); //写入换行符号

bw.newLine();
//刷新
bw.flush(); 
}
//关闭流
bw.close();
}
--------------------------------------------------------------------------------
/**
*BufferedReader:字符缓冲输入流
*
* 构造方法
* public BufferedReader(Reader in)创建一个使用默认大小输入缓冲区的缓冲字符输入流。 
* public BufferedReader(Reader in, int sz)创建一个使用指定大小输入缓冲区的缓冲字符输入流。
* 
*需求:读取当前项目下的bw.txt这个文件
*
*/
导包:
import java.io.BufferedReader;
import java.io.FileReader;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {

//创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("bw.txt"));

//读数据
//一次读取一个字符数组
char[] chs = new char[1024] ;
int len = 0 ;
while((len=br.read(chs))!=-1) {
System.out.println(new String(chs,0,len));
}
//释放资源
br.close();
}
--------------------------------------------------------------------------------
/**
*
* 在字符流中提供了一个更高效的流-->字符缓冲流
* 字符缓冲输入流
* 字符缓冲输出流
* 
* BufferedWrier:文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入
* 构造方法
* BufferedWriter(Writer out) :默认缓冲区大小构造字符缓冲输出流对象
* BufferedWriter(Writer out,int size):指定缓冲区大小
*
*/
导包:
import java.io.BufferedWriter;
import java.io.FileWriter;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {

//创建一个字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt")) ;


//写数据
bw.write("hello");
bw.write("world");

//刷新流
bw.flush(); 

//关闭资源
bw.close();

}
--------------------------------------------------------------------------------
/**
*使用字符缓冲流进行复制操作
*
*分别使用两种方式
* 1)一次读取一个字符数组
* 2)一次读取一行 
*
*/
导包:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {
//源文件:StringDemo.java
//目的地文件:当前项目下copy.java

//封装文件
BufferedReader br = new BufferedReader(new FileReader("StringDemo.java")) ;
//封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter("copy.java")) ;

//一次读取一个字符数组
/* char[] chs = new char[1024] ;
int len = 0 ;
while((len=br.read(chs))!=-1) {
bw.write(chs, 0, len);
bw.flush(); 
}*/

//一次读取一行
String line = null ;
while((line=br.readLine())!=null) {
//写
bw.write(line);
bw.newLine();
bw.flush();
}


//关闭资源
bw.close();
br.close();
}
--------------------------------------------------------------------------------
/**
* 2. 需求：把ArrayList集合中的字符串数据存储到文本文件
* 
*   ArrayList集合存储的元素String,可以存储一些字符串
* 使用增强for遍历ArrayList
* 使用BufferedWriter(文本文件)
* 源文件:ArrayList<String>
* 目的地:BufferedWriter输出文本文件,给文件中写入字符
*/
导包:
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.util.ArrayList;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {

//创建一个ArrayList集合
ArrayList<String>  list  = new ArrayList<String>() ;
//添加元素
list.add("hello") ;
list.add("world") ;
list.add("java") ;
list.add("hello") ;

//创建一个字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt")) ;

//遍历
for(String s:list) {
//将集合中元素写入到流中
bw.write(s);
bw.newLine();
bw.flush();
}

//关闭资源
bw.close();
}
--------------------------------------------------------------------------------
/**
* 复制文本文件(5种方式分别完成)
* 
* 文本文件:字符流
* 
* 基本的字符流:一次读取一个字符
*  一次读取一个字符数组
* 字符缓冲流: 一次读取一个字符
* 一次读取一个字符数组
* 一次读取一行
*/
导包:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {

// method1("StringDemo.java","copy.java") ;


method2();
}


private static void method2() throws FileNotFoundException, IOException {
BufferedReader br = new BufferedReader(new FileReader("StringDemo.java")) ;
BufferedWriter bw = new BufferedWriter(new FileWriter("copy.java")) ;

//一次读取一行
String line = null;
while((line=br.readLine())!=null) {
bw.write(line);
bw.newLine();
bw.flush();
}
br.close();
bw.close();
}


private static void method1(String src, String dest) throws Exception {
BufferedReader br = new BufferedReader(new FileReader(src)) ;
BufferedWriter bw = new BufferedWriter(new FileWriter(dest)) ;

//字符数组
char[] chs = new char[1024] ;
int len = 0 ;
while((len=br.read(chs))!=-1) {
bw.write(chs, 0, len);
bw.newLine();
bw.flush();
}
br.close();
bw.close();
}
--------------------------------------------------------------------------------
/**
 *需求:有一个文本文本,需要将文本文件中的内容放到ArrayList集合中,遍历集合获取元素 
 *
 *源文件:b.txt----->读取---->BuffferedReader
 *目的地:ArrayList<String>
 *
 */
导包:
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.ArrayList;
主方法代码如下:(将代码复制到你所创建的类中就可运行)

public static void main(String[] args) throws Exception {

//封装源文件
BufferedReader br = new BufferedReader(new FileReader("b.txt")) ;

//创建一个ArrayList集合
ArrayList<String> list = new ArrayList<String>() ;

//读b.txt文件的内容
String line = null ;
while((line=br.readLine())!=null) {
//将数据添加到集合中
list.add(line) ;
}

//遍历集合
for(String s:list) {
System.out.println(s);
}

//关闭流
br.close();
}
--------------------------------------------------------------------------------
/**
*需求：我有一个文本文件中存储了几个名称，请大家写一个程序实现随机获取一个人的名字。 
*
*
* 1)封装一个文本文件:使用字符缓冲输入流读文件
* 2)创建一个ArrayList<String>
* 3)使用字符缓冲输入流readLine(),一次读取一行,就将该行数据添加到集合中
* 4)创建Random类对象
* 5)Random类对象.nextInt(集合对象.size()) ;
* 6)通过角标get(int index ):获取内容
*/
导包:
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.Random;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {

//封装文件
BufferedReader br = new BufferedReader(new FileReader("b.txt")) ;
//创建一个集合
ArrayList<String> array = new ArrayList<String>() ;

//一次读取一行
String line = null ;
while((line=br.readLine())!=null) {
//将数据添加到集合
array.add(line) ;
}

//释放资源
br.close(); 
//创建Random类对象
Random r = new Random();

//获取随机数
int index = r.nextInt(array.size()) ;
//通过角标查找集合中元素
String name = array.get(index) ;
System.out.println("幸运的人是:"+name);
}
--------------------------------------------------------------------------------
/**
*内存操作流:适用于临时存储文件.
* 内存操作输入流:byteArrayInputStream
* ByteArrayInputStream(byte[] buf) 
*
* 内存操作输出流: byteArrayOutputStream
* 构造方法:ByteArrayOutputStream() 
*内存操作流:一个程序结束后,那么这些程序的变量,就会从内存消失(马上消失的这些数据进行读取写入)
*/
导包:
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws IOException {

//创建内存操作输出流对象
ByteArrayOutputStream baos = new ByteArrayOutputStream() ;
for(int x = 0 ; x <10 ; x ++) {
baos.write(("hello"+x).getBytes());

}
//释放资源
/**
* 源码:
*  public void close() throws IOException {
    }
*/
// baos.close(); 该流不需要关闭

//从内存中将内从中的数据显到控制台上
//public byte[] toByteArray():构造一个字符串
byte[] bys = baos.toByteArray() ;

//创建内存操作输入流对象
ByteArrayInputStream bais = new ByteArrayInputStream(bys) ;

//一次读取一个字节
int by = 0 ;
while((by=bais.read())!=-1) {
System.out.print((char)by);
}
}
--------------------------------------------------------------------------------
/**
*源文件:StringDemo.java --->BufferedReader
*目的文件:Copy.java   ----->PrintWriter
*
*/
导包:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws IOException {

//封装文件
BufferedReader br = new BufferedReader(new FileReader("StringDemo.java")) ;
PrintWriter pw = new PrintWriter(new FileWriter("Copy.java",true)) ;

//一次读取一行
String line = null ;
while((line=br.readLine())!=null) {
//向打印输出内容
pw.println(line);

}

//释放资源
pw.close();
br.close();
}
--------------------------------------------------------------------------------
/**
* 数据流:针对Java基本类型的数据进行读写操作
*数据输入流:DataInputStream
*数据输出流:DataOutputStream 
*/
导包:
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws Exception {

// write() ;
read() ;
}



//读
private static void read() throws Exception {
DataInputStream dis = new DataInputStream(new FileInputStream("dos.txt")) ;

//读
int i = dis.readInt() ;
short s = dis.readShort() ;
byte b = dis.readByte() ;
double d = dis.readDouble() ;
float f = dis.readFloat();
boolean flag = dis.readBoolean() ;
char ch = dis.readChar() ;

dis.close();

System.out.println(i);
System.out.println(s);
System.out.println(b);
System.out.println(d);
System.out.println(f);
System.out.println(flag);
System.out.println(ch);


}
//写
private static void write() throws Exception {

DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt")) ;

//给流中写入数据
dos.writeInt(10); 
dos.writeShort(100);
dos.writeByte(120);
dos.writeDouble(13.34);
dos.writeFloat(12.56F);
dos.writeBoolean(true);
dos.writeChar('a');

//关闭资源
dos.close();
}
--------------------------------------------------------------------------------
/**
*打印流
* 字符打印流(针对文本进行操作:PrintWriter)
* 字节打印流(printStream 和标准输出流有关系 System.out;)  
*
*PrintWriter:属于输出流
* 1)只能写数据(只能针对目的地文件进行操作),不能读数据(不能针对源文件进行操作)
* 2)可以针对文件直接进行操作
* 如果一个类中的构造方法里面有File对象或者String类型数据,这个类可以对文本文件直接操作
* FileInputStream
* FileOutputStream
* FileWriter
* FileReader..
* PrintWriter
* 3)自动刷新功能::PrintWriter(OutputStream out/Writer out,boolean autoflush);第二个参数如果是true 表示启动自动刷新功能
* 4)打印的方法:print(XXX x)/println(XXX  xx)
*/
导包:
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws IOException {

//创建一个字符打印流对象
PrintWriter pw = new PrintWriter(new FileWriter("pw.txt")) ;

//写数据
/*pw.write("hello");
pw.write("world");
pw.write("java");*/

pw.println("hello");//本身自动换行并且向pw.txt文件打印内容

pw.flush(); //本身在构造的时候,就可以启动自动刷新

//关闭流
pw.close();
}
--------------------------------------------------------------------------------
/**
* 输出一个文本文件,启动自动刷新功能
*/
导包:
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws IOException {

//创建一个字符打印流对象,启动自动刷新
PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true) ;

//加入换行
pw.println("hello"); 
pw.println("world"); 
pw.println("java");

//关闭
pw.close();
}
--------------------------------------------------------------------------------
/**
* SequenceInputStream 表示其他输入流的逻辑串联(合并流)
* 
*构造方法
* public SequenceInputStream(InputStream s1, InputStream s2)
* 复制文件
* a.txt----->b.txt
* c.txt----->d.txt
* 
* 现在的需求:
* a.txt+b.txt--->c.txt
* StringDemo.java+SystemInDemo.java---->Copy.java
*/
导包:
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws IOException {

//封装源文件
InputStream in1 = new FileInputStream("StringDemo.java") ;
InputStream in2 = new FileInputStream("SystemInDemo.java") ;

//创建合并流对象
SequenceInputStream sis = new SequenceInputStream(in1, in2) ;
//创建一个字节缓冲输入流对象
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("Copy.java"));

//原来怎么读写,现在依然这样读写
byte[] bys = new byte[1024] ;
int len = 0 ;
while((len=sis.read(bys))!=-1) {
bos.write(bys, 0, len);
bos.flush(); //读图片文件的时候
}

//关闭资源
sis.close();
bos.close();

}
--------------------------------------------------------------------------------
/**
*sequenceInputStream另一种构造方式
*public SequenceInputStream(Enumeration e) 
*
* 将多个输入流对象进行合并
* a.txt+b.txt+c.txt--->d.txt
*/
导包:
import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws IOException {
//StringDemo.java+SystemInDemo.java+PrintWriterDemo.java--->Copy.java文件中

//定义一个集合Vector
Vector<InputStream> v  = new Vector<InputStream>() ;
//使用InputStream封装文件
InputStream s1 = new FileInputStream("StringDemo.java") ;
InputStream s2 = new FileInputStream("SystemInDemo.java") ;
InputStream s3 = new FileInputStream("PrintWriterDemo.java") ;

//将流对象添加到集合中
v.add(s1) ;
v.add(s2) ;
v.add(s3) ;

//特有功能
Enumeration<InputStream> en = v.elements() ;

//创建合并输入流对象
SequenceInputStream sis = new SequenceInputStream(en) ;
//创建字节缓冲输出流对象
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("Copy.java")) ;

//一次读取一个字节数组
byte[] bys = new byte[1024] ;
int len = 0 ;
while((len=sis.read(bys))!=-1) {
bos.write(bys, 0, len);
bos.flush();
}

//关闭资源
bos.close();
sis.close();
}
--------------------------------------------------------------------------------
/**
*标准的输入输出流
* InputStream in = System.in 
* PrintStream out = Syste.out ;
*
*jdk5以后,Java--->Scanner(InputStream in)
*
* 键盘录入
* 1)Scanner
* 2)BufferedReader里面包装字符转换输入流,包装System.in
*/
导包:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws IOException {

//标准输入流
//分布走
//创建输入流对象
/*InputStream in = System.in ;

//使用这个类最终可不可实现一次读取一行?readLine()
//想要实现一次读取一行,使用BufferedReader
//构造BufferedReader流对象
// BufferedReader br = new BufferedReader(in) ;  //不能直接将字节流使用BufferedReader进行包装
//构造一个字符转换输入流对象
InputStreamReader isr = new InputStreamReader(in) ;
BufferedReader br = new BufferedReader(isr) ;*/

//另一种键盘录入的方式:使用流的方式
//Java的装饰者模式
BufferedReader br = new BufferedReader(
new InputStreamReader(
System.in)) ;

System.out.println("请输入一个字符串:");
String line = br.readLine() ;
System.out.println("您输入的字符串是:"+line);

System.out.println("请输入一个整数:");
String str = br.readLine() ;

int num = Integer.parseInt(str) ;
System.out.println("输入的整数是:"+num);
}
--------------------------------------------------------------------------------
/**
*标准输出流
* PrintStream ps = System.out ; 
*
*
*使用BufferedWriter 去包装System.out
*/
导包:
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws IOException {
System.out.println("我爱高圆圆");

System.out.println("-------------");
PrintStream ps = System.out ;
//PrintStream的功能
//public void println(String x)
ps.println("我爱高圆圆");

ps.println();
// ps.print() ;没有该功能
System.out.println("---------------------------");

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out)) ;

bw.write("hello");
bw.newLine();
bw.write("world");
bw.newLine();
bw.write("java");
bw.newLine();
bw.flush();

bw.close();
}
********************************************************************************
/**
*序列化:将对象按照流的方式存储到文本文件中或者再网络中传输    对象---->流数据 序列化流 (ObjectOutputStream)
*反序列化:将文本文件中的流对象或者网络传输中的流对象还原成对象   流数据--->对象  反序列化流(ObjectInputStream)
*
*
*现在就自定义类:Person类
*/
导包:
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {

// write() ;
read();
}

//反序列化
private static void read() throws FileNotFoundException, IOException, ClassNotFoundException {

//创建反序列化流对象
//public ObjectInputStream(InputStream in)
ObjectInputStream in = new ObjectInputStream(new FileInputStream("oos.txt")) ;

//读
//public final Object readObject():从 ObjectInputStream 读取对象。
Object obj = in.readObject() ;

in.close();
System.out.println(obj);//Person [name=高圆圆, age=27]
}



//序列化
private static void write() throws FileNotFoundException, IOException {

//创建一个序列化流对象
//public ObjectOutputStream(OutputStream out)
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt")) ;

//创建一个Person类对象
Person p = new Person("高圆圆", 27) ;

//public final void writeObject(Object obj)
oos.writeObject(p);

//关闭资源
oos.close();

}
Person类:
/**
*  java.io.NotSerializableException :当前类未实现序列化功能的异常
*  
*  Serializable:接口 没有构造方法,没有字段,也没有方法
*  接口---->标记接口
*  
*  自定义类要实现序列化功能,必须实现接口Serializable接口
*  
*  类实现了serializable也意味着他是标记类
*  
*   假设之前操作针对Peroson操作序列的时候,产生一个标记  Preson.class--->固定ID 100
*  
*   name -100
*   age -100
*  
*   已经序列化完毕了,然后有修改了Person类里面的一些东西,加入了toString()
*   Person.class---固定id -- 200
*  
*  
*  org.westos_01.Person; local class incompatible: 
*   stream classdesc serialVersionUID = -428218385429329797, 
*   local class serialVersionUID = -5865763454468005049
*  
*  
*  因为手动修改了这些类的属性/成员变量,将序列化版本Id改变了
*  InvalidClassException:一般情况:该类的序列版本号与从流中读取的类描述符的版本号不匹配 
*  实际开发中,不想多次对当前这些序列化,如果这样做,非常麻烦?
*  如何解决呢?
*   让当前实现类序列化功能的这个类产生一个固定ID,注意看程序有黄色警告线,直接就点它固定Id
*  
*  比如:当前的这个类中有很多属性(性别,地址,学号...),某些属性不想被序列化,如何解决这样一个问题
*/
导包:
import java.io.Serializable;
public class Person implements Serializable{

//产生随机的固定Id
private static final long serialVersionUID = 3929786557947102117L;


private String name ;
// private int age ;
// public int age ;

transient int age  ;//这样这个类的属性就不会被序列化

public Person() {
super();
}

public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}


public String getName() {
return name;
}


public void setName(String name) {
this.name = name;
}


public int getAge() {
return age;
}


public void setAge(int age) {
this.age = age;
}


@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
--------------------------------------------------------------------------------
/**
* Properties:表示了一个持久的属性集(简称:属性集合类)  extends Hashtable<K,V> Map集合的
* 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。
* public Properties():无参构造
*
*/
导包:
import java.util.Properties;
import java.util.Set;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//它继承Hashtable
//创建一个属性集合类对象
// Properties<String,String> prop = new Properties<String,String>() ;
Properties prop = new Properties() ;
System.out.println(prop);
System.out.println("---------------------");

//给属性集合类中的属性列表添加元素
prop.put("高圆圆", "赵又廷") ;
prop.put("文章", "马伊琍") ;
prop.put("黄晓明", "baby") ;

System.out.println(prop);

//遍历属性集合类
Set<Object> keySet = prop.keySet() ;
for(Object key :keySet) {
Object value = prop.get(key) ;
System.out.println(key+"="+value);
}
}
--------------------------------------------------------------------------------
/**
*属性集合类的特有功能:
* public Object setProperty(String key, String value) :给属性列表中添加键和值,并且强制都使用String
* public Set<String> stringPropertyNames():遍历的功能
* public String getProperty(String key)用指定的键在此属性列表中搜索属性
*
*/
导包:
import java.util.Properties;
import java.util.Set;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//创建属性集合类对象
Properties prop = new Properties() ;

//添加元素
prop.setProperty("张三", "20") ;
prop.setProperty("李四", "22") ;
prop.setProperty("王五", "18") ;

//遍历
//获取所有的键的集合
Set<String> keyset = prop.stringPropertyNames() ;
for(String key:keyset) {
//通过键找值
String value = prop.getProperty(key) ;
System.out.println(key+"----"+value);
}
}
--------------------------------------------------------------------------------
/**
*可保存在流中或从流中加载,只能使用属性集合类
*public void store(Writer writer,String comments):把集合中的数据保存文本文件中(属性集合)
*public void load(Reader reader):将文本文件中的数据加载到属性集合中
*举例:
* 打游戏:游戏进度的保存和游戏加载
*/
导包:
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws IOException {

// MyStore();
MyLoad();
}

//将文本文件中的数据加载属性集合类中
private static void MyLoad() throws IOException {

//创建属性集合类对象
Properties prop =new Properties() ;

//public void load(Reader reader):将文本文件中的数据加载到属性集合中
FileReader fr = new FileReader("prop.txt") ;
//加载
prop.load(fr);
fr.close();
System.out.println(prop);

}

//将属性集合中的数据保存到文本文件中
private static void MyStore() throws IOException {

//创建一个属性集合类对象
Properties prop = new Properties() ;

//添加元素
prop.setProperty("张三", "20") ;
prop.setProperty("文章", "29") ;
prop.setProperty("成龙", "55") ;

//public void store(Writer writer,String comments):把集合中的数据保存文本文件中(属性集合)
FileWriter fw = new FileWriter("name.txt") ;
//将数据保存到文本文件中
prop.store(fw, "names'content");

//释放资源
fw.close();
 
}
--------------------------------------------------------------------------------
/**
* 我有一个文本文件(user.txt)，我知道数据是键值对形式的，但是不知道内容是什么。
 请写一个程序判断是否有“lisi”这样的键存在，如果有就改变其实为”100
 
 1)读取文件的内容,将文件内容加载属性集合类中
 2)遍历属性集合,获取所有的键的集合
 3)遍历的键的时候,可以判断是否有"lisi"这样一个键
 4)有的话,就更改
 5)需要将当前属性集合类中的保存文本文件中
*/
导包:
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws IOException {

//创建属性集合类对象
Properties prop = new Properties() ;

//读取文本文件内容加载到集合中
FileReader fr = new FileReader("user.txt") ;
prop.load(fr); 
fr.close(); 

//遍历属性集合
//获取所有的键的集合
Set<String> keySet = prop.stringPropertyNames() ;
for(String key:keySet) {
//判断
if("lisi".equals(key)) {
//更改
prop.setProperty(key, "100") ;
}
}

//将属性集合中的数据保存文本文件中
FileWriter fw = new FileWriter("user.txt") ;
prop.store(fw, "content");
fw.close();


}
--------------------------------------------------------------------------------
/**
* 需求:
* 我有一个猜数字小游戏的程序，请写一个程序实现在测试类中只能用5次，
* 超过5次提示：游戏试玩已结束，请付费。
*/
导包:
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) throws IOException {

//创建文件
/*File file = new File("content.txt") ;
if(file!=null) {
file.createNewFile() ;
}*/

//将文件的内容加载到属性集合中
Properties prop = new Properties() ;
//创建字符输入流
FileReader fr = new FileReader("count.txt") ;
prop.load(fr);
fr.close();

//现在有内容了,通过键获取当前对应的值(String)
String value = prop.getProperty("count") ;

//String---int
int number = Integer.parseInt(value) ;
//判断
//超过5次提示：游戏试玩已结束，请付费。
if(number >5) {
System.out.println("游戏试玩接收,请您付费...");
System.exit(0);
}else {
number ++ ;
prop.setProperty("count", String.valueOf(number)) ;
FileWriter fw = new FileWriter("count.txt") ;
prop.store(fw, "game'content");
fw.close() ;

GetNumber.start();

}
}
GetNember类:
导包:
import java.util.Scanner;


public class GetNumber {

private GetNumber() {

}

//为了防止打断点的时候,黄色警告线会影响断点,所有加入强制解决
@SuppressWarnings("resource")
public static void start() {
//1-100随机数
int number = (int) (Math.random()*100+1) ;

//定义一个统计变量
int count = 0 ;

while(true) {


Scanner sc = new Scanner(System.in) ;
System.out.println("请输入要猜的数据:");
int guessNumber = sc.nextInt() ;

count ++ ;
if(guessNumber>number) {
System.out.println("你要猜的数据大了...");
}else if(guessNumber <number) {
System.out.println("你要猜的数据小了...");
}else {
System.out.println("恭喜您"+count+"次猜中了...");
break ;
}

}
}
}
********************************************************************************
我们学习多线程,首先先学习什么是进程,线程依赖于进程存在

进程:系统可以进行独立调配并且是一个不可分割 独立单元
开启一个任务管理器,很多进程(应用软件/某些客户端)

什么是多进程?
多进程的意义:是为了提高CPU的使用率
现在计算机都是多进程,假设:在听音乐的同时,也在打游戏..,他们是同时进行的吗?
他们不是同时进行的,感觉同时,一点点CPU的时间片在同一个时刻在两个进程之间进行高效的切换!

什么线程?
线程:进程的一个独立的单元
一个进程里面有多个任务,把每一个任务看成一个线程
多线程:
线程之间在抢占CPU的执行权(抢占资源)
多线程的执行具有随机性

举例"
打篮球:1v1 两个人抢占篮球的几率同样大
 1v5   5个人抢占篮球的几率大,并不能说一定抢到 (随机性的)
 
/**
*
* JVM:Java虚拟机 识别main(主线程)
* 面试题:
* JVM是多线程程序吗?至少有几条线程..
* jvm是多线程的,
* 至少有2条线程...
* 有主线程,main..执行这些代码,能够被Jvm识别
* 在执行一些程序的时候,一些对象Jvm释放掉,原因,
* 它开启了垃圾回收线程,里面GC:垃圾回收器(回收一些没有更多引用的对象或者变量...)
*/
--------------------------------------------------------------------------------
/**
*如何实现多线程程序呢?
*要实现多线程程序,需要开启进程,
*开启进程,是需要创建系统资源,但是Java语言不能创建系统资源
*只有C/C++可以创建系统资源, 利用c语言创建好的系统资源实现
*Java提供了一个类:Thread类
* 实现多线程程序的步骤:
* 1)将类声明为 Thread 的子类
* 2)该子类应重写 Thread 类的 run 方法
* 3)在主线程进行该自定义的线程类的对象的创建
*
*
*
*并行和并发(高并发:MyBatis --->IBatis:半自动化)
*强者逻辑上的同时,指的是同一个时间段内
*后者物理上的同时,指的是同一个时间点
*
*/


主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//创建MyThread类对象
// MyThread my = new MyThread() ;

//当前Thread类有一个run public void run() 
// my.run(); 
// System.out.println("-------------------");
// my.run();
//执行线程不是run方法 ,run方法的调用相当于一个普通方法的调用

/*public void start()使该线程开始执行；Java 虚拟机调用该线程的 run 方法。 
结果是两个线程并发地运行*/

MyThread t1 = new MyThread() ;
t1.start();
//IllegalThreadStateException:非法状态异常,同一个线程只能被执行一次
// t1.start();
MyThread t2 = new MyThread() ;
t2.start();


}
MyThread类:
/**
*MyThread类就是一个执行线程类
*并且重写Thread类中的run 方法
*run()方法里面应该是一些耗时的操作,IO操作/循环语句..
*/
public class MyThread extends Thread {


@Override
public void run() {
// System.out.println("helloworld");
for(int x = 0 ;x <200; x ++) { //两个线程都需要执行这个代码
System.out.println(x);
}
}
}


--------------------------------------------------------------------------------
/**
*Thread 类提供了一些方法
* public final void setName(String name):给线程起名称
* public final String getName() :获取线程名称
*
*/
导包:
import java.security.AccessControlContext;
import java.security.AccessController;
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//创建两个线程对象
/* MyThread my1 = new MyThread() ;
MyThread my2 = new MyThread() ;

//启动线程
my1.start(); 
my2.start();*/

//给线程起名字:无参构造的形式+setName()
/*MyThread my1 = new MyThread() ;
MyThread my2 = new MyThread() ;


//给线程起名字
// my1.setName("高圆圆");
// my2.setName("张杨");

//分别启动
my1.start();
my2.start();*/

System.out.println("------------");
//public Thread(String name):有参构造的形式
MyThread t1 = new MyThread("张三") ;
MyThread t2 = new MyThread("李四") ;
t1.start();
t2.start();


//Thread类中提供另一个功能:
//public static Thread currentThread():返回当前正在执行的线程对象的引用
System.out.println(Thread.currentThread().getName());//main
}

MyThread类:
//第一种:继承关系Extends
public class MyThread extends Thread {
public MyThread() {

}

public MyThread(String name) {
super(name) ;
}


@Override
public void run() {
for(int x = 0 ;x < 100 ; x++) {//t1,t2
System.out.println(getName()+":"+x); //thread-线程编号(从0开始)
}
}
}
--------------------------------------------------------------------------------
/**
*跟线程优先级相关的方法:
* public final int getPriority()返回线程的优先级。 
* public final void setPriority(int newPriority)更改线程的优先级
* 线程存在一个默认优先级
*
* public static final int MAX_PRIORITY 10 最大优先级
* public static final int MIN_PRIORITY 1 最小优先级
* public static final int NORM_PRIORITY 5 默认优先级
*/
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//创建三个子线程
MyThread t1 = new MyThread() ;
MyThread t2 = new MyThread() ;
MyThread t3 = new MyThread() ;

// System.out.println(t1.getPriority()); //5 默认优先级
// System.out.println(t2.getPriority());
// System.out.println(t3.getPriority());

t1.setName("林青霞");
t2.setName("林志颖");
t3.setName("林彪");

//设置线程优先级
t1.setPriority(10); 
t2.setPriority(1);
t3.setPriority(5);

t1.start();
t2.start(); 
t3.start();
}
--------------------------------------------------------------------------------
/**
* 
*public final void setDaemon(boolean on) :true时,表示为守护线程

* 将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。(守护线程不会立即结

         *      束掉,它会执行一段时间在结束掉)

* 该方法必须在启动线程前调用。
*
*/
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//创建两个子线程
ThreadDaemon td1 = new ThreadDaemon() ;
ThreadDaemon td2 = new ThreadDaemon() ;

td1.setName("张飞");
td2.setName("关羽");

//在启动之前,设置为守护线程
td1.setDaemon(true); 
td2.setDaemon(true);

td1.start();
td2.start(); 

Thread.currentThread().setName("刘备");
for(int x =0 ; x < 5 ; x ++) {
System.out.println(Thread.currentThread().getName()+":"+x);
}
}
ThreadDaemon类:
public class ThreadDaemon extends Thread {

@Override
public void run() {
for(int x = 0 ; x<100; x ++) {
System.out.println(getName()+":"+x);
}
}
}
--------------------------------------------------------------------------------
/**
*public final void join():等待该线程终止 interruputedException 中断异常
*
*分别创建三个子线程,让第一个子线程执行之后,调用join()等待该线程中,在执行t2,t3线程
*/
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//创建三个子线程
ThreadJoin t1 = new ThreadJoin() ;
ThreadJoin t2 = new ThreadJoin() ;
ThreadJoin t3 = new ThreadJoin() ;

//分别给线程设置名称
t1.setName("李渊");
t2.setName("李世明");
t3.setName("李元霸");

t1.start();

try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}

t2.start();
t3.start();


}
ThreadJoin类:
//可执行线程
public class ThreadJoin extends Thread {

@Override
public void run() {
for(int x = 0  ; x < 100 ; x ++) {
System.out.println(getName()+":"+x);
}
}
}
--------------------------------------------------------------------------------
/**
* public static void sleep(long millis):线程睡眠 指定是时间毫秒值
* throws InterruptedException
* 
* 
* 两个区别?
* public final void stop() ;强迫线程停止执行。 不会执行了 (过时了),方法能使用的
* public void interrupt()中断线程。 表示中断线程的一种状态 
* 面试题
* 区别?
* wait(): wait()调用的,立即释放锁  (同步锁/Lock锁)
* sleep(): 线程睡眠,调用不会释放锁
* 
*
*/


主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//创建两个子线程
ThreadSleep ts1 = new ThreadSleep() ;
ThreadSleep ts2 = new ThreadSleep() ;

ts1.setName("张三");
ts2.setName("李四");

ts1.start();
ts2.start();
}
ThreadSleep类:
导包:
import java.util.Date;


public class ThreadSleep extends Thread {



@Override
public void run() {
for(int x = 0 ; x <100 ; x ++) {
//t1,t2
//t1, 0,1    //t2来了 ,3,4,5,6,7,8 //t1 2 ,,,
System.out.println(getName()+":"+x+",日期是:"+new Date());

//困了,想睡一秒钟
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}


}
}
--------------------------------------------------------------------------------
/**
* public final void stop() ;强迫线程停止执行。 不会执行了 (过时了),方法能使用的
*/
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//创建ThreadStop类对象
ThreadStop st = new ThreadStop() ;

st.start() ;

//如果3秒不醒来,我就干掉你
try {
st.sleep(3000);
// st.stop();
st.interrupt();// 中断
} catch (InterruptedException e) {
// e.printStackTrace();
System.out.println("程序出现了中断异常");
}

}
ThreadStop类:
public class ThreadStop extends Thread {

@Override
public void run() {
System.out.println("程序开始了....");

//睡秒10秒钟
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// e.printStackTrace();
System.out.println("程序出现异常了...");
}

System.out.println("程序结束了....");
}
}
--------------------------------------------------------------------------------
/**
* public static void yield()暂停当前正在执行的线程对象，并执行其他线程
*/
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//创建两个子线程对象
ThreadYield ty1 = new ThreadYield() ;
ThreadYield ty2 = new ThreadYield() ;

ty1.setName("张三");
ty2.setName("李四");

//分别启动线程
ty1.start();
ty2.start();
}
ThreadYield类:
public class ThreadYield extends Thread {


@Override
public void run() {//t1,t2子线程线程都要执行这个run()方法
for(int x = 0 ;x <100 ; x ++) {
System.out.println(getName()+":"+x);//

}
Thread.yield();

 
}
}
--------------------------------------------------------------------------------
/**
*实现多线程程序的第二种方式:
* 1)自定义一个类,实现Runnable接口
* 2)实现接口中的run方法,对耗时的代码进行操作
* 3)然后在主线程中创建该了对象,将该类对象做为一个资源类,创建Threadd类的对象,将刚才的资源类作为参数进行传递 
*/
主方法代码如下:(将代码复制到你所创建的类中就可运行)
public static void main(String[] args) {

//创建当前类对象
MyThread my =new MyThread() ;

//实现多线程
//public Thread(Runnable target,String name)
Thread t1 = new Thread(my, "高圆圆") ;
Thread t2 = new Thread(my, "赵又廷") ;

//启动线程
t1.start();
t2.start();
}
MyThread类:
//自定义类实现接口,实现run方法
public class MyThread implements Runnable {


@Override
public void run() {

for(int x= 0; x <100 ; x ++) {
// System.out.println(getName()+":"+x);
System.out.println(Thread.currentThread().getName()+":"+x);
}
}


}
--------------------------------------------------------------------------------