• 當前平臺默認編碼集 :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/內存操作流)

  13. *先使用字符緩沖輸出流寫數據,在使用字符緩沖輸入讀數據,顯示控制臺上

• *字符緩沖輸出流:

• 特有功能: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();

  }
  }

  17. 需求：把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();

}

}

8. 我有一個文本文件(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(): 線程睡眠,調用不會釋放鎖
  15. public static void yield()暫停當前正在執行的線程對象，並執行其他線程
  16. 實現多線程程序的第二種方式:
• 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();

  }
  }

學習內容總結