努力加油

一:
1.計算機如何存儲中文的?

當前平臺默認編碼集 :GBK 一個中文兩個字節
第一個字節:一定是負數
第二個字節:一般是負數,可能也會是正數,不會影響的結果.
*/
public class StringDemo {
public static void main(String[] args) {
//定義一個字符串
// String str = "abc" ;
// String str = "我愛你中國" ;
String str = "你好" ;//[-60, -29, -70, -61]

//轉成字節數組
byte[] bys = str.getBytes() ;

// System.out.println(bys);

//需要能看懂
//Arrays
//System.out.println(Arrays.toString(bys));//[97, 98, 99] :英文的字符串
System.out.println(Arrays.toString(bys));
//[-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]
}
}
2.

一次讀取一個字節數組的方式要比一次讀取一個字節方式高效.
*

一次讀取一個字節數組,相當於構造一個緩沖區,有沒有比一次讀取一個字節數組還要高效的流
字節緩沖流 :
*/
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {

//復制操作:將e盤下的abc.mp4復制到當前項目下,輸出copy.mp4
//封裝源文件
FileInputStream fis = new FileInputStream("e://abc.mp4") ;
//封裝目的地文件
FileOutputStream fos = new FileOutputStream("copy.mp4") ;

//讀寫操作:一次讀取字節數組
byte[] bys = new byte[1024] ;
int len = 0 ;
while((len=fis.read(bys))!=-1) {
//邊讀邊寫
fos.write(bys, 0, len);
}

//釋放資源
fis.close();

fos.close();
}
}
3.字節緩沖輸入流
public BufferedInputStream(InputStream in):默認緩沖區大小構造緩沖輸入流對象
public BufferedInputStream(InputStream in,int size):指定緩沖區大小構造緩沖輸入流對象
public int read()
public int read(byte[] b,int off,int len)
在使輸入流的時候,
兩種方式讀取(一次讀取一個字節/一次讀取一個字節數在),只能用一種方式,否則,會出現錯誤!
@author Administrator
/
public class BufferedInputStreamDemo {
public static void main(String[] args) throws Exception {
//構造一個字節緩沖輸入流對象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bos.txt"));

//讀數據
//一次讀取一個字節
/ int by = 0 ;
while((by=bis.read())!=-1) {
System.out.print((char)by);
}/
//一次讀取一個字節數組
byte[] bys = new byte[1024] ;
int len = 0 ;
while((len=bis.read(bys))!=-1) {
System.out.println(new String(bys, 0, len));
}
//釋放資源
bis.close();
}
}
4.字節緩沖輸出流:
構造方式:
(第一種開發中) 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)
5.存儲文件

IO流:永久存儲(耗時)
數據庫:永久存儲
基本的字節流
文件字節輸入流/文件字節輸出流
高效的字節流(緩沖流)
操作一個視頻文件,來測試速度問題
基本的字節流一次讀取一個字節 ://耗時:85772毫秒
基本的字節流一次讀取一個字節數組 :共耗時:216毫秒
高效的字節流一次讀取一個字節 :共耗時:682毫秒
高效的字節流一次讀取一個字節數組:共耗時:49毫秒
@author Administrator
StringBuffer:提供了一個字符串緩沖區 (可以在緩沖區中不斷追加字符串)
/
6.
使用字節流一次讀取一個字節的方式,會造成中文亂碼--->Java提供了一個字符流(專門用來解決中文亂碼問題)
*/
public class FileInputStreamDemo {
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);
}

//釋放資源
fis.close();
}
}
7.編碼和解碼:前後的編碼格式要一致!
編碼:
簡單理解:將能看懂的東西--->看不懂的東西
解碼:
看不懂的東西---能看懂的東西
舉例: 諜戰片
今天老地方見...
編碼:
今---->字節---->二進制數據
解碼:二進制數據-->十進制數據--->字節---->字符串
今
編碼: 將字符串變成一個字節數組
public byte[] getBytes() :平臺默認編碼集(默認的是Gbk)
public byte[] getBytes(Charset charset) ;"指定編碼格式
解碼:將字節數組--->字符串
public String(byte[] bytes) :使用平臺默認編碼集(gbk)
public String(byte[] bytes,Charset charset):用指定的編碼格式來解碼
@author Administrator
*/
public class StringDemo {
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);
}
}
8.需求:將a.txt文件中的內容進行復制,復制到當前項目下(b.txt)
文本文件:優先采用字符流
源文件:a.txt---->Reader---->InputStreamReader---->FileReader
目的的文件:b.txt--->Writer-->OutputStreamWriter---->FileWriter
9.字符轉換輸入流:InputStreamReader
InputStreamReader(InputStream in) :構造一個字符轉換輸入流,默認編碼
public InputStreamReader(InputStream in,Charset cs) 構造一個字符轉換輸入流,指定編碼
*字符轉換輸入流=字節流+編碼格式
10.字符流:
字符輸入流:Reader
字符輸出流:Writer
字符輸出流/字符輸入流:都是抽象類
使用一個子類:轉換流
字符輸出流的構造方法
public OutputStreamWriter(OutputStream out):使用默認的編碼格式構造一個字符轉換輸出流對象
public OutputStreamWriter(OutputStream out, Charset cs):使用指定編碼格式構造一個字符轉換輸出流對象
轉換流的構成=字節流+編碼格式(平臺默認/指定)
轉換流的對象的創建,格式比較長,非常麻煩,Java--->轉換流的便捷類
Reader:抽象類:字符輸入流
inputStreamReader(字符轉換輸入流 :inputStream+編碼格式)
便捷類:FileReader,這個類可以直接對文件進行操作
Writer:抽象類:字符輸出流
outputStreamWriter(字符轉換輸出流:outputStream+編碼格式)
便捷類:FileWriter,這個類可以直接對文件進行操作
11.字符輸入流讀數據的方法:

int read(char[] chs):讀取一個字符數組
int read():讀取單個字符
12.字符輸出流寫數據的功能:
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/內存操作流)
先使用字符緩沖輸出流寫數據,在使用字符緩沖輸入讀數據,顯示控制臺上
字符緩沖輸出流:
特有功能:public void newLine():寫入一個行的分隔符號
字符緩沖輸入流:
特有功能:public String readLine():一次讀取一行
14.BufferedReader:字符緩沖輸入流
構造方法
public BufferedReader(Reader in)創建一個使用默認大小輸入緩沖區的緩沖字符輸入流。
public BufferedReader(Reader in, int sz)創建一個使用指定大小輸入緩沖區的緩沖字符輸入流。
15.在字符流中提供了一個更高效的流-->字符緩沖流
字符緩沖輸入流
字符緩沖輸出流
BufferedWrier:文本寫入字符輸出流，緩沖各個字符，從而提供單個字符、數組和字符串的高效寫入
構造方法
BufferedWriter(Writer out) :默認緩沖區大小構造字符緩沖輸出流對象
BufferedWriter(Writer out,int size):指定緩沖區大小
16.使用字符緩沖流進行復制操作
分別使用兩種方式
1)一次讀取一個字符數組
2)一次讀取一行
/
public class CopyDemo {
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();
}
}
需求：把ArrayList集合中的字符串數據存儲到文本文件
` ArrayList集合存儲的元素String,可以存儲一些字符串
使用增強for遍歷ArrayList
使用BufferedWriter(文本文件)
源文件:ArrayList<String>
目的地:BufferedWriter輸出文本文件,給文件中寫入字符
*/
public class ArrayListToFileTest {
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();
}
}
18.復制文本文件(5種方式分別完成)
文本文件:字符流
基本的字符流一次讀取一個字符
一次讀取一個字符數組
字符緩沖流一次讀取一個字符
一次讀取一個字符數組
一次讀取一行
@author Administrator
*/
public class CopyTest {
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();

}
}
19.需求:有一個文本文本,需要將文本文件中的內容放到ArrayList集合中,遍歷集合獲取元素

源文件:b.txt----->讀取---->BuffferedReader
目的地:ArrayList<String>

*/
public class FileToArrayListTest {

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();

}
}
20.內存操作流:適用於臨時存儲文件.

內存操作輸入流:byteArrayInputStream
ByteArrayInputStream(byte[] buf)
內存操作輸出流: byteArrayOutputStream
構造方法:ByteArrayOutputStream()
內存操作流:一個程序結束後,那麽這些程序的變量,就會從內存消失(馬上消失的這些數據進行讀取寫入)
21.打印流
字符打印流(針對文本進行操作: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)
二.
序列化:將對象按照流的方式存儲到文本文件中或者再網絡中傳輸 對象---->流數據 序列化流 (ObjectOutputStream)
*反序列化:將文本文件中的流對象或者網絡傳輸中的流對象還原成對象 流數據--->對象 反序列化流(ObjectInputStream)
現在就自定義類:Person類
/
public class ObjectDemo {
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();

}
}
2.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
比如:當前的這個類中有很多屬性(性別,地址,學號...),某些屬性不想被序列化,如何解決這樣一個問題
3.Properties:表示了一個持久的屬性集(簡稱:屬性集合類) extends Hashtable<K,V> Map集合的
可保存在流中或從流中加載。屬性列表中每個鍵及其對應值都是一個字符串。
public Properties():無參構造
*/
public class PropertiesDemo {
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);
}
}
}
4.Properties:表示了一個持久的屬性集(簡稱:屬性集合類) extends Hashtable<K,V> Map集合的
可保存在流中或從流中加載。屬性列表中每個鍵及其對應值都是一個字符串。
public Properties():無參構造
*/
public class PropertiesDemo {
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);
}
}
}
5.屬性集合類的特有功能:
public Object setProperty(String key, String value) :給屬性列表中添加鍵和值,並且強制都使用String
public Set<String> stringPropertyNames():遍歷的功能
public String getProperty(String key)用指定的鍵在此屬性列表中搜索屬性
*/
public class PropertiesDemo2 {
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);
}
}
}
6.可保存在流中或從流中加載,只能使用屬性集合類
public void store(Writer writer,String comments):把集合中的數據保存文本文件中(屬性集合)
public void load(Reader reader):將文本文件中的數據加載到屬性集合中
7.可保存在流中或從流中加載,只能使用屬性集合類
public void store(Writer writer,String comments):把集合中的數據保存文本文件中(屬性集合)
public void load(Reader reader):將文本文件中的數據加載到屬性集合中
舉例:
打遊戲:遊戲進度的保存和遊戲加載
/
public class PropertiesDemo3 {
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)需要將當前屬性集合類中的保存文本文件中

/
public class PropertiesTest {
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();
}
}
9.JVM:Java虛擬機 識別main(主線程)
面試題:
JVM是多線程程序嗎?至少有幾條線程..
jvm是多線程的,
至少有2條線程...
有主線程,main..執行這些代碼,能夠被Jvm識別
在執行一些程序的時候,一些對象Jvm釋放掉,原因,
它開啟了垃圾回收線程,裏面GC:垃圾回收器(回收一些沒有更多引用的對象或者變量...)
10.如何實現多線程程序呢?
要實現多線程程序,需要開啟進程,
開啟進程,是需要創建系統資源,但是Java語言不能創建系統資源
只有C/C++可以創建系統資源, 利用c語言創建好的系統資源實現
Java提供了一個類:Thread類
實現多線程程序的步驟:
1)將類聲明為 Thread 的子類
2)該子類應重寫 Thread 類的 run 方法
3)在主線程進行該自定義的線程類的對象的創建
並行和並發(高並發:MyBatis --->IBatis:半自動化)
強者邏輯上的同時,指的是同一個時間段內
後者物理上的同時,指的是同一個時間點
/
public class ThreadDemo {
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();
}
}
11.Thread 類提供了一些方法
public final void setName(String name):給線程起名稱
public final String getName() :獲取線程名稱
12.public final void setDaemon(boolean on) :true時,表示為守護線程
將該線程標記為守護線程或用戶線程。當正在運行的線程都是守護線程時，Java 虛擬機退出。(守護線程不會立即結束掉,它會執行一段時間在結束掉)
該方法必須在啟動線程前調用。
13.跟線程優先級相關的方法:
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 class ThreadDemo {
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();

}
}
14.public static void sleep(long millis):線程睡眠 指定是時間毫秒值

throws InterruptedException
兩個區別?
public final void stop() ;強迫線程停止執行。 不會執行了 (過時了),方法能使用的
public void interrupt()中斷線程。 表示中斷線程的一種狀態
面試題
區別?
wait(): wait()調用的,立即釋放鎖 (同步鎖/Lock鎖)
sleep(): 線程睡眠,調用不會釋放鎖
public static void yield()暫停當前正在執行的線程對象，並執行其他線程
實現多線程程序的第二種方式:
1)自定義一個類,實現Runnable接口
2)實現接口中的run方法,對耗時的代碼進行操作
3)然後在主線程中創建該了對象,將該類對象做為一個資源類,創建Threadd類的對象,將剛才的資源類作為參數進行傳遞
*/
public class ThreadDemo {
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();
}
}

字節/字符——輸入/輸出流