1.List和和Set集合的區(qū)別?

1)是否有序List存儲和取出一致,有序的Set存儲和取出不一致,不能保證迭代次序---->默認(rèn)使用HashSet--->HashMap集合 2)是否重復(fù)List可以允許元素重復(fù)Set集合中存儲的元素唯一 3)具體實(shí)現(xiàn)類的數(shù)據(jù)結(jié)構(gòu)不同List集合--->ArrayList/Vector:底層數(shù)據(jù)結(jié)構(gòu):數(shù)組LinkedList底層數(shù)據(jù)結(jié)構(gòu):鏈表Set集合---->HashSet基于HashMap實(shí)例(底層哈希表)TreeSet基于TreeMap的實(shí)例(底層是一種紅黑樹(自平衡的二叉樹)結(jié)構(gòu))

2.List集合的遍歷方式

//遍歷方式 Object[] toArray() Iterator iterator() size()和get(int index)結(jié)合普通for循環(huán) ListIterator listiterator() //列表迭代器 //增強(qiáng)for循環(huán) for(存儲的數(shù)據(jù)類型 遍歷名: 集合對象){//... }

3.TreeSet集合存儲自定義類型如何實(shí)現(xiàn)自然排序?

//TreeSet集合要實(shí)現(xiàn)自然排序,使用無參構(gòu)造方法,而且需要保證TreeSet存儲的類型必須實(shí)現(xiàn)Compareable接口中的compareTo方法(T t) TreeSet<Student> ts = new TreeSet<>() ; //創(chuàng)建一些學(xué)生對象.... //添加到集合中//大部分常用了String,Character,Integer..等等都會實(shí)現(xiàn)Compareable接口,完成自然升序排序class Student implements Compareable<Student>{//屬性私有化//setXXX(xx)/getXXX()public int compareTo(Student s){//需要按照主要條件排序//自己分析次要條件return 結(jié)果;} }

4.HashSet集合存儲自定義類型,如何保證元素唯一

HashSet集合保證自定義類型的元素唯一:add方法--->依賴于HashMap的put方法---->putVal()方法--->間接依賴于Object的hashCode()和equals方法;當(dāng)前自定義類型必須重寫Object的equals和hashCode,保證元素唯一!

5.java.util.Date和String日期文本之間的相互轉(zhuǎn)換

class DateUtils{private DateUtils(){}public static String date2String(Date date,String patttern){return new SimpleDateFormat(pattern).format(date) ;}//String--->Datepublic static Date string2Date(String sourceDate,String pattern)throws ParseException{return new SimpleDateFormat(pattern).parse(sourceDate) ;}}

Map集合 <K, V>兩個子實(shí)現(xiàn)類

Map<K,V> :一個鍵對應(yīng)一個值(鍵值映射),Map集合針對鍵必須唯一,值是可以重復(fù)的!

將鍵映射到值的對象,一個映射不能包含重復(fù)的鍵,每個鍵最多只能映射到一個值Map接口和Collection接口的不同Map是雙列的,Collection是單列的Map的鍵唯一,Collection的子體系Set是唯一的Map集合的數(shù)據(jù)結(jié)構(gòu)值針對鍵有效，跟值無關(guān)Collection集合的數(shù)據(jù)結(jié)構(gòu)是針對元素有效

Map集合的基本功能:

V put(K key,V value) :添加方法---返回值什么意思?通過返回值是否為null,判斷鍵是否重復(fù),如果不重復(fù),返回值永遠(yuǎn)是null;如果鍵重復(fù),將第一次存儲鍵對應(yīng)的值返回,將后面鍵對應(yīng)的值進(jìn)行存儲void clear():清空Map集合的所有鍵值對V remove(Object key):刪除Map集合的指定鍵,然后返回被刪除的值boolean containsKey(Object key):是否包含指定的鍵boolean containsValue(Object value):是否包含指定的值boolean isEmpty():判斷Map集合是否為空

Map集合遍歷方式:1)

方式1：根據(jù)鍵找值獲取所有鍵的集合遍歷鍵的集合，獲取到每一個鍵根據(jù)鍵找值Set<K> keySet()獲取Map集合的所有的鍵的集合V get(Object key):通過鍵獲取值

例子1

package MapBianLi;import java.util.HashMap; import java.util.Map; import java.util.Set;public class Test2 {public static void main(String[] args) {Map<String,String>MP=new HashMap<>();MP.put("路飛","橡膠果實(shí)");MP.put("黑胡子","黑暗果實(shí)");MP.put("白胡子","震動果實(shí)");MP.put("艾斯","燒燒果實(shí)");Set<String> str = MP.keySet();//獲取Map集合的所有的鍵的集合//Set<K> keySet()獲取Map集合的所有的鍵的集合// V get(Object key):通過鍵獲取值for(String s:str){String s2 = MP.get(s);System.out.println(s+s2);}} }

例子2

package MapBianLi;import java.util.ArrayList; import java.util.HashMap; import java.util.Set;public class Test3 {public static void main(String[] args) {HashMap<String, ArrayList<String>>hs=new HashMap<>();ArrayList<String>as=new ArrayList<>();as.add("蒙奇.D.路飛");as.add("羅羅諾亞.索隆");as.add("文斯莫克.山治");hs.put("海賊王",as);ArrayList<String>as2=new ArrayList<>();as2.add("漩渦鳴人");as2.add("宇智波佐助");as2.add("春野櫻");hs.put("火影忍者",as2);ArrayList<String>as3=new ArrayList<>();as3.add("黑崎一護(hù)");as3.add("井上織姬");as3.add("茶渡泰虎");hs.put("死神",as3);Set<String> str = hs.keySet();for(String s:str){System.out.println(s+"\t");ArrayList<String> s2 = hs.get(s);System.out.println("\t"+s2);}} }

Map集合遍歷方式:2)

方式2：根據(jù)鍵值對對象找鍵和值獲取所有鍵值對對象的集合遍歷鍵值對對象的集合，獲取到每一個鍵值對對象根據(jù)鍵值對對象找鍵和值Set<Map.Entry<K,V>> entrySet() 獲取所有鍵值對對象K getKey()獲取鍵V getValue()

例子1

public class MapDemo3 {public static void main(String[] args) {//創(chuàng)建Map集合Map<String,String> map = new HashMap<>() ;//添加map.put("楊過","小龍女") ;map.put("郭靖","黃蓉") ;map.put("陳玄風(fēng)","梅超風(fēng)") ;map.put("令狐沖","任盈盈") ;//獲取所有的鍵值對對象Set<Map.Entry<String, String>> entrySet = map.entrySet();for(Map.Entry<String,String> en:entrySet){//獲取鍵,獲取值String key = en.getKey();String value = en.getValue();System.out.println(key+"="+value) ;}} }

例子2

package MapBianLi;import java.util.HashMap; import java.util.Map; import java.util.Set;public class Test4 {public static void main(String[] args) {Map<String,String>ms=new HashMap<>();ms.put("蒙奇.D.路飛","橡膠果實(shí)");ms.put("羅羅諾亞.索隆","劍豪");ms.put("文斯莫克.山治","改造人");Set<Map.Entry<String, String>> entries = ms.entrySet();for(Map.Entry<String, String> mss:entries){String key = mss.getKey();String value = mss.getValue();System.out.println(key+"\t "+value);}} }

Map集合和Collection集合的區(qū)別?

1)存儲類型Collection<E>,只能存儲一種引用類型---屬于"單列集合"---->理解為"光棍"Map<K,V>,可以存儲多種類型的引用類型--->屬于"雙列集合"----理解為"夫妻對"2)關(guān)系區(qū)別Collection和Map沒有直接關(guān)系,間接關(guān)系Collection具體的子接口Set--->HashSet/Treeset 直接的去依賴于Map接口的HashMap和TreeMap

HashMap<K,V>

Key:Student類型 ---學(xué)生信息 Value:String類型 ---朝代使用HashMap集合保證key(鍵)唯一! HahMap--->底層哈希表實(shí)現(xiàn),put方法依賴hashCode和equals方法,Map針對鍵有效,要針對鍵的類型自定類型,當(dāng)前類必須重寫equals和hashCode(),保證鍵唯一(重點(diǎn))

例子

package HashMapTest;import java.util.HashMap; import java.util.Set;class Student{private String name;private int age;public Student() {}public Student(String name, int age) {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;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (!(o instanceof Student)) return false;Student student = (Student) o;if (age != student.age) return false;return name != null ? name.equals(student.name) : student.name == null;}@Overridepublic int hashCode() {int result = name != null ? name.hashCode() : 0;result = 31 * result + age;return result;} } public class Test7 {public static void main(String[] args) {//創(chuàng)建HashMap集合HashMap<Student,String> hm = new HashMap<>() ;Student s1 = new Student("唐伯虎",35) ;Student s2 = new Student("唐伯虎",35) ;Student s3 = new Student("祝枝山",30) ;Student s4 = new Student("宋江",54) ;Student s5 = new Student("宋江",54) ;Student s6 = new Student("高圓圓",44) ;Student s7 = new Student("高圓圓",44) ;Student s8 = new Student("秋香",32) ;//添加元素hm.put(s1,"明朝") ;hm.put(s2,"明朝") ;hm.put(s3,"宋朝") ;hm.put(s4,"清朝") ;hm.put(s5,"清朝") ;hm.put(s6,"現(xiàn)代") ;hm.put(s7,"現(xiàn)代") ;hm.put(s8,"明朝") ;hm.put(s1,"現(xiàn)代") ;//遍歷Set<Student> keySet = hm.keySet();for(Student s:keySet){//通過獲取值String value = hm.get(s);System.out.println(s.getName()+"---"+s.getAge()+"---"+value);}}}

TreeMap<K,V>

存儲鍵值對元素,保證鍵唯一的同時,還有排序! 使用哪種排序,取決于使用構(gòu)造方法:public TreeMap():自然排序,當(dāng)前鍵的類型必須實(shí)現(xiàn)Compareable接口public TreeMap(Comparator<? super K> comparator):使用比較器排序 (推薦) 直接可以使用接口匿名內(nèi)部類 需求:TreeMap<Student,String>key:Student類型value:String,代表學(xué)生住址信息主要條件:按照學(xué)生姓名的長度,從小到排序分析次要條件:長度相同的,不一定姓名內(nèi)容相同"gaoyuanyuan""zhangsanfen"

例子

package TreeMapDTest;import java.util.Comparator; import java.util.Set; import java.util.TreeMap;class Student {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public void setName(String name) {this.name = name;}public void setAge(int age) {this.age = age;}public String getName() {return name;}public int getAge() {return age;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}} public class Test5 {public static void main(String[] args) {TreeMap<Student,String>ts=new TreeMap<>(new Comparator<Student>() {@Overridepublic int compare(Student s1, Student s2) {int num=s1.getName().length()-s2.getName().length();int num2=(num==0)?(s1.getName().compareTo(s2.getName())):num;return num2;}});Student n1=new Student("蔡徐坤",43);Student n2=new Student("陳立",33);Student n3=new Student("陳立",13);Student n4=new Student("何超",23);Student n5=new Student("何超",33);ts.put(n1,"美國");ts.put(n2,"中國");ts.put(n3,"法國");ts.put(n4,"英國");ts.put(n5,"日本國");Set<Student> stu = ts.keySet();for(Student s:stu){String s2 = ts.get(s);System.out.println(s.getName()+"---"+s.getAge()+"---"+s2);}} }

針對集合操作工具類

提供一些常用的方法: 1)public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key):2)二分搜索在List中查詢元素 (不管集合還是Arrays---->binaraySearch方法,(集合或者數(shù)組必須有序))3)public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) :獲取Colection中的最大值4)public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) :獲取Colection中的最小值5)public static <T extends Comparable<? super T>> void sort(List<T> list):針對List集合進(jìn)行自然排序6)public static <T> void sort(List<T> list,Comparator<? super T> c):針對List集合比較器排序7)public static void shuffle(List<?> list):針對List集合隨機(jī)置換7)public static <T> List<T> synchronizedList(List<T> list):將線程不安全ArrayList,變成線程安全的列表

例子

package CollectionTool;import java.util.ArrayList; import java.util.Collections; import java.util.List;public class Test8 {public static void main(String[] args) {List<Integer> list = new ArrayList<>();list.add(23);list.add(14);list.add(8);list.add(46);list.add(89);list.add(12);System.out.println(list);//[23, 14, 8, 46, 89, 12]System.out.println("-----------------");Integer max = Collections.max(list);System.out.println("list集合最大值是： "+max);//list集合最大值是： 89System.out.println("-----------------");//Integer本身實(shí)現(xiàn)的接口就是一個自然排序CompareableCollections.sort(list);System.out.println(list);//[8, 12, 14, 23, 46, 89]System.out.println("-----------------");int i = Collections.binarySearch(list, 99);//尋找list集合中是否有99這個元素int i1 = Collections.binarySearch(list, 12);//尋找list集合中是否有12這個元素System.out.println(i);//-7System.out.println(i1);//1System.out.println("-----------------");//針對List集合隨機(jī)置換Collections.shuffle(list);System.out.println(list);} }

斗地主老師代碼

package com.qf.collections_07;import java.util.ArrayList; import java.util.Collections;/*** 使用集合"模擬斗地主"洗牌,發(fā)牌---可以完成看牌的功能!*** 斗地主---->3個人玩, 54張牌,底牌3張*1)創(chuàng)建牌盒 ---沒有明確說明什么集合,默認(rèn)就使用ArrayList---->array*2)裝牌* 點(diǎn)數(shù)數(shù)組 String[] numbers = {"A","2","3","4",...."J","Q","K"} ;* 花色數(shù)組 String[] colors = {"?","?","?","?"} ;*2.1)將花色和點(diǎn)數(shù)遍歷,拼接成對一個 String poker*2.2)將poker牌 添加牌盒中,添加"小王","大王"**3)洗牌----->Collections工具類提供的:public static void shuffle(List<?> list):針對List集合隨機(jī)置換*4)發(fā)牌:* 三個玩家----每一個玩家都看成是ArrayList* player1* player2* player3* diPai集合---存3張牌* 4.1) 規(guī)律:遍歷牌盒中的所有牌* for(int x = 0 ; x <array.size() ; x++ ){* 判斷如果當(dāng)前* if(x >= array.size()-3){* //diPai.add(array.get(角標(biāo)x)) ;* }else if(x % 3 == 0){* //玩家1的牌* }else if(x % 3 == 1){* //玩家2的牌* }else if(x % 3 == 2){* //玩家3的牌* }* }**5)定義一個靜態(tài)方法----看牌的功能* public static void lookPoker(String name,ArrayList<String> array){** //name的牌是:* //遍歷這個牌盒* //將牌獲取到,輸出....* }**/ public class ArrayListTest {public static void main(String[] args) {//1)使用ArrayList模擬一個牌盒ArrayList<String> array = new ArrayList<>() ;//2)裝牌//定義一個點(diǎn)數(shù)數(shù)組String[] numbers = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"} ;//定義一個花色數(shù)組String[] colors = {"?","?","?","?"} ;//循環(huán)遍歷for(String color:colors){//獲取花色for(String number:numbers){String poker = number.concat(color);//將poker添加牌盒中array.add(poker) ;}}//添加小王和大王array.add("小王") ;array.add("大王") ;//System.out.println(array) ;//3)洗牌//Collections工具類提供的:public static void shuffle(List<?> list):針對List集合隨機(jī)置換Collections.shuffle(array) ;//System.out.println(array) ;//4)發(fā)牌----3個玩家 ,還創(chuàng)建一個集合:代表底牌//每一個玩家---默認(rèn)ArrayList存儲ArrayList<String> player1 = new ArrayList<>() ;ArrayList<String> player2 = new ArrayList<>() ;ArrayList<String> player3 = new ArrayList<>() ;ArrayList<String> diPai = new ArrayList<>() ;//規(guī)律:遍歷牌盒中的所有牌//判斷:如果當(dāng)前角標(biāo)>= 牌盒中所有的元素 -3 ---底牌for(int x = 0 ; x < array.size() ; x++){if(x >= array.size()-3){//底牌diPai.add(array.get(x)) ;}else if(x % 3 == 0){ //x % 3 == 0 :第一種情況//玩家1的player1.add(array.get(x)) ;}else if(x % 3 == 1){//第二種情況//玩家2player2.add(array.get(x)) ;}else if(x %3 == 2){//玩家3player3.add(array.get(x)) ;}}//看牌lookPoker("高圓圓",player1) ;lookPoker("李國棟",player2) ;lookPoker("趙又廷",player3) ;lookPoker("底牌",diPai) ;}//將看牌定義一個功能public static void lookPoker(String name,ArrayList<String> array){System.out.print(name+"的牌是:\t") ;//遍歷每一個人的牌for(String poker:array){System.out.print(poker+" ");}System.out.println();} }

線程和進(jìn)程

線程是依賴于進(jìn)程的,沒有進(jìn)程就沒有線程! 進(jìn)程在計算機(jī)的任務(wù)管理查看到此電腦上所有的客戶端的進(jìn)行!概念:調(diào)用"系統(tǒng)資源"的獨(dú)立單位!開啟一個進(jìn)程----創(chuàng)建 "系統(tǒng)資源" 所有的計算機(jī),包括我們"jvm",都支持多進(jìn)程,多進(jìn)程的意義?一句話:提高CPU的使用率!在打游戲的同時,聽音樂,---同時開啟了兩個進(jìn)程,是同時進(jìn)行的嗎?并不是同時的,CPU(時間片),一點(diǎn)點(diǎn)時間片可以高效在兩個進(jìn)制來回切換!線程:是進(jìn)程中的最小執(zhí)行單元!(理解為,進(jìn)程中的某個任務(wù))舉例:360進(jìn)程開啟之后,可以殺毒/清理/電腦瘦身等等多線程:在一個程序的過程中,其執(zhí)行路徑有多條,線程的執(zhí)行具有"隨機(jī)性"!多線程的意義?多個線程"共享同一個資源",互相搶占CPU執(zhí)行權(quán),從而達(dá)到線程的執(zhí)行速度!舉例1 v 3 打籃球,3個人搶占的籃球的幾率大,可能這1個人也能搶占大籃球!

創(chuàng)建線程的方式1: Thread類提供方法:

1)jvm是多線程的嗎?是多線程;至少有兩條件線程1)main---"用戶線程"2)垃圾回收線程,回收沒有更多的引用對象,從而釋放空間;如果沒有垃圾回收線程,Java中不斷的去new,不斷的堆內(nèi)存空間---->導(dǎo)致OOM(Out Of Memory:內(nèi)存溢出)2)Java能創(chuàng)建線程嗎?創(chuàng)建線程--->創(chuàng)建進(jìn)程---->創(chuàng)建系統(tǒng)資源---->Java不能夠直接創(chuàng)建資源的,間接的提供了一個Thread創(chuàng)建線程的方式1:1)自定義一個類 繼承Thread類2)重寫Thread類的run方法3)在main()用戶線程中,創(chuàng)建當(dāng)前線程了對象4)啟動線程--->start()不是run方法,run方法是一個普通方法,Thread類提供方法:public final String getName()獲取線程的名稱public final void setName(String name):設(shè)置線程名稱

例子

/*** 標(biāo)記當(dāng)前類是一個線程類*/ public class MyThread extends Thread{//重寫run方法@Overridepublic void run() {//兩個線程都要進(jìn)來//完成耗時的操作//循環(huán)for(int x = 0 ; x < 200 ; x ++){//public final String getName()獲取線程的名稱System.out.println(getName()+":"+x) ;}} }public class ThreadDemo {public static void main(String[] args) {/*for(int x = 0 ; x < 1000;x++){System.out.println(new Object()+":"+x) ;}*/ // 在main()用戶線程中,創(chuàng)建當(dāng)前線程了對象MyThread my = new MyThread() ;MyThread my2 = new MyThread() ;//第二個線程對象my.setName("高圓圓") ;my2.setName("李紀(jì)奔");//啟動線程/* my.run() ;my.run();*///上面代碼:使用線程對象將普通run方法調(diào)用兩次,并不會出現(xiàn)線程的執(zhí)行隨機(jī)性!my.start();//my.start() ;//IllegalThreadStateException:非法線程狀態(tài)異常,一個線程只能啟動一次my2.start();} }

Thread類的sleep方法以及join()方法/setPriority()設(shè)置線程優(yōu)先級的方法，以及線程的創(chuàng)建方式2Runnable接口

安全 不安全

ArrayList LinkedList
Vector StringBuilder
StringBuffer HashMap
TreeMap HashSet
String TreeSet

1.Collection和Map集合的區(qū)別

1)集合類型的區(qū)別Collection單例集合,只能存儲一種引用類型數(shù)據(jù)Map,雙列集合,可以存儲鍵值對Key,Value,兩種引用類型數(shù)據(jù) 2)遍歷方式的區(qū)別Collection--->使用自己的專有遍歷方式:迭代器---增強(qiáng)for來代替迭代器Map --->推薦:Set<K> keySet()--->增強(qiáng)for遍歷所有的鍵---->V get(Object key)Set<Map.entry<K,V>> etnrySet()--->遍歷鍵值對對象--->K getKey()V getValue() 3)間接有一定關(guān)系Collection里面Set接口的兩個子實(shí)現(xiàn)類,HashSet和TreeSet都依賴于Map接口中兩個子實(shí)現(xiàn)類HashMap和TreeMap---put方法有關(guān)系!

2.HashMap集合的鍵存儲自定義類型,如何保證鍵唯一

保證鍵唯一需要重寫HashCode和equals方法,HashMap底層依賴put方法最終直接關(guān)聯(lián)到Object的hashCode和equals方法;

3.List集s合和Set集合的區(qū)別?

1)是否有序List是有序,存儲和取出一致Set是無序的,默認(rèn)使用HashSet--->HashMap,(存儲和取出不一致) 2)元素是否可以重復(fù)List:元素可以重復(fù)Set:能夠保證元素唯一 3)兩個接口對應(yīng)實(shí)現(xiàn)類的底層數(shù)據(jù)結(jié)構(gòu)的區(qū)別ListArrayList:底層數(shù)組結(jié)構(gòu),查詢快,增刪慢,線程不安全,單線程中效率高Vector :底層數(shù)組結(jié)構(gòu),查詢快,增刪慢,線程安全的類,單線程中效率低,多線程中使用居多LinkedList:底層數(shù)據(jù)結(jié)構(gòu)是鏈表,查詢慢,增刪快,線程不安全的類,單線程中效率高Set:HashSet--->依賴HashMap---底層哈希表結(jié)構(gòu),保證元素唯一TreeSet--->依賴TreeMap--->自平衡的二叉樹結(jié)構(gòu),保證唯一,而且根據(jù)存儲的類型,是自然排序/還是比較器排序!(取決于使用的構(gòu)造函數(shù))

5.什么是進(jìn)程和線程?

進(jìn)程:是調(diào)用"系統(tǒng)資源"一個獨(dú)立單位!(每一個客戶端應(yīng)用程序,對應(yīng)一個進(jìn)程!)一個進(jìn)程:0-n個線程組成多進(jìn)程:是為了提高cpu的使用率! 線程:依賴于進(jìn)程,是程序中最小執(zhí)行單元(CPU調(diào)度的一種最小單位!) 多個線程去同一個資源(程序計數(shù)器:pc寄存器)多線程:為了讓多個線程互相搶占CPU執(zhí)行,提高線程的利用率!

6.創(chuàng)建線程的方式1的步驟

//1)自定義一個類,讓這個類繼承自Thread類 :標(biāo)記當(dāng)前是一個線程類 class MyThread extends Thread{//2)重寫Thread類中的run方法public void run(){//線程中的耗時操作...for(int x = 0 ; x < 200 ; x++){System.out.println(getName()+":"+x) ;}} }class ThreadDemo{public static void main(String[] args){//3)在main:用戶線程中(主線程中) 創(chuàng)建當(dāng)前這個線程類對象MyThread my1 = new MyThread() ;MyThread my2 = new MyThread() ;//4)設(shè)置線程名稱my1.setName("t1線程") ;my2.setName("t2線程") ; //5)啟動線程my1.start() ;my2.start() ;} }

2.Java中異常的處理 (兩種處理方案)

throws和try...catch,實(shí)際開發(fā)中,在業(yè)務(wù)層代中service層,使用try...catch捕獲異常;在dao層代碼中(數(shù)據(jù)庫訪問:jdbc/mybatis框架)----全部使用throws

4.線程的創(chuàng)建第二種 (重點(diǎn))

另一種方法來創(chuàng)建一個線程是聲明實(shí)現(xiàn)類"Runnable接口"。 那個類然后實(shí)現(xiàn)了run方法。 然后可以分配類的實(shí)例，在創(chuàng)建Thread時作為參數(shù)傳遞，并啟動; 如何使用:上面給的步驟第二種方式優(yōu)點(diǎn)?能夠體現(xiàn)數(shù)據(jù)共享/用到了設(shè)計模式"靜態(tài)代理"Java中23種設(shè)計模式(面試中:創(chuàng)建型/結(jié)構(gòu)型)創(chuàng)建型:單例/簡單工廠/工廠方法...結(jié)構(gòu)型:代理設(shè)計模式靜態(tài)代理動態(tài)代理--->跟"反射"有關(guān)系行為型

異常概念

程序中會出現(xiàn)異常,開發(fā)人員必須解決異常!異常的父類:Throwable-->提供一些方法:將異常的信息直接打印在控制上:具體(跟蹤堆棧-->底層原碼)public void printStackTrace()Error(嚴(yán)重問題) Exception嚴(yán)重問題:內(nèi)存溢出(借助于其他硬件解決這個問題,加內(nèi)存條)Exception:編譯時期異常:只要不是RuntimeException的子類,都屬于編譯時期必須讓開發(fā)人員必須處理,不處理,代碼編譯通過不了!運(yùn)行時期異常:RuntimeException大部分邏輯不夠嚴(yán)謹(jǐn),導(dǎo)致出現(xiàn)的問題NullPointerEception:在獲取到某個類的對象的時候,并沒有非空判斷,可能對象是null,使用這個對象調(diào)用它里面的方法,出現(xiàn)空指針了

常見格式

在Java中處理異常方案:throws:拋出//標(biāo)準(zhǔn)格式try{可能出現(xiàn)問題的代碼}catch(異常類名 對象名){處理異常}finally{//釋放資源}變形格式try{可能出現(xiàn)問題的代碼}catch(異常類名 對象名){處理異常}try{可能出現(xiàn)問題的代碼}catch(異常類名 對象名){處理異常}catch(異常類名2 對象名2){處理異常...}

例子try…catch…

public class ExceptionDemo {public static void main(String[] args) {//處理方案://try...catch...//try代碼如果出現(xiàn)問題,---執(zhí)行catch語句---->處理異常---->內(nèi)存中,jvm會創(chuàng)建異常的對象,new XXException,//執(zhí)行的catch語句代碼try{//可能出現(xiàn)的代碼int i = 10 ;System.out.println(i/0) ;}catch(Exception e){ //捕獲的異常Exception//自己處理//System.out.println("除數(shù)不能為0");e.printStackTrace();}System.out.println("over");}

例子throws,throw

public class ExceptionDemo2 {public static void main(String[] args) throws IOException,ArrayIndexOutOfBoundsException, Exception { //throws 在方法聲明上//將可能出現(xiàn)代碼包起來---try...catch--- (ctrl+alt+t---->選擇第6個)/* try {int[] arr = {11,22,33} ;System.out.println(arr[0]);System.out.println(arr[1]);System.out.println(arr[3]);//ArrayIndexOutOfBoundsException數(shù)組角標(biāo)越界} catch (Exception e) {e.printStackTrace();}*/int[] arr = {11,22,33} ;System.out.println(arr[0]);System.out.println(arr[1]);//System.out.println(arr[3]);//ArrayIndexOutOfBoundsException數(shù)組角標(biāo)越界System.out.println("----------------------------------------------");Date date = string2Date();System.out.println(date);System.out.println("-------------------------------");divide();}public static Date string2Date() throws ParseException {String source = "2023-03-21" ;//將source--->java.util.DateSimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd ") ;//當(dāng)解析的時候,模式的格式和String文本格式不一致會出現(xiàn)問題Date date = sdf.parse(source);//編譯時期異常 --誰調(diào)用這個方法,就必須處理這個方法return date ;}public static void divide() throws Exception {int i = 10 ;int b = 0 ;if(b==0){//如果執(zhí)行到這個代碼中,一定會出異常!throw new Exception("除數(shù)不能為0") ;}else{System.out.println(i/b) ;}} }

throw和throws的區(qū)別

異常處理throws:拋出throw:拋出區(qū)別:1)書寫位置的區(qū)別throws:用在方法聲明上throw:用在方法體中2)后面跟的類型不一樣的throws后面跟的異常類名,可以多個,中間逗號隔開throw:后面只能一個異常對象,new XXException()3)是否出現(xiàn)異常的時機(jī)throws:可能出現(xiàn)問題,可能性throw:執(zhí)行某個邏輯代碼,一定會出現(xiàn)這個異常!(肯定性)4)處理異常:throws:拋出給調(diào)用者,誰調(diào)用這個方法(帶有throws的方法),誰必須對這個已處理(throws/try...catch...)throw:異常的處理:交給方法體中邏輯判斷,if(xxx){throw new XXException(...);}

異常的使用的注意事項(xiàng):

1)子類繼承父類的時候,如果子類重寫父類的方法,父類的方法如果本身沒有throws拋出異常子類的方法中出現(xiàn)異常,子類只能自己處理,只能try...catch...2)子類繼承父類,子類重寫父類方法的時候,如果父類的方法拋出異常,那么子類的該方法最起碼要根父類的方法異常保存一致(要么子類該放的異常是父類方法的異常中的子類)

例子

class Father{public void method() {System.out.println("method Father");}public void show() throws ArrayIndexOutOfBoundsException{System.out.println("show father");} } class Son extends Father{@Overridepublic void show() throws ArrayIndexOutOfBoundsException {System.out.println("show Son");}@Overridepublic void method() {try {//將日期文本---解析java.util.DateString dateStr = "2023-05-01" ;SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd") ;Date date = sdf.parse(dateStr);} catch (ParseException e) {e.printStackTrace();}} } public class ExceptionDemo {public static void main(String[] args) {} }

異常的使用的注意事項(xiàng):

1)子類繼承父類的時候,如果子類重寫父類的方法,父類的方法如果本身沒有throws拋出異常子類的方法中出現(xiàn)異常,子類只能自己處理,只能try...catch...2)子類繼承父類,子類重寫父類方法的時候,如果父類的方法拋出異常,那么子類的該方法最起碼要根父類的方法異常保存一致(要么子類該放的異常是父類方法的異常中的子類)

例子

class Father{public void method() {System.out.println("method Father");}public void show() throws ArrayIndexOutOfBoundsException{System.out.println("show father");} } class Son extends Father{@Overridepublic void show() throws ArrayIndexOutOfBoundsException {System.out.println("show Son");}@Overridepublic void method() {try {//將日期文本---解析java.util.DateString dateStr = "2023-05-01" ;SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd") ;Date date = sdf.parse(dateStr);} catch (ParseException e) {e.printStackTrace();}} } public class ExceptionDemo {public static void main(String[] args) {} }

線程的Join方法

等待該線程中終止public final void join() throws InterruptedException因?yàn)榫€程的執(zhí)行具有隨機(jī)性,哪個線程啟動之后,調(diào)用join(),正常理想情況,等待該線程執(zhí)行完畢,執(zhí)行其他線程!需求實(shí)現(xiàn)三個線程依次先后執(zhí)行完畢, t1,t2,t3每一個線程啟動之后,都可以調(diào)用join()

例子

package Test2; /*現(xiàn)在有T1、T2、T3三個線程，你怎樣保證T2在T1執(zhí)行完后執(zhí)行，T3在T2執(zhí)行完后執(zhí)行 (線程里面的join使用)T1--T2--T3*/ class Demo extends Thread{@Overridepublic void run() {for (int x = 0; x < 100; x++) {System.out.println(getName() + ":" + x);}} } public class Test2 {public static void main(String[] args) {Demo T1=new Demo();Demo T2=new Demo();Demo T3=new Demo();T1.setName("T1");T2.setName("T2");T3.setName("T3");T1.start();try {T1.join();} catch (InterruptedException e) {e.printStackTrace();}T2.start();try {T2.join();} catch (InterruptedException e) {e.printStackTrace();}T3.start();try {T3.join();} catch (InterruptedException e) {e.printStackTrace();}} }

線程的yield方法

public static void yield():線程禮讓(暫停當(dāng)前正在執(zhí)行的線程,執(zhí)行其他線程)

package Yield; class YieldThread extends Thread{@Overridepublic void run() {for(int x=0;x<20;x++){System.out.println(getName()+": "+x);yield();}} } public class Test5 {public static void main(String[] args) {YieldThread yt=new YieldThread();YieldThread yt2=new YieldThread();YieldThread yt3=new YieldThread();yt.setName("張三");yt2.setName("李四");yt3.setName("王五");yt.start();yt2.start();yt3.start();} }

優(yōu)先級

public final void setPriority(int newPriority):設(shè)置優(yōu)先級public final int getPriority():獲取優(yōu)先級Thread提供三個自定義常量:public static final int MAX_PRIORITY 10 最大優(yōu)先級public static final int MIN_PRIORITY 1 最小優(yōu)先級public static final int NORM_PRIORITY 5 默認(rèn)優(yōu)先級創(chuàng)建線程,沒有設(shè)置優(yōu)先級,線程的默認(rèn)優(yōu)先級就是5(搶占CPU執(zhí)行權(quán)的概率一樣大)

例子

package PriorityThread; class Priority extends Thread{@Overridepublic void run() {for(int x = 0 ; x < 100 ; x++){System.out.println(getName()+":"+x);}} }public class PriorityThread {public static void main(String[] args) {Priority p1=new Priority();Priority p2=new Priority();Priority p3=new Priority();p1.setName("王拉拉");p2.setName("王喜喜");p3.setName("王露露");//設(shè)置優(yōu)先級p1.setPriority(10);p3.setPriority(1);p1.start();p2.start();p3.start();} }

線程創(chuàng)建方式1

1)自定義一個類 繼承Thread類2)重寫Thread類的run方法3)在main()用戶線程中,創(chuàng)建當(dāng)前線程了對象4)啟動線程--->start()不是run方法,run方法是一個普通方法,Thread類提供方法:public final String getName()獲取線程的名稱public final void setName(String name):設(shè)置線程名稱

例子

/*** 標(biāo)記當(dāng)前類是一個線程類*/public class MyThread extends Thread{//重寫run方法@Overridepublic void run() {//兩個線程都要進(jìn)來//完成耗時的操作//循環(huán)for(int x = 0 ; x < 200 ; x ++){//public final String getName()獲取線程的名稱System.out.println(getName()+":"+x) ;}}}public class ThreadDemo {public static void main(String[] args) {/*for(int x = 0 ; x < 1000;x++){System.out.println(new Object()+":"+x) ;}*/// 在main()用戶線程中,創(chuàng)建當(dāng)前線程了對象MyThread my = new MyThread() ;MyThread my2 = new MyThread() ;//第二個線程對象my.setName("高圓圓") ;my2.setName("李紀(jì)奔");//啟動線程/* my.run() ;my.run();*///上面代碼:使用線程對象將普通run方法調(diào)用兩次,并不會出現(xiàn)線程的執(zhí)行隨機(jī)性!my.start();//my.start() ;//IllegalThreadStateException:非法線程狀態(tài)異常,一個線程只能啟動一次my2.start();}}

線程創(chuàng)建方式2

線程的創(chuàng)建方式2:1)自定義一個類,實(shí)現(xiàn)Runnable接口2)重寫Runnable接口的run方法3)在用戶線程main中去創(chuàng)建當(dāng)前類對象--->"資源類"4)創(chuàng)建Thread類對象,將3)資源類作為Thread類對象的參數(shù)進(jìn)行傳遞

例子

package ThreadCreat2; class MyRunnable implements Runnable{@Overridepublic void run() {//完成耗時的操作//兩個線程都要進(jìn)來for(int x = 0 ; x < 200 ; x ++){//Thread類靜態(tài)方法//public static Thread currentThread():獲取正在執(zhí)行的線程System.out.println(Thread.currentThread().getName()+":"+x) ;}} }public class Test8 {public static void main(String[] args) {//創(chuàng)建MyRunnable類對象MyRunnable my = new MyRunnable() ;//創(chuàng)建線程Thread類對象,將資源類作為參數(shù)傳遞//public Thread(Runnable target,String name)Thread t1 = new Thread(my,"t1") ;Thread t2 = new Thread(my,"t2") ;//啟動線程t1.start() ;t2.start() ;} }

方式1和方式2的優(yōu)劣

方式1的弊端：1）繼承關(guān)系說。繼承關(guān)系有局限性。繼承Thread類，重寫了run方法，但是其他的方法也會繼承過來，2）內(nèi)存角度看，多個線程導(dǎo)致多個棧指向多個堆 方式2的好處1）面向接口編程，直接實(shí)現(xiàn)Runnable這種方式：靜態(tài)代理，可以體現(xiàn)數(shù)據(jù)共享！創(chuàng)建對象的時候都指向同一個資源對象！實(shí)現(xiàn)Runnable接口的 類對象

java有23種模式

創(chuàng)建型:單例/簡單工廠/工廠方法...結(jié)構(gòu)型:代理設(shè)計模式靜態(tài)代理動態(tài)代理--->跟"反射"有關(guān)系行為型

線程的6種狀態(tài)

在Thread類中提供了內(nèi)部枚舉：enum State{}NEW= new新建RUNNABLE= runnable 運(yùn)行BLOCKED= blocked 阻塞WAITING= waiting死死等待 TIMED_WAITING= timed_waiting 超時等待TERMINATED= terminated線程終止/死亡

靜態(tài)代理

設(shè)計模式一種思想(前輩總結(jié)出來的),并非一種技術(shù)代理設(shè)計模式屬于結(jié)構(gòu)型設(shè)計模式一種;代理設(shè)計模式: 核心思想:讓代理角色幫助真實(shí)角色完成一件事情!靜態(tài)代理動態(tài)代理:jdk動態(tài)代理:前提必須有接口cglib動態(tài)代理:第三方j(luò)ar包 ---基于子類實(shí)現(xiàn)靜態(tài)代理:最大特點(diǎn):代理角色和真實(shí)角色必須實(shí)現(xiàn)同一個接口代理角色:幫助真實(shí)角色完成一些事情真實(shí)角色:專注于自己的事情弊端：代理角色堆業(yè)務(wù)功能增強(qiáng)的是時候，和系統(tǒng)監(jiān)控的代碼不能有效的分離

老師例子

public class StaticProxyDemo {public static void main(String[] args) {//測試真實(shí)角色//接口多態(tài)/創(chuàng)建具體的子類You you = new You() ;you.mary();System.out.println("---------------------------------") ;//創(chuàng)建WeddingCompany類對象You you2 = new You() ;//---->類似 資源類對象 MyRunnable implement RunnbleWeddingCompany weddingCompany = new WeddingCompany(you2) ; //類似 ---Thread t1 = new Thread(MyRunnable對象,線程名稱);weddingCompany.mary() ; //類似----t1.start() ; jvm調(diào)用run}} //結(jié)婚的接口 interface Mary{void mary() ; }//真實(shí)角色 class You implements Mary{@Overridepublic void mary() {System.out.println("要結(jié)婚了,很開心...");} }//婚慶公司:代理角色 class WeddingCompany implements Mary{//聲明Mary接口變量private Mary mary ; //---類似Thread類的private Runnable target;public WeddingCompany(Mary mary){//類似 Thread(Runnable target,String name)this.mary = mary ;}@Overridepublic void mary() {if(mary!=null){System.out.println("婚慶公司,要布置婚禮現(xiàn)場!");//真實(shí)角色完成它自己的事情mary.mary();System.out.println("婚慶公司接收尾款!");}} }

關(guān)鍵字鎖（synchronized）

Java的同步機(jī)制synchronized(鎖對象){ //鎖對象可以是任意的Java類對象,每一個線程都是用"同一把鎖"多條語句對共享數(shù)據(jù)的操作

老師例子

package Synchronized;class Demo{} class SellTicket implements Runnable{ private static int ticket=100; private Object obj=new Object(); private Demo d=new Demo(); // synchronized(鎖對象){ //鎖對象可以是任意的Java類對象,每一個線程都是用"同一把鎖"// 多條語句對共享數(shù)據(jù)的操作}@Overridepublic void run() {while (true){synchronized (obj){//由于鎖里的可以是任意java類 所以隨便定義一個類就可，里面寫上面的 d 也可以if(ticket>0){try {Thread.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"正在出售第"+(ticket--)+"張票");}}}} } public class Test10 {public static void main(String[] args) {//創(chuàng)建SellTicket對象SellTicket st = new SellTicket() ;//創(chuàng)建三個線程Thread t1 = new Thread(st,"窗口1") ;Thread t2 = new Thread(st,"窗口2") ;Thread t3 = new Thread(st,"窗口3") ;//啟動線程t1.start() ;t2.start() ;t3.start() ;} }

1.如何解決多線程的安全問題

使用Java同步鎖---同步代碼塊 格式://多個線程必須使用同一個鎖對象!(任意Java類對象,jdk提供,或者自定義的類)synchronized(鎖對象){將多條語句對共享數(shù)據(jù)的操作包裹起來;} //Java中線程安全的類Vector集合/StringBuffer還有Collections里面有一些方法都是同步鎖

2.join()和yield()的區(qū)別?

join()當(dāng)前線程終止(線程調(diào)用join()方法會讓當(dāng)前線程執(zhí)行完畢) yield() 線程禮讓,暫停正在執(zhí)行的線程,并執(zhí)行其他線程!

3.線程的狀態(tài)有哪些?

Thread類中有內(nèi)部枚舉類:enum State{NEW,新建狀態(tài)RUNNABLE,運(yùn)行狀態(tài)BLOCKED,線程阻塞狀態(tài)WAITTING,死死等待,TIMED_WAITTING,超時等待TERMINATED,線程終止/線程死亡}

4.什么是靜態(tài)代理?

靜態(tài)代理:特點(diǎn):代理角色和真實(shí)角色必須實(shí)現(xiàn)同一個接口!始終代理的核心思想:讓代理角色幫助真實(shí)角色完成功能的增強(qiáng)!舉例:這個角色---CEO (添加權(quán)限/刪除權(quán)限/查詢權(quán)限/修改權(quán)限)這個用戶是否是CEO---->在進(jìn)行添加/刪除/修改/查詢---"權(quán)限校驗(yàn)"如果有權(quán)限--->完成了查詢/修改/添加/刪除的動作對當(dāng)前哪一天這個人操作的這些事情---->"產(chǎn)生日志"弊端:代理角色對業(yè)務(wù)功能增強(qiáng)的時候,和"系統(tǒng)監(jiān)控的代碼"不能有效分離!

5.線程創(chuàng)建的方式2的實(shí)現(xiàn)方式

//創(chuàng)建線程的方式2使用的就是一種靜態(tài)代理: class MyRunnable implements Runnable{public void run(){//線程執(zhí)行的業(yè)務(wù)} }class ThreadTest{public static void main(String[] args){MyRunnable my = new MyRunnable() ;//真實(shí)角色//Thread類 implements Runnable{ //代理角色private Runnable target;private String name ;// public Thread(Runnable target,String name ){//init初始化方法---->通過局部變量成員變量賦值//}//public void run(){// if(target!=null){target.run() ;//}//} // }//創(chuàng)建線程類對象Thread t1 = new Thread(my,"t1線程") ;Thread t2 = new Thread(my,"t2線程") ;//啟動線程t1.start() ;t2.start() ;} }

1.解決死鎖—>同步中使用 "生產(chǎn)者-消費(fèi)者"思想

出現(xiàn)死鎖原因:多個線程加入同步鎖之后,線程互相之間持有對方的鎖,每一個線程必須讓對方釋放鎖之后,才能去使用同步中的內(nèi)容,導(dǎo)致線程之間出現(xiàn)互相等待!(訪問的資源不是同一個資源)wait()+notify():這個兩個必須在synchronzied使用(同步代碼塊或者同步方法) 使用"信號燈法"來解決死鎖問題

2.面試題: sleep和wait方法區(qū)別?

1)使用區(qū)別:sleep()單獨(dú)使用,里面?zhèn)魅氤瑫r時間,wait()不能單獨(dú)用,必須在同步代碼塊/同步方法中使用,否則,就會出現(xiàn) java.lang.IllegalMonitorStateException 2)來源不同sleep(long time)線程睡眠,來源于Thread類中,wait()來源于Object類中 3)導(dǎo)致線程狀態(tài)不同sleep(long time)參數(shù)出入的超時時間,時間到達(dá),線程睡眠接收,線程會繼續(xù)執(zhí)行,在休眠過程中,線程處于的狀態(tài)是TIMED_WAITTING(超時等待)wait() 線程進(jìn)入等待狀態(tài),如果沒有鎖對象調(diào)用notify()或則notifyAll(),線程狀態(tài)就進(jìn)入到WAITTING(死死等待) 4)是否主動喚醒sleep(long time):時間到達(dá)之后,自動喚醒(主動喚醒),而wait(),被動喚醒,需要使用notify()或者notifyAll進(jìn)行喚醒 5)是否會釋放鎖sleep()方法不會去釋放鎖,wait()方法調(diào)用會立即釋放鎖

3.線程池

線程的好處:1)提高了線程使用率2)大大減少資源開銷4)可以通過一些參數(shù)(7大參數(shù))進(jìn)行線程池的調(diào)優(yōu),到達(dá)一些效果 弊端:維護(hù)成本大可以通過線程池---->Executors工廠類提供很多靜態(tài)方法 public static ExecutorService newFixedThreadPool(int nThreads):創(chuàng)建固定的可重用的線程數(shù)的線程池ExecutorService子實(shí)現(xiàn)類=--- TreadPoolExecutor完成線程池初始化! 如果涉及到定期讓線程進(jìn)行活動(public static ScheduledExecutorService newScheduledThreadPool)

面試題 wait()/notify()并非Thread類中為什么定義在Object的?

wait()線程等待--->底層域wait(long time),Java的本地方法(底層語言操作),使用monitor(監(jiān)視器鎖)來調(diào)用wait方法(本質(zhì)就是synchronized同步鎖)notify()/notifyAll():喚醒單個線程以及喚醒所有線程,都是鎖對象的方法,而鎖對象可以是任意Java類對象,不會定義在Thread類中,而是在Object類中定義的

同步方法

如果一個成員方法中進(jìn)來就是一個synchronized(鎖對象){}----同步代碼塊,將synchronized提到方法聲明上默認(rèn)的鎖對象this如果是靜態(tài)的同步方法,鎖對象是 "當(dāng)前類名.class"--跟"反射"有關(guān)系反射:Java代碼經(jīng)歷三個階段"SORUCE" ,"CLASS"(反射中的核心) "RUNTIME"//同步方法:如果一個成員方法中進(jìn)來就是一個synchronized(鎖對象){}----同步代碼塊,將synchronized提到方法聲明上//同步方法的鎖對象:是this---當(dāng)前類對象的地址值引用!

例子

package Synchronized_Funcation; class SellTicket implements Runnable{private static int tickets = 100 ;//創(chuàng)建一把鎖private Object obj = new Object() ;//定義一個統(tǒng)計變量int x = 0 ;@Overridepublic void run() {//模擬一直有票while(true){if(x% 2==0){ // synchronized (obj) {//synchronized (this) {//當(dāng)前類對象的地址值引用synchronized (SellTicket.class) {//當(dāng)前類名.class:獲取到當(dāng)前類的字節(jié)碼文件對象if (tickets > 0) {//模擬網(wǎng)絡(luò)延遲try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "正在出售第" + (tickets--) + "張票");}}}else {//x變量不能被2整除sell() ; //同步方法(非靜態(tài))}x++ ;}}public static synchronized void sell(){//靜態(tài)是隨著類的加載而加載 ,靜態(tài)的同步方法的鎖對象是"類if (tickets > 0) {//模擬網(wǎng)絡(luò)延遲try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "正在出售第" + (tickets--) + "張票");}} }public class Test_thecher {public static void main(String[] args) {SellTicket st = new SellTicket() ;//三個線程操作同一個資源Thread t1 = new Thread(st,"窗口1") ;Thread t2 = new Thread(st,"窗口2") ;Thread t3 = new Thread(st,"窗口3") ;//啟動線程t1.start() ;t2.start() ;t3.start() ;} }

同步鎖//同步代碼塊//同步方法

（以下是擴(kuò)展內(nèi)容）同步代碼塊 synchronized(obj) {//需要被同步的代碼塊 }同步方法同步方法是當(dāng)方法聲明上加synchronized，表示此時只有一個線程進(jìn)入同步方法。鎖住的該類實(shí)例化的對象。

死鎖

兩個或者兩個以上的線程,在執(zhí)行的過程中,互相持有對方的鎖,需要等待對方釋放鎖,導(dǎo)致出現(xiàn)了互相等待情況

例子

//創(chuàng)建兩把鎖 public class MyLock {// 鎖對象:可以是任意Java類對象public static Object objA = new Object() ;public static Object objB = new Object() ; }//資源類 public class DieLock implements Runnable {private boolean flag ;public DieLock(boolean flag){this.flag = flag ;}@Overridepublic void run() {if(flag){synchronized (MyLock.objA){System.out.println("if ObjA...");synchronized (MyLock.objB){System.out.println("if ObjB...");}}}else {synchronized (MyLock.objB){System.out.println("else ObjB...");synchronized (MyLock.objA){System.out.println("else objA...");}}}} }//測試類 public class ThreadDemo {public static void main(String[] args) {//創(chuàng)建資源類對象DieLock d1 = new DieLock(true) ;DieLock d2 = new DieLock(false) ;//創(chuàng)建線程類Thread t1 = new Thread(d1) ;Thread t2 = new Thread(d2) ;//啟動線程t1.start();t2.start();} }

生產(chǎn)者和消費(fèi)者模式思想

使用生產(chǎn)者和消費(fèi)者模式思想,來解決線程死鎖問題!組成:Student類:姓名,年齡兩個學(xué)數(shù)據(jù)SetTread類:生產(chǎn)資源類,里面產(chǎn)生學(xué)生數(shù)據(jù)GetThred類:消費(fèi)者資源類,里面使用學(xué)生數(shù)據(jù)ThreadDemo類:用戶線程,等會開啟兩個生產(chǎn)者所在的線程/消費(fèi)者所在的線程

常見的問題 和解決方案

問題1:輸出null--0,因?yàn)樯a(chǎn)資源類中和消費(fèi)資源類中并沒有使用同一個資源!優(yōu)化:需要不斷的在生產(chǎn)資源類中產(chǎn)生學(xué)生數(shù)據(jù),在消費(fèi)者資源類中不斷地使用學(xué)生數(shù)據(jù)!問題2:不斷的在生產(chǎn)者資源類中產(chǎn)生數(shù)據(jù),消費(fèi)者資源不斷使用使用數(shù)據(jù),出現(xiàn)數(shù)據(jù)紊亂!姓名和年齡不符! ---多線程環(huán)境不安全---需要多線程安全問題校驗(yàn)多線程安全問題的標(biāo)準(zhǔn):1)是否是多線程環(huán)境2)是否存在共享數(shù)據(jù)3)是否有多條語句對共享數(shù)據(jù)操作使用同步代碼塊---將3) 包起來問題3: 加入同步代碼塊,解決了線程安全問題,數(shù)據(jù)不會紊亂,但是數(shù)據(jù)一打印一大片原因:線程的執(zhí)行,通過cpu一點(diǎn)點(diǎn)時間片,足夠線程執(zhí)行很多次!

例子老師

package Test2; class Student {String name ; //姓名int age ; //年齡boolean flag ; //false,沒有數(shù)據(jù),true,有數(shù)據(jù)! }class SetThread implements Runnable{private Student s ;public SetThread(Student s){this.s = s ;}private int x = 0 ;//統(tǒng)計變量@Overridepublic void run() {while(true){synchronized (s){ //鎖對象,任意Java類對象//創(chuàng)建學(xué)生對象// Student s = new Student() ;if(x % 2==0){//%2是因?yàn)檫@樣子的話打印出來就是依次兩個的。s.name = "高圓圓" ;s.age = 44 ;}else {s.name = "李國棟";s.age = 23 ;}}x ++ ;}} } class GetThread implements Runnable{//聲明學(xué)生變量private Student s ;public GetThread(Student s){this.s = s ;}@Overridepublic void run() {while(true){synchronized (s){//使用學(xué)生學(xué)生//Student s = new Student() ;System.out.println(s.name.concat(""+s.age));}}} } public class TestMiNi {public static void main(String[] args) {//創(chuàng)建學(xué)生對象Student s = new Student() ;//創(chuàng)建資源類SetThread st = new SetThread(s) ;GetThread gt = new GetThread(s) ;//創(chuàng)建兩個線程Thread t1 = new Thread(st) ;Thread t2 = new Thread(gt) ;//啟動線程t1.start() ;t2.start() ;} }

信號燈機(jī)制和等待喚醒機(jī)制

//使用生產(chǎn)者和消費(fèi)者模式思想,來解決線程死鎖問題!組成:Student類:姓名,年齡兩個學(xué)數(shù)據(jù)SetTread類:生產(chǎn)資源類,里面產(chǎn)生學(xué)生數(shù)據(jù)GetThred類:消費(fèi)者資源類,里面使用學(xué)生數(shù)據(jù)ThreadDemo類:用戶線程,等會開啟兩個生產(chǎn)者所在的線程/消費(fèi)者所在的線程Object notify() 方法用于喚醒一個在此對象監(jiān)視器上等待的線程wait()+notify() 也算Java同步機(jī)制--->必須使用鎖對象調(diào)用方法

例子老師-改進(jìn)版

public class Student {String name ; //姓名int age ; //年齡boolean flag ; //false,沒有數(shù)據(jù),true,有數(shù)據(jù)! } public class SetThread implements Runnable{private Student s ;public SetThread(Student s){this.s = s ;}private int x = 0 ;//統(tǒng)計變量@Overridepublic void run() {while(true){synchronized (s){ //鎖對象,任意Java類對象//加入一個判斷if(s.flag){//沒有數(shù)據(jù),先產(chǎn)生數(shù)據(jù),等待消費(fèi)使用數(shù)據(jù)//線程等待--Object類---->wait()try {s.wait();//wait方法調(diào)用,立即釋放鎖} catch (InterruptedException e) {e.printStackTrace();}}//創(chuàng)建學(xué)生對象// Student s = new Student() ;if(x % 2==0){s.name = "高圓圓" ;s.age = 44 ;}else {s.name = "李國棟";s.age = 23 ;}//如果有數(shù)據(jù)了,通知(喚醒)消費(fèi)者資源來,趕緊來消費(fèi)(改變信號)s.flag = true ;s.notify() //通知(喚醒)消費(fèi)者}x ++ ;}} } public class GetThread implements Runnable{//聲明學(xué)生變量private Student s ;public GetThread(Student s){this.s = s ;}@Overridepublic void run() {while(true){synchronized (s){//加入判斷if(!s.flag){//有數(shù)據(jù)了,等待先使用這個數(shù)據(jù)try {s.wait();//wait方法調(diào)用,立即釋放鎖} catch (InterruptedException e) {e.printStackTrace();}}//使用學(xué)生學(xué)生//Student s = new Student() ;System.out.println(s.name.concat(""+s.age));//當(dāng)flag是一個false,沒有數(shù)據(jù)了,通知(喚醒)生產(chǎn)者所在的線程,來產(chǎn)生數(shù)據(jù)!s.flag = false ;s.notify();//通知(喚醒)生產(chǎn)者}}} } public class ThreadDemo {public static void main(String[] args) {//創(chuàng)建學(xué)生對象Student s = new Student() ;//創(chuàng)建資源類SetThread st = new SetThread(s) ;GetThread gt = new GetThread(s) ;//創(chuàng)建兩個線程Thread t1 = new Thread(st) ;Thread t2 = new Thread(gt) ;//啟動線程t1.start() ;t2.start() ;} }

Lock–>鎖定操作

jdk5以后提供了具體的"鎖定操作"java.u til.concurrent.l cks.Lock接口---->可重入的互斥鎖 ReentrantLock 提供一些方法,可以獲取鎖,可以去釋放鎖void lock() 獲取鎖void unlock()釋放鎖finally除是一種特例:在執(zhí)行finally語句之前,jvm退出 System.exit(0) ; ,任何情況下,finally語句一定會執(zhí)行!//使用完,釋放鎖

例子

import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;/*** 資源類*/ public class SellTicket implements Runnable {//100張票private static int tickets = 100 ;//之前:鎖對象可以是任意Java類對象,現(xiàn)在jdk提供Lock具體的鎖----ReetrantLock子實(shí)現(xiàn)類private Lock lock = new ReentrantLock() ;@Overridepublic void run() {//模擬一直有票while(true){try{//獲取鎖// void lock() 獲取鎖// synchronized (自定義一個鎖){}lock.lock();if(tickets>0){try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"張票");}}finally {lock.unlock();}}} }* 電影院三個窗口賣票---使用Lock解決多線程安全問題----和synchronized是同樣的語義*/ public class LockDemo {public static void main(String[] args) {//創(chuàng)建資源類SellTicket st = new SellTicket() ;//創(chuàng)建三個線程,代表三個窗口Thread t1 = new Thread(st,"窗口1") ;Thread t2 = new Thread(st,"窗口2") ;Thread t3 = new Thread(st,"窗口3") ;//啟動線程t1.start() ;t2.start() ;t3.start() ;} }

線程池

可以通過Executors工廠類(當(dāng)前類構(gòu)造方法私有化,對外提供靜態(tài)方法--->簡單工廠模式)提供一些創(chuàng)建線程池的功能可以創(chuàng)建固定的可重用的線程數(shù)的線程池public static ExecutorService newFixedThreadPool(int nThreads):參數(shù)為當(dāng)前的線程數(shù)量上面的返回值ExecutorService接口提供一些方法Future<?> submit(Runnable task)提交異步任務(wù)<T> Future<T> submit(Callable<T> task):提交異步任務(wù)void shutdown():關(guān)閉線程池

例子老師

import java.util.concurrent.Callable;/*** 自定義類實(shí)現(xiàn)Callable:完成異步計算*/ public class MyCallable implements Callable<Object> {@Overridepublic Object call() throws Exception {for(int x = 0 ; x < 200 ; x++){System.out.println(Thread.currentThread().getName()+":"+x);}return null;} } public class MyRunnable implements Runnable{@Overridepublic void run() {for(int x = 0 ; x < 100 ; x++){System.out.println(Thread.currentThread().getName()+":"+x) ;}} } public class ExecutorsDemo {public static void main(String[] args) {//創(chuàng)建線程池---創(chuàng)建固定的可重用的線程數(shù)的線程池 // public static ExecutorService newFixedThreadPool(int nThreads):參數(shù)為當(dāng)前的線程數(shù)量ExecutorService threadPool = Executors.newFixedThreadPool(2);MyCallable myCallable = new MyCallable() ;threadPool.submit(myCallable) ;threadPool.submit(myCallable) ;// void shutdown():關(guān)閉線程池threadPool.shutdown();}}

兩條線程求1-100和1-200的和

/*** 需求:使用線程池的方式完成多個線程的異步計算:* 1個線程求1-100的和* 另一個線程求1-200的和** 1)創(chuàng)建線程池:固定的可重用的線程數(shù)的線程池* 2)提交異步任務(wù)<T> Future<T> submit(Callable<T> task):提交異步任務(wù)* 返回值:Future接口:代表異步計算的結(jié)果* V get():獲取計算的結(jié)果*/ package com.qf.executor_07;import com.qf.executors_06.MyCallable;import java.util.concurrent.Callable;/*** 異步任務(wù)*/ public class MySelfCallable implements Callable<Integer> {private int number ;public MySelfCallable(int number){ //100或者200this.number = number ;}@Overridepublic Integer call() throws Exception {//定義一個最終結(jié)果變量int sum = 0 ;for(int x = 1; x <= number ;x++){sum += x ;}return sum;} }import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future;public class Test {public static void main(String[] args) throwsExecutionException, InterruptedException {//1)創(chuàng)建線程池:固定的可重用的線程數(shù)的線程池ExecutorService threadPool = Executors.newFixedThreadPool(2);//2)提交異步任務(wù)//<T> Future<T> submit(Callable<T> task):Future<Integer> f1 = threadPool.submit(new MySelfCallable(100));Future<Integer> f2 = threadPool.submit(new MySelfCallable(200));System.out.println(f1.get());System.out.println(f2.get());//3)關(guān)閉線程池threadPool.shutdown();} }

面試題必問–> 線程池5個創(chuàng)建方式以及7大參數(shù)

線程池

線程是稀有資源，系統(tǒng)頻繁創(chuàng)建會很大程度上影響服務(wù)器的使用效率，如果不加以限制，很容易就會把服務(wù)器資源耗盡。所以，我們可以通過創(chuàng)建線程池來管理這些線程，提升對線程的使用率 簡而言之，線程池就是管理線程的一個容器，有任務(wù)需要處理時，會相繼判斷核心線程數(shù)是否還有空閑、線程池中的任務(wù)隊(duì)列是否已滿、是否超過線程池大小，然后調(diào)用或創(chuàng)建線程或者排隊(duì)，線程執(zhí)行完任務(wù)后并不會立即被銷毀，而是仍然在線程池中等待下一個任務(wù)，如果超過存活時間還沒有新的任務(wù)就會被銷毀，通過這樣復(fù)用線程從而降低開銷。

線程池5個創(chuàng)建方式

1.newCachedThreadPool

創(chuàng)建一個可根據(jù)需要創(chuàng)建新線程的線程池，但是在以前構(gòu)造的線程可用時將重用它們，并在需要時使用提供的 ThreadFactory 創(chuàng)建新線程。 特征： （1）線程池中數(shù)量沒有固定，可達(dá)到最大值（Interger. MAX_VALUE） （2）線程池中的線程可進(jìn)行緩存重復(fù)利用和回收（回收默認(rèn)時間為1分鐘） （3）當(dāng)線程池中，沒有可用線程，會重新創(chuàng)建一個線程 通過： Executors.newCachedThreadPool();創(chuàng)建線程池

2.newFixedThreadPool

創(chuàng)建一個可重用固定線程數(shù)的線程池，以共享的無界隊(duì)列方式來運(yùn)行這些線程。在任意點(diǎn)，在大多數(shù) nThreads 線程會處于 處理任務(wù)的活動狀態(tài)。如果在所有線程處于活動狀態(tài)時提交附加任務(wù)，則在有可用線程之前，附加任務(wù)將在隊(duì)列中等待。 如果在關(guān)閉前的執(zhí)行期間由于失敗而導(dǎo)致任何線程終止，那么一個新線程將代替它執(zhí)行后續(xù)的任務(wù)（如果需要）。在某個 線程被顯式地關(guān)閉之前，池中的線程將一直存在 特征： （1）線程池中的線程處于一定的量，可以很好的控制線程的并發(fā)量 （2）線程可以重復(fù)被使用，在顯示關(guān)閉之前，都將一直存在 （3）超出一定量的線程被提交時候需在隊(duì)列中等待 創(chuàng)建方式 (1）Executors.newFixedThreadPool(int nThreads)；//nThreads為線程的數(shù)量 //nThreads為線程的數(shù)量，threadFactory創(chuàng)建線程的工廠方式 （2）Executors.newFixedThreadPool(int nThreads，ThreadFactory threadFactory)；

3.newSingleThreadExecutor

創(chuàng)建一個使用單個 worker 線程的 Executor，以無界隊(duì)列方式來運(yùn)行該線程。（注意，如果因?yàn)樵陉P(guān)閉前的執(zhí)行期間出現(xiàn) 失敗而終止了此單個線程，那么如果需要，一個新線程將代替它執(zhí)行后續(xù)的任務(wù)）。可保證順序地執(zhí)行各個任務(wù)，并且在 任意給定的時間不會有多個線程是活動的。與其他等效的 newFixedThreadPool不同，可保證無需重新配置此方法所返回 的執(zhí)行程序即可使用其他的線程。 特征： （1）線程池中最多執(zhí)行1個線程，之后提交的線程活動將會排在隊(duì)列中以此執(zhí)行 創(chuàng)建方式： （1）Executors.newSingleThreadExecutor() ； // threadFactory創(chuàng)建線程的工廠方式 （2）Executors.newSingleThreadExecutor(ThreadFactory threadFactory)；

4.newScheduleThreadPool

創(chuàng)建一個線程池，它可安排在給定延遲后運(yùn)行命令或者定期地執(zhí)行 特征： （1）線程池中具有指定數(shù)量的線程，即便是空線程也將保留 （2）可定時或者延遲執(zhí)行線程活動 創(chuàng)建方式： （1）Executors.newScheduledThreadPool(int corePoolSize)；// corePoolSize線程的個數(shù) （2）newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)；// corePoolSize線程的個數(shù)， threadFactory創(chuàng)建線程的工廠

5.newSingleThreadScheduledExecutor

創(chuàng)建一個單線程執(zhí)行程序，它可安排在給定延遲后運(yùn)行命令或者定期地執(zhí)行。 特征： （1）線程池中最多執(zhí)行1個線程，之后提交的線程活動將會排在隊(duì)列中以此執(zhí)行 （2）可定時或者延遲執(zhí)行線程活動 創(chuàng)建方式： （1）Executors.newSingleThreadScheduledExecutor() ； //threadFactory創(chuàng)建線程的工廠 （2）Executors.newSingleThreadScheduledExecutor(ThreadFactory threadFactory)

ThreadPoolExecutor它的構(gòu)造方法涉及的相關(guān)參數(shù)

1.corePoolSize

核心線程數(shù)：是指線程池中長期存活的線程數(shù). 這就好比古代大戶人家，會長期雇傭一些“長工”來給他們干活，這些人一般比較穩(wěn)定，無論這一年的活多活少，這些人都不會被辭退，都是長期生活在大戶人家的

2.maximumPoolSize

最大線程數(shù)：線程池允許創(chuàng)建的最大線程數(shù)量，當(dāng)線程池的任務(wù)隊(duì)列滿了之后，可以創(chuàng)建的最大線程數(shù) 這是古代大戶人家最多可以雇傭的人數(shù)，比如某個節(jié)日或大戶人家有人過壽時，因?yàn)榛钐?#xff0c;僅靠“長工”是完不成任務(wù)，這時就會再招聘一些“短工”一起來干活，這個最大線程數(shù)就是“長工”+“短工”的總?cè)藬?shù)，也就是招聘的人數(shù)不能超過 maximumPoolSize。最大線程數(shù) maximumPoolSize 的值不能小于核心線程數(shù) corePoolSize，否則在程序運(yùn)行時會報 IllegalArgumentException 非法參數(shù)異常

3.keepAliveTime

空閑線程存活時間，當(dāng)線程池中沒有任務(wù)時，會銷毀一些線程，銷毀的線程數(shù)=maximumPoolSize（最大線程數(shù)）- corePoolSize（核心線程數(shù) 當(dāng)大戶人家比較忙的時候就會雇傭一些“短工”來干活，但等干完活之后，不忙了，就會將這些“短工”辭退掉，而 keepAliveTime 就是用來描述沒活之后，短工可以在大戶人家待的（最長）時間

4.TimeUnit

時間單位：空閑線程存活時間的描述單位

5.BlockingQueue

阻塞隊(duì)列：線程池存放任務(wù)的隊(duì)列，用來存儲線程池的所有待執(zhí)行任務(wù)。 它可以設(shè)置以下幾個值：ArrayBlockingQueue：一個由數(shù)組結(jié)構(gòu)組成的有界阻塞隊(duì)列。LinkedBlockingQueue：一個由鏈表結(jié)構(gòu)組成的有界阻塞隊(duì)列。SynchronousQueue：一個不存儲元素的阻塞隊(duì)列，即直接提交給線程不保持它們。PriorityBlockingQueue：一個支持優(yōu)先級排序的無界阻塞隊(duì)列。DelayQueue：一個使用優(yōu)先級隊(duì)列實(shí)現(xiàn)的無界阻塞隊(duì)列，只有在延遲期滿時才能從中提取元素LinkedTransferQueue：一個由鏈表結(jié)構(gòu)組成的無界阻塞隊(duì)列。與SynchronousQueue類似，還含有非阻塞方法。LinkedBlockingDeque：一個由鏈表結(jié)構(gòu)組成的雙向阻塞隊(duì)列。

6.ThreadFactory

線程工廠：線程池創(chuàng)建線程時調(diào)用的工廠方法，通過此方法可以設(shè)置線程的優(yōu)先級、線程命名規(guī)則以及線程類型（用戶線 程還是守護(hù)線程）等。

7.RejectedExecutionHandler

拒絕策略：當(dāng)線程池的任務(wù)超出線程池隊(duì)列可以存儲的最大值之后，執(zhí)行的策略. 默認(rèn)的拒絕策略有以下 4 種：AbortPolicy：拒絕并拋出異常。CallerRunsPolicy：使用當(dāng)前調(diào)用的線程來執(zhí)行此任務(wù)。DiscardOldestPolicy：拋棄隊(duì)列頭部（最舊）的一個任務(wù)，并執(zhí)行當(dāng)前任務(wù)。DiscardPolicy：忽略并拋棄當(dāng)前任務(wù)。 線程池的默認(rèn)策略是 AbortPolicy 拒絕并拋出異常

解決死鎖—>同步中使用 "生產(chǎn)者-消費(fèi)者"思想

出現(xiàn)死鎖原因:多個線程加入同步鎖之后,線程互相之間持有對方的鎖,每一個線程必須讓對方釋放鎖之后,才能去使用同步中的內(nèi)容,導(dǎo)致線程之間出現(xiàn)互相等待!(訪問的資源不是同一個資源)wait()+notify():這個兩個必須在synchronzied使用(同步代碼塊或者同步方法) 使用"信號燈法"來解決死鎖問題

2.面試題: sleep和wait方法區(qū)別?

1)使用區(qū)別:sleep()單獨(dú)使用,里面?zhèn)魅氤瑫r時間,wait()不能單獨(dú)用,必須在同步代碼塊/同步方法中使用,否則,就會出現(xiàn) java.lang.IllegalMonitorStateException 2)來源不同sleep(long time)線程睡眠,來源于Thread類中,wait()來源于Object類中 3)導(dǎo)致線程狀態(tài)不同sleep(long time)參數(shù)出入的超時時間,時間到達(dá),線程睡眠接收,線程會繼續(xù)執(zhí)行,在休眠過程中,線程處于的狀態(tài)是TIMED_WAITTING(超時等待)wait() 線程進(jìn)入等待狀態(tài),如果沒有鎖對象調(diào)用notify()或則notifyAll(),線程狀態(tài)就進(jìn)入到WAITTING(死死等待) 4)是否主動喚醒sleep(long time):時間到達(dá)之后,自動喚醒(主動喚醒),而wait(),被動喚醒,需要使用notify()或者notifyAll進(jìn)行喚醒 5)是否會釋放鎖sleep()方法不會去釋放鎖,wait()方法調(diào)用會立即釋放鎖

3.線程池

線程的好處:1)提高了線程使用率2)大大減少資源開銷4)可以通過一些參數(shù)(7大參數(shù))進(jìn)行線程池的調(diào)優(yōu),到達(dá)一些效果 弊端:維護(hù)成本大可以通過線程池---->Executors工廠類提供很多靜態(tài)方法 public static ExecutorService newFixedThreadPool(int nThreads):創(chuàng)建固定的可重用的線程數(shù)的線程池ExecutorService子實(shí)現(xiàn)類=--- TreadPoolExecutor完成線程池初始化! 如果涉及到定期讓線程進(jìn)行活動(public static ScheduledExecutorService newScheduledThreadPool)

單例

單例設(shè)計模式---屬于創(chuàng)建型設(shè)計模式(創(chuàng)建對象) 概念:始終在內(nèi)存中有且僅有一個當(dāng)前類的實(shí)例!(有一個對象)

餓漢式

不會出現(xiàn)安全問題的單例設(shè)計模式1)當(dāng)前類是具體類2)類一加載就創(chuàng)建當(dāng)前類實(shí)例3)構(gòu)造私有化,對外隱藏,不能new實(shí)例4)對外提供靜態(tài)方法,返回值當(dāng)前類本身Java中的類Runtime類:標(biāo)準(zhǔn)的單例(餓漢式),和計算機(jī)的運(yùn)行環(huán)境有關(guān)系

例子

package SinglePattern;import java.io.IOException; //餓漢式 class Student{//靜態(tài)實(shí)例:Student一加載,就創(chuàng)建當(dāng)前類實(shí)例private static Student s=new Student();//對外不能newprivate Student(){}//對外提供靜態(tài)的方法,返回值是當(dāng)前類本身public static Student getStudent(){return s;} } public class Test1 {public static void main(String[] args) throws IOException {Student s1=Student.getStudent();Student s2=Student.getStudent();System.out.println(s1==s2);//true//創(chuàng)建Runtime實(shí)例:獲取運(yùn)行環(huán)境Runtime runtime = Runtime.getRuntime();//availableProcessors()獲取cpu處理器的數(shù)量System.out.println(runtime.availableProcessors());//exec(String dos指令)System.out.println(runtime.exec("calc"));//打開計算器指令} }

懶漢式

可能存在安全問題的一種單例模式1)當(dāng)前類是個具體類2)當(dāng)前類構(gòu)造方法私有化3)當(dāng)前類的成員位置:聲明當(dāng)前類的一個靜態(tài)變量4)對外提供靜態(tài)方法,返回值是當(dāng)前類本身:需要判斷當(dāng)前變量是否為null現(xiàn)實(shí)開發(fā)業(yè)務(wù)中:存在懶加載(按需加載)一個用戶有多個賬戶: 一對多 (從用戶維度去看賬戶) ,查詢用戶的時候,開啟懶加載方式(針對用戶用哪個賬戶查詢哪個賬戶)賬戶的維度去看用戶:一個賬戶從屬于某個用戶的 一對一

例子

package SinglePattern; //懶漢式class Teacher{//聲明靜態(tài)變量,t的類型Teacherprivate static Teacher t;//構(gòu)造方法私有化:private Teacher(){}public static synchronized Teacher getInstance(){if(t==null){t=new Teacher();}return t;} } public class Test2 {public static void main(String[] args) {Teacher t1 = Teacher.getInstance();Teacher t2 = Teacher.getInstance();System.out.println(t2==t1);//tre} }

File

java.io.File--->表示文件或者文件夾(目錄)一種抽象路徑形式 構(gòu)造方法:File(File parent, String child)從父抽象路徑名和子路徑名字符串創(chuàng)建新的 File實(shí)例。File(String pathname)通過將給定的路徑名字符串轉(zhuǎn)換File(String parent, String child) 父路徑名字符串和子路徑名字符串創(chuàng)建新的 File實(shí)例

例子

import java.io.File; import java.io.IOException;public class FileDemo {public static void main(String[] args) throws IOException {//描述:D盤下的demo文件夾中的a.txt文件//File(String parent, String child)File file = new File("D:\\demo","a.txt") ;System.out.println(file);System.out.println("----------------------------------------") ;//File(File parent, String child)File file2 = new File("D:\\demo") ;File file3 = new File(file2,"a.txt") ;System.out.println(file3);System.out.println("----------------------------------------") ;//File(String pathname)(推薦)File file4 = new File("D:\\EE_2302\\day26\\code\\a.txt") ;System.out.println(file4.createNewFile()) ;//創(chuàng)建文件System.out.println(file4);} }

File的基本功能以及特有功能：

public boolean createNewFile() throws IOException:創(chuàng)建文件public boolean mkdir():創(chuàng)建文件夾public boolean mkdirs():創(chuàng)建文件夾,當(dāng)父目錄不存在,自動創(chuàng)建public boolean delete():刪除文件夾或則文件路徑,如果是文件夾,必須是空目錄public boolean exists():判斷此路徑名表示的文件或者目錄是否存在public boolean isDirectory():此抽象路徑名表示的文件是否是目錄public boolean isFile():是否是文件public boolean isHidden():是否隱藏特有功能:高級功能public String[] list():獲取指定抽象路徑名表示的文件或者目錄的名稱(返回字符串?dāng)?shù)組)public File[] listFiles():獲取指定路徑名表示的文件或者目錄的File數(shù)組

例子老師

import java.io.File; import java.io.IOException; import java.util.Arrays;public class FileDemo2 {public static void main(String[] args) throws IOException {//在創(chuàng)建D:\EE_2302\day26\code\demo文件夾//表示它的路徑File file = new File("D:\\EE_2302\\day26\\code\\demo") ;//public boolean mkdir():創(chuàng)建文件夾System.out.println(file.mkdir());System.out.println("--------------------------------") ;//public boolean mkdirs():創(chuàng)建文件夾,當(dāng)父目錄不存在,自動創(chuàng)建//創(chuàng)建aaa\bbb\ccc 多級目錄(直接指定具體文件夾或者文件,相對路徑創(chuàng)建)File file2 = new File("aaa\\bbb\\ccc") ;System.out.println(file2.mkdirs());System.out.println("---------------------------------") ;File file3 = new File("a.txt") ;//創(chuàng)建文件System.out.println(file3.createNewFile());System.out.println("--------------------------------");System.out.println(file3.exists());System.out.println(file3.isDirectory());System.out.println(file3.isFile());System.out.println(file3.isHidden());System.out.println(file3.canRead());System.out.println(file3.canWrite());System.out.println("-----------------------------------");//public String[] list():獲取指定抽象路徑名表示的文件或者目錄的名稱(返回字符串?dāng)?shù)組)//public File[] listFiles():獲取指定路徑名表示的文件或者目錄的File數(shù)組//描述D盤---所有的文件夾以及文件的名稱 獲取到File myFile = new File("d:\\") ;String[] strs = myFile.list() ;if(strs!=null){for (String str : strs) {System.out.println(str);}//System.out.println(Arrays.toString(strs));}System.out.println("----------------------------------------------") ;File[] files = myFile.listFiles();//防止空指針if(files!=null){for (File f : files) {//獲取當(dāng)前File對象所表示的文件夾以及文件的名稱 --public String getName()System.out.println(f.getName());}}} }

經(jīng)典案例

獲取".jpg"結(jié)尾的文件

方案1

import java.io.File; public class FileTest {public static void main(String[] args) {//1)描述D盤---使用File對象File file = new File("D:\\") ;//2)通過 public File[] listFiles() :獲取指定路徑下所有的文件以及文件夾的File數(shù)組File[] files = file.listFiles();if(files!=null){for (File f : files) {//f:代表File對象//判斷是否是文件if(f.isFile()){//滿足是文件//獲取文件名稱,以".jpg"結(jié)尾if(f.getName().endsWith(".jpg")){//輸出文件名稱System.out.println(f.getName());}}}}} }

方案2

package IO_File; import java.io.File; public class FilenameFilter {public static void main(String[] args) {File file = new File("D:\\個人東西");String[] list = file.list(new FilenameFilter() {@Overridepublic boolean accept(File dir, String name) {File file1 = new File(dir, name);boolean file2 = file1.isFile();boolean file3 = file1.getName().endsWith("jpg");return file2&&file3;}});if(list!=null){for(String list1:list){System.out.println(list1);}}} }

方案3（方案2改良版）

package IO_File; import java.io.File; public class FilenameFilter {public static void main(String[] args) {File file = new File("D:\\個人東西");String[] list = file.list(new java.io.FilenameFilter() {@Overridepublic boolean accept(File dir, String name) {File file1 = new File(dir, name);return file1.isFile() && file1.getName().endsWith(".jpg");}});if(list!=null){for(String list1:list){System.out.println(list1);}}} }

IO流

I:InputO : Output流的定義：流是指一連串流動的字符。以先進(jìn)先出方式發(fā)送信息的通道。字節(jié)流是 8 位通用字節(jié)流，字符流是16位Unicode字符流

字節(jié)流

java.io.InputStream 字節(jié)輸入流 java.io.OutputStream 字節(jié)輸出流

字符流

java.io.Writer 字符輸出流 java.io.Reader 字符輸入流

出寫入讀

都是抽象類。

1.**文件**（File）java.io.FileInputStream java.io.FileOutputStream java.io.FileReaderjava.io.FileWriter2.**轉(zhuǎn)換流**：(將字節(jié)流轉(zhuǎn)換成字符流)java.io.InputStreamReader java.io.OutputStreamWriter3.**緩沖流**java.io.BufferedReaderjava.io.BufferedWriterjava.io.BufferedInputStreamjava.io.BufferedOutputStream4.**數(shù)據(jù)流**java.io.BufferedOutputStreamjava.io.DataOutputStream5.**標(biāo)準(zhǔn)輸出流**java.io.PrintWriterjava.io.PrintStream6.**對象專屬流**java.io.ObjectInputStream java.io.ObjectOutputStream 7.**File文件類**java.io.File

字節(jié)輸出流

OutputStream--抽象的 ---具體的子類針對文件操作:FileOutputStream 步驟1）創(chuàng)建字節(jié)輸出流對象2）寫數(shù)據(jù)3）釋放資源基本功能//void write(byte[] b):寫字節(jié)數(shù)組//void write(byte[] b, int off, int len):寫字節(jié)數(shù)組一部分//abstract void write(int b) 寫一個字節(jié)//釋放資源:將流對象指向的文件地址的系統(tǒng)資源進(jìn)行釋放fos.close() ;

例子

package FileOutputStreamDemo; import java.io.FileOutputStream; import java.io.IOException;public class Test4 {public static void main(String[] args) throws IOException {FileOutputStream fos = new FileOutputStream("fos.txt");//寫數(shù)據(jù)//abstract void write(int b) 寫一個字節(jié)fos.write(100);//void write(byte[] b):寫字節(jié)數(shù)組byte[] bytes = {98,99,100,101,102,103,104} ;fos.write(bytes);//void write(byte[] b, int off, int len):寫字節(jié)數(shù)組一部分fos.write(bytes, 0, 3);//釋放資源 將流對象指向的文件地址的系統(tǒng)資源進(jìn)行釋放fos.close();} } 效果： dbcdefghbcd

字節(jié)數(shù)追加

字節(jié)輸出流:FileOutputStream實(shí)現(xiàn)文件的字節(jié)數(shù)追加public FileOutputStream(String name,boolean append)throws FileNotFoundException第二個參數(shù)是true:自動追加內(nèi)容IO流寫數(shù)據(jù),實(shí)現(xiàn)換行效果 widows系統(tǒng) "\r\n"

例子

package FileOutputStreamDemo; import java.io.FileOutputStream; import java.io.IOException; public class Test5 {public static void main(String[] args) throws IOException {FileOutputStream ttx = new FileOutputStream("ttx.txt");ttx.write("hello".getBytes());System.out.println(ttx);for(int x=0;x<10;x++){ttx.write(("world"+x).getBytes());ttx.write("\r\n".getBytes());}ttx.close();} } 效果： helloworld0 world1 world2 world3 world4 world5 world6 world7 world8 world9

字節(jié)輸入流

InputStream:字節(jié)輸入流--->抽象類--->具體的子類FileInputStream:文件字節(jié)輸入流1)創(chuàng)建文件字節(jié)輸入流對象FileInputStream(String name) :讀取指定的文件 name:文件地址2)讀數(shù)據(jù)繼承它父類的方法:public abstract int read()throws IOException:一次讀取一個字節(jié)public int read(byte[] b) throws IOException:一次讀取一個字節(jié)數(shù)組需求:使用字節(jié)輸入流將當(dāng)前項(xiàng)目下的"fis.txt"文件內(nèi)容讀取出來打印在控制臺上一次讀取一個字節(jié)的方式:針對中文---會出現(xiàn)亂碼 (char)字節(jié)數(shù),平臺默認(rèn)編碼格式utf-8:一個中文對應(yīng)三個字節(jié)英文字母和中文-拼接一塊,一個英文字母對應(yīng)一個字節(jié),這個時候拼接不上,導(dǎo)致文亂碼---Java提供"字符流",解決亂碼

老師例子

package com.qf.io_04_fileinputStream;import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException;/*** InputStream:字節(jié)輸入流--->抽象類--->具體的子類FileInputStream:文件字節(jié)輸入流* 1)創(chuàng)建文件字節(jié)輸入流對象FileInputStream(String name) :讀取指定的文件 name:文件地址* 2)讀數(shù)據(jù)* 繼承它父類的方法:public abstract int read()throws IOException:一次讀取一個字節(jié)* public int read(byte[] b) throws IOException:一次讀取一個字節(jié)數(shù)組*** 需求:* 使用字節(jié)輸入流將當(dāng)前項(xiàng)目下的"fis.txt"文件內(nèi)容讀取出來打印在控制臺上** 一次讀取一個字節(jié)的方式:* 針對中文---會出現(xiàn)亂碼 (char)字節(jié)數(shù),平臺默認(rèn)編碼格式utf-8:一個中文對應(yīng)三個字節(jié)* 英文字母和中文-拼接一塊,一個英文字母對應(yīng)一個字節(jié),這個時候拼接不上,導(dǎo)致文亂碼---Java提供"字符流",解決亂碼*/ public class FileInputStreamDemo {public static void main(String[] args) {FileInputStream fis = null ;try {//創(chuàng)建文件字節(jié)輸入流對象FileInputStream(String name)//fis = new FileInputStream("fis.txt") ;//讀取當(dāng)前項(xiàng)目下的FileOutputStreamDemo3.java文件,把它內(nèi)容打印控制臺上fis = new FileInputStream("FileOutputStreamDemo3.java") ;//public abstract int read()throws IOException:一次讀取一個字節(jié)//返回值:讀取的實(shí)際字節(jié)數(shù)//第一次讀取/*int by = fis.read() ;System.out.println(by);System.out.println((char)by);System.out.println("---------------------------------------------") ;//第二次讀取by = fis.read() ;System.out.println(by) ;System.out.println((char)by);System.out.println("---------------------------------------------") ;//第三次讀取by = fis.read();System.out.println(by) ;System.out.println((char)by);System.out.println("---------------------------------------------") ;//第四次讀取by = fis.read();System.out.println(by) ;System.out.println((char)by);System.out.println("---------------------------------------------") ;//第五次讀取by = fis.read();System.out.println(by) ; //-1:流對象的內(nèi)容已經(jīng)到達(dá)末尾System.out.println((char)by);*///文件內(nèi)容未知---使用while循環(huán)//循環(huán)條件中---賦值,判斷,一塊使用//定義一個字節(jié)數(shù):從0開始int by = 0 ;while((by=fis.read())!=-1){//將字節(jié)數(shù)by---強(qiáng)轉(zhuǎn)char字符System.out.print((char)by) ;}} catch (IOException e) {e.printStackTrace();} finally {if(fis!=null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}}} }

例子1（老辦法）

package FileInputStreamDemo;import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException;public class Test6 {public static void main(String[] args) {FileInputStream fis=null;try {fis = new FileInputStream("fos.txt");//第一次讀取int by=fis.read();System.out.println(by);System.out.println((char) by);//第2次讀取by=fis.read();System.out.println(by);System.out.println((char) by);//第3次讀取by=fis.read();System.out.println(by);System.out.println((char) by);//第4次讀取by=fis.read();System.out.println(by);System.out.println((char) by);//第5次讀取by=fis.read();System.out.println(by);System.out.println((char) by);} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}} 結(jié)果： 100 d 98 b 99 c 100 d 101 e fos.txt:dbcdefghbcd(內(nèi)容是這個 讀取這個txt文檔)

例子2（改良的）一次輸入一個字節(jié)

package FileInputStreamDemo;import java.io.FileInputStream; import java.io.IOException;public class Test7 {public static void main(String[] args) {FileInputStream fis = null ;try {fis = new FileInputStream("Test6.java") ;int by = 0 ;while((by=fis.read())!=-1){//將字節(jié)數(shù)by---強(qiáng)轉(zhuǎn)char字符System.out.print((char)by) ;}} catch (IOException e) {e.printStackTrace();} finally {if(fis!=null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}}} }

使用字節(jié)輸入流一次讀取一個字節(jié)數(shù)組的方式:

public int read(byte[] b) throws IOException:一次讀取一個字節(jié)數(shù)組

例子（老版本）

package FileInputStreamDemo;import java.io.FileInputStream; import java.io.IOException; //字節(jié)流一次讀取一個字節(jié)數(shù)組 public class Test8 {public static void main(String[] args) throws IOException {FileInputStream fia = new FileInputStream("fia.txt");byte[] bytes=new byte[5];// public int read(byte[] b)--->返回:讀取的字節(jié)數(shù)組的長度int len = fia.read(bytes);System.out.println(len);//5System.out.println("------");//byte數(shù)組轉(zhuǎn)成String//每一次是從0開始讀取實(shí)際字節(jié)數(shù)System.out.println(new String(bytes,0,len));//helloSystem.out.println("------");len=fia.read(bytes) ;System.out.println(len);System.out.println//windows系統(tǒng)換行符號\r\n(new String(bytes,0,len));//Wor "\r\n"占了兩個字符System.out.println("------");len=fia.read(bytes) ;System.out.println(len);System.out.println (new String(bytes,0,len));//ld--//JSystem.out.println("------");len=fia.read(bytes) ;System.out.println(len);System.out.println (new String(bytes,0,len));} }fia: Hello World Java 輸出結(jié)果 5 ------ Hello ------ 5Wor ------ 5 ld J ------ 5 ava

例子（最終效果）

package FileInputStreamDemo;import java.io.FileInputStream; import java.io.IOException;//創(chuàng)建一個字節(jié)緩沖區(qū)（長度是1024或者1024的整數(shù)倍） public class Test9 {public static void main(String[] args) throws IOException {FileInputStream fia = new FileInputStream("fia.txt");byte[] bytes=new byte[1024];//實(shí)際字節(jié)數(shù)從0開始int len=0;while((len=fia.read(bytes)) !=-1){//如果沒有字節(jié)內(nèi)容可讀。到達(dá)末尾，返回值為-1String s = new String(bytes, 0, len);System.out.println(s);/*HelloWorldJava */}} } 結(jié)果：HelloWorldJava

例子（最終效果）2

package FileInputStreamDemo;import java.io.FileInputStream; import java.io.IOException;//創(chuàng)建一個字節(jié)緩沖區(qū)（長度是1024或者1024的整數(shù)倍） public class Test9 {public static void main(String[] args) throws IOException {FileInputStream fia = new FileInputStream("Test6.java");byte[] bytes=new byte[1024];//實(shí)際字節(jié)數(shù)從0開始int len=0;while((len=fia.read(bytes)) !=-1){//如果沒有字節(jié)內(nèi)容可讀。到達(dá)末尾，返回值為-1String s = new String(bytes, 0, len);System.out.println(s);/*HelloWorldJava */}} } Test6內(nèi)容是一段代碼 讀取這段代碼輸出的中文不是亂碼 為什么呢 因?yàn)檫@次沒有強(qiáng)轉(zhuǎn)char而是讀取的實(shí)際字節(jié) 字符串

Copy例子

public class CopyMp4 {public static void main(String[] args) {long start = System.currentTimeMillis() ;//共耗時:222564毫秒//copyMp4("myavi.mp4","D:\\EE_2302\\day26\\code\\copy.mp4");//共耗時:356毫秒copyMp4_2("myavi.mp4","D:\\EE_2302\\day26\\code\\copy.mp4");long end = System.currentTimeMillis() ;System.out.println("共耗時:"+(end-start)+"毫秒");}/*** 使用字節(jié)輸入流一讀取一個字節(jié)的方式,進(jìn)行文件復(fù)制* @param srcFile 源文件地址* @param destFile 目標(biāo)文件地址*/public static void copyMp4(String srcFile, String destFile) {FileInputStream fis = null ;FileOutputStream fos = null ;try {//創(chuàng)建字節(jié)輸入流操作srcFilefis = new FileInputStream(srcFile) ;//創(chuàng)建字節(jié)輸出流對象操作destFilefos = new FileOutputStream(destFile) ;//一次讀取一個字節(jié)int by = 0 ;while((by=fis.read())!=-1){//使用字節(jié)輸入流一次一個字節(jié),使用fos輸出流對象寫一個字節(jié)fos.write(by) ; //不需要強(qiáng)轉(zhuǎn),要的字節(jié)}} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}finally {//釋放資源if(fos!=null){try {fos.close();} catch (IOException e) {e.printStackTrace();}}if(fis!=null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}}} }

一次讀取一個字節(jié)的方式 --代碼體現(xiàn)

//讀寫復(fù)制操作 //D:\\a.txt文件---復(fù)制到 當(dāng)前項(xiàng)目下的E:\\b.txt文件中 //創(chuàng)建字節(jié)輸入流對象--FileInputStream FileInputStream fis = new FileInputStream("d:\\a.txt") ; //字節(jié)輸出流對象 FileOutputStream fos = new FileOutputStream("e:\\b.txt") ; int by = 0 ; while((by=fis.read())!=-1){//讀一個字節(jié),通過fos流對象寫出到b.txt文件中fos.write(by) ; } //釋放資源 fos.close() ; fis.close() ;

一次讀取一個字節(jié)數(shù)組的方式–代碼體現(xiàn)

//讀寫復(fù)制操作 //D:\\a.txt文件---復(fù)制到 當(dāng)前項(xiàng)目下的E:\\b.txt文件中 //創(chuàng)建字節(jié)輸入流對象--FileInputStream FileInputStream fis = new FileInputStream("d:\\a.txt") ; //字節(jié)輸出流對象 FileOutputStream fos = new FileOutputStream("e:\\b.txt") ; //字節(jié)緩沖區(qū) byte[] bytes = new byte[1024] ; int len = 0 ; while((len=fis.read(bytes))!=-1){//給fos流對象寫入(每次從0開始)實(shí)際字節(jié)數(shù)fos.write(bytes,0,len) ; } //釋放資源 fos.close(); fis.close() ;

同步方法的鎖對象和靜態(tài)同步方法的鎖對象?

非靜態(tài)的同步方法---鎖對象---this 靜態(tài)的同步方法鎖對象---鎖對象---類名.class

遞歸例子

package com.qf.digui_01;import java.io.File;/*** 需求:刪除某個磁盤上的帶內(nèi)容的目錄* "D:\EE_2302\day27\code\demo"** 分析:* 1) 描述磁盤上的路徑* 2)定義一個方法:deleteDirectory(File f):遞歸刪除文件夾的方法* 3)方法里面:獲取目錄中的所有的文件夾以及文件的File數(shù)組* File[] listFiles()* 3.1)File數(shù)組不為null* 3.2)遍歷File數(shù)組,獲取到File對象* 3.3)File對象的路徑形式是否是"文件夾"* 滿足條件---回到2)* 否則,是文件* 刪除的同時獲取,這個文件的父類名稱是什么,然后直接刪除--*/ public class DiGuiTest {public static void main(String[] args) {//描述磁盤上的路徑File srcFile = new File("D:\\EE_2302\\day27\\code\\demo") ;//定義遞歸刪除帶內(nèi)容的目錄的方法deleteDirectory(srcFile) ;}public static void deleteDirectory(File destFile) { //傳入的的路徑//獲取目標(biāo)文件夾 中所有的文件以及文件夾的File數(shù)組File[] files = destFile.listFiles();if(files!=null){for(File file:files){//獲取每一個file對象//去判斷if(file.isDirectory()){//是文件夾//調(diào)用遞歸刪除的方法deleteDirectory(file);}else {//是文件,刪除的同時獲取它的父目錄的名稱//public File getParentFile()//System.out.println(file.getParentFile().getName()+"目錄名稱:"+"---->"+file.delete());System.out.println(file.getName()+"目錄名稱:"+"---->"+file.delete());}}System.out.println(destFile.getName()+"----"+destFile.delete());}} }

字符流

字符流:字符輸出流:Writer(抽象類)--->具體的子類 OutputStreamWriter:字符轉(zhuǎn)換輸出流,"可以將字節(jié)輸出流---轉(zhuǎn)換---字符輸出流"構(gòu)造方法:public OutputStreamWriter(OutputStream out):使用平臺默認(rèn)字符集進(jìn)行編碼--輸出數(shù)據(jù)public OutputStreamWriter(OutputStream out,String charsetName):使用指定的字符集進(jìn)行編碼---輸出數(shù)據(jù)寫數(shù)據(jù):void write(char[] cbuf) :寫入字符數(shù)組void write(char[] cbuf,int off,int len ) :寫入字符數(shù)組的一部分void write(int c) :寫一個字符void write(String str) :字符串void write(String str,int off,int len):寫入字符串的一部分

例子

public class OutputStreamWriterDemo {public static void main(String[] args) throws Exception {//創(chuàng)建一個字符轉(zhuǎn)換輸出流對象//utf-8:一個中文對應(yīng)三個字節(jié)/* OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"),"utf-8") ;*/OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"));//寫字符串osw.write("helloworld");osw.write("高圓圓");osw.write(97) ;//寫入字符,傳入?yún)?shù)int--->ASCII碼表對應(yīng)的字符值//釋放資源osw.close();} }

字節(jié)緩沖流

ava之IO流提供了字節(jié)緩沖流:讓讀取的速度更快一些,提供對應(yīng)的類字節(jié)緩沖輸入流/字節(jié)緩沖輸出流 (高效的字節(jié)流)---僅僅是內(nèi)部提供緩沖區(qū)字節(jié)數(shù)組長度:8192長度,文件的讀寫復(fù)制還的依賴于基本字節(jié)流(InputStream/OutputStream)BufferedInputStream(InputStream in):字節(jié)緩沖輸入流BufferedOutputStream(OutputStream out):字節(jié)緩沖輸出流使用字節(jié)緩沖流來完成讀寫復(fù)制---看他們執(zhí)行效率

例子

public class CopyFileTest {public static void main(String[] args) throws IOException {long start = System.currentTimeMillis();copyFile2("myavi.mp4","D:\\EE_2302\\day27\\code\\copy.mp4") ;long end = System.currentTimeMillis() ;System.out.println("共耗時:"+(end-start)+"毫秒");}/*** 使用字節(jié)緩沖輸入流一次讀取一個字節(jié)數(shù)組* @param srcFile 源文件地址* @param destFile 目標(biāo)文件地址*/public static void copyFile2(String srcFile, String destFile) throws IOException {//BufferedInputStream(InputStream in):字節(jié)緩沖輸入流//創(chuàng)建字節(jié)緩沖輸入流對象BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile)) ;// BufferedOutputStream(OutputStream out):字節(jié)緩沖輸出流//創(chuàng)建字節(jié)緩沖輸出流對象BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile)) ;//一次讀取一個字節(jié)數(shù)組byte[] bytes = new byte[1024] ;int len = 0 ;//實(shí)際字節(jié)數(shù)while((len=bis.read(bytes))!=-1){//每次從0開始寫入實(shí)際字節(jié)數(shù)bos.write(bytes,0,len);//使用字節(jié)緩沖輸出流的時候,防止一些字節(jié)數(shù)沒有交給OutputStream字節(jié)輸出流//強(qiáng)制刷新緩沖輸出流(尤其圖片,圖片文件帶有緩沖數(shù)據(jù):可能字節(jié)數(shù)沒有寫入到底層輸出流中,導(dǎo)致圖片文件缺失)bos.flush() ;}//釋放資源bos.close();bis.close();}/*** 使用字節(jié)緩沖輸入流一次讀取一個字節(jié)* @param srcFile 源文件地址* @param destFile 目標(biāo)文件地址*/public static void copyFile(String srcFile, String destFile) throws IOException {//BufferedInputStream(InputStream in):字節(jié)緩沖輸入流//創(chuàng)建字節(jié)緩沖輸入流對象BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile)) ;// BufferedOutputStream(OutputStream out):字節(jié)緩沖輸出流//創(chuàng)建字節(jié)緩沖輸出流對象BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile)) ;//一次讀取一個字節(jié)int by = 0 ;while((by=bis.read())!=-1){//讀取一個字節(jié),寫出一個字節(jié)bos.write(by) ;}//釋放資源bos.close();bis.close();} }

字符輸入流

--->Reader(抽象類)--->具體的子類:字符轉(zhuǎn)換輸入流InputStreamReader --- 將字節(jié)輸入流---->轉(zhuǎn)換--->字符輸入流public InputStreamReader(InputStream in):使用平臺默認(rèn)字符集進(jìn)行解碼---讀取數(shù)據(jù)public InputStreamReader(InputStream in,String charsetName)使用指定字符集解碼---讀取數(shù)據(jù)讀數(shù)據(jù):int read() :一次讀取一個字符 --->返回結(jié)果:實(shí)際的字符數(shù)int read(char[] cbuf) :一次讀取一個字符數(shù)組int read(char[] cbuf,int off, int len):讀取字符數(shù)組的一部分

例子

public class InputStreamReaderDemo {public static void main(String[] args) throws Exception {//創(chuàng)建字符轉(zhuǎn)換輸入流對象//解碼:gbk(中國編碼表): 一個中文對應(yīng)兩個字節(jié)/* InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"),"gbk") ;*///public InputStreamReader(InputStream in)InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt")) ;//讀數(shù)據(jù)//一次讀取一個字符int by = 0 ;//實(shí)際字符數(shù)while((by=isr.read())!=-1){//展示控制臺上 讀取的時候?qū)⑽募?nèi)容的里面--->int類型----->轉(zhuǎn)換成字符System.out.print((char)by);}} }

字符輸出流

字符輸出流:Writer(抽象類)--->具體的子類 OutputStreamWriter:字符轉(zhuǎn)換輸出流,"可以將字節(jié)輸出流---轉(zhuǎn)換---字符輸出流"構(gòu)造方法:public OutputStreamWriter(OutputStream out):使用平臺默認(rèn)字符集進(jìn)行編碼--輸出數(shù)據(jù)public OutputStreamWriter(OutputStream out,String charsetName):使用指定的字符集進(jìn)行編碼---輸出數(shù)據(jù)寫數(shù)據(jù):void write(char[] cbuf) :寫入字符數(shù)組void write(char[] cbuf,int off,int len ) :寫入字符數(shù)組的一部分void write(int c) :寫一個字符void write(String str) :字符串void write(String str,int off,int len):寫入字符串的一部分

例子

public class OutputStreamWriterDemo {public static void main(String[] args) throws Exception {//創(chuàng)建一個字符轉(zhuǎn)換輸出流對象//utf-8:一個中文對應(yīng)三個字節(jié)/* OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"),"utf-8") ;*/OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"));//寫字符串osw.write("helloworld");osw.write("高圓圓");osw.write(97) ;//寫入字符,傳入?yún)?shù)int--->ASCII碼表對應(yīng)的字符值//釋放資源osw.close();} }

鍵盤錄入的第二種方式

0)main方法里面:早期錄入 String[] args1)Scanner(InputStream in)---->Scanner sc = new Scanner(System.in) ;2)new BufferedReader(new InputStreamReader(System.in))--->InputStreamReader(InputStream in)

例子

package JianPanLuRu2;import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader;public class Test3 {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));System.out.println("請您輸入一個數(shù)據(jù):");String line = br.readLine();System.out.println("您輸入的內(nèi)容是:"+line);//數(shù)字字符串--->// int num = Integer.parseInt(line);//輸出數(shù)字字符串// System.out.println("您輸入的內(nèi)容是:"+num);//輸出數(shù)字字符串} }

BufferedReader字符緩沖輸入流

字符緩沖輸入流—可以讀取一行內(nèi)容

構(gòu)造方法:public BufferedReader(Reader in):提供默認(rèn)緩沖區(qū)大小的字符緩沖輸入流 (8192個長度)這個流如果直接操作文件--->參數(shù)里面使用FileReaderpublic String readLine()throws IOException特有功能:public String readLine()throws IOException:一次讀取一行返回值是讀取到這一行的內(nèi)容,當(dāng)流已經(jīng)到達(dá)末尾,則返回null鍵盤錄入1)Scanner(InputStream in)---->Scanner sc = new Scanner(System.in) ;2)new BufferedReader(new InputStreamReader(System.in))--->InputStreamReader(InputStream in)

例子

package BufferredReaderDemo;import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException;public class Test1 {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new FileReader("新建 文本文檔.txt"));String line=null;while((line=br.readLine())!=null){System.out.println(line);}br.close();} } 新建 文本文檔.txt： dajiahao woshi yisanbao

BufferedWriter字符緩沖輸出流

BufferedWriter構(gòu)造方法public BufferedWriter(Writer out):提供默認(rèn)緩沖區(qū)大小的字符緩沖輸出流,默認(rèn)緩沖區(qū)足夠大 8192長度寫的功能:write(字符/字符數(shù)組/字符串...)特有功能:不需要在使用"\r\n"換行符號, public void newLine()寫入行的分隔符

例子

package BufferredWriterDemo;import java.io.BufferedWriter; import java.io.FileWriter; import java.io.IOException;public class Test2 {public static void main(String[] args) throws IOException {BufferedWriter bw = new BufferedWriter(new FileWriter("新建 文本文檔.txt"));for(int x=0;x<=10;x++){bw.write("哈哈"+x);bw.newLine();//換行bw.flush();//刷新}bw.close();} } 新建 文本文檔.txt： 哈哈0 哈哈1 哈哈2 哈哈3 哈哈4 哈哈5 哈哈6 哈哈7 哈哈8 哈哈9 哈哈10

Properties屬性集合列表

java.util.Properties:屬性集合列表---extends Hashtabl<K,V>-->本質(zhì)是Map<K,V>集合添加功能:put(K key,V value)遍歷方式:Set<K> keySet()遍歷鍵-->通過鍵獲取值 V get(K key)自己的特有功能:java.util.Properties:沒有泛型,鍵和值都只能String---->作用:用來讀取配置文件xx .properties配置文件(src下面)構(gòu)造方法:public Properties()添加屬性列表的鍵和值:public Object setProperty(String key,String value)特有的遍歷方式:public Set<String> stringPropertyNames():獲取屬性列表中的所有的鍵(屬性名稱)public String getProperty(String key):通過屬性列表中的屬性名稱獲取對應(yīng)的值

例子

public class PropertiesDemo {public static void main(String[] args) {//創(chuàng)建屬性集合列表Properties prop = new Properties() ;System.out.println(prop);//public Object setProperty(String key,String value)prop.setProperty("張三","30") ;prop.setProperty("李四","25") ;prop.setProperty("王五","35") ;System.out.println(prop);//遍歷// public Set<String> stringPropertyNames():獲取屬性列表中的所有的鍵(屬性名稱)// public String getProperty(String key):通過屬性列表中的屬性名稱獲取對應(yīng)的值Set<String> keySet = prop.stringPropertyNames();for(String key:keySet){String value = prop.getProperty(key);System.out.println(key+"---"+value);}} }

將文件的內(nèi)容加載到屬性集合列表中

java.util.Properties可以保存到流中或從流中加載** 將文件的內(nèi)容加載到屬性集合列表中:* public void load(InputStream inStream/Reader)** 將屬性列表中的內(nèi)容保存到指定文件中* 第二個參數(shù):描述屬性列表* public void store(OutputStream out/Writer,String comments)*

例子

public class PropertiesDemo2 {public static void main(String[] args) throws IOException {// myLoad();myStore() ;}//寫private static void myStore() throws IOException {//將屬性列表中的內(nèi)容---保存指定文件中Properties prop = new Properties() ;//存儲用戶名和密碼prop.setProperty("文章","123") ;prop.setProperty("高圓圓","123456") ;prop.setProperty("admin","admin") ;System.out.println(prop) ;//public void store(OutputStream out/Writer,String comments)prop.store(new FileWriter("D:\\EE_2302\\day27\\code\\day27\\src\\my.properties"),"name'list") ;}private static void myLoad() throws IOException {//創(chuàng)建屬性集合列表Properties prop = new Properties() ;System.out.println(prop);//如何讀取src下面的xx.properties文件//1)獲取當(dāng)前類的字節(jié)碼文件對象--->類名.class 屬性// Class c = PropertiesDemo2.class ;//2)通過獲取到的字節(jié)碼文件對象獲取 當(dāng)前類的加載器// public ClassLoader getClassLoader()// ClassLoader classLoader = c.getClassLoader();//3)ClassLoader---類加載器--->讀取到src下面配置文件的內(nèi)容--->存儲到字節(jié)輸入流中//public InputStream getResourceAsStream(String name) 返回用于讀取指定資源的輸入流//InputStream inputStream = classLoader.getResourceAsStream("name.properties");//一步走InputStream inputStream = PropertiesDemo2.class.getClassLoader().getResourceAsStream("name.properties");//public void load(InputStream inStream/Reader)prop.load(inputStream);System.out.println(prop);} }

文本文件—使用字符流去操作

字符轉(zhuǎn)換流:不能直接操作文件地址,借助于底層流(字節(jié)流),字符轉(zhuǎn)換流提供它的子類 "轉(zhuǎn)換流的便捷類"InputStreamReader讀源文件 ----->FileReader(String pathName)OutputStreamWriter寫目標(biāo)文件---->FileWriter(String pathName)

例子

public class CopyFileTest {public static void main(String[] args) throws IOException {FileReader fr = new FileReader("D:\\EE_2302\\day27\\code\\DiGuiTest.java");FileWriter fw = new FileWriter("copy.java") ;int by = 0 ;while((by=fr.read())!=-1){fw.write(by) ;fw.flush();}fw.close();fr.close();} }

網(wǎng)絡(luò)三要素：

1）IP地址:InetAddress 網(wǎng)絡(luò)中設(shè)備的標(biāo)識，不易記憶，可用主機(jī)名 A類->第一個號段是網(wǎng)絡(luò)號段，后面的是主機(jī)號段（國家政府機(jī)關(guān)）B類->前面兩個號段是網(wǎng)絡(luò)號段，后面的是主機(jī)號段（校園網(wǎng)/公司內(nèi)網(wǎng)等）C類->私人地址，前面的三個都是網(wǎng)絡(luò)號段，后面是主機(jī)號段 "點(diǎn)分十進(jìn)法"2）端口號 用于標(biāo)識進(jìn)程的邏輯地址，不同進(jìn)程的標(biāo)識范圍：0-65535 其中的0-1024是保留端口號，自己指定的端口號是1025-65535（不要和系統(tǒng)的端口號沖突否則報錯->Address already in use :BindException：地址值被占用）3）傳輸協(xié)議通訊的規(guī)則 常見協(xié)議：TCP，UDP TCP/UDP 底層網(wǎng)絡(luò)協(xié)議 UDP：1）不可靠連接，不需要建立連接通道，以"數(shù)據(jù)報包"方式進(jìn)行數(shù)據(jù)傳輸,不安全2）不同步，執(zhí)行效率相對TCP來說高3）發(fā)送數(shù)據(jù)大小有限制！（字節(jié)流形式） TCP:1）可靠連接，需要建立連接通道。2）同步的，執(zhí)行效率低，但是安全性能較UDP高，3）發(fā)送數(shù)據(jù)大小無限制（字節(jié)流形式）

類InetAddress

對IP地址的獲取和操作

獲取任意主機(jī)：getByName() 主機(jī)名：getHostName() 主機(jī)Ip地址：getHostAddress()

例子

package AdressDemo;import java.net.InetAddress; import java.net.UnknownHostException;public class AdressDemo {public static void main(String[] args) throws UnknownHostException {InetAddress address=InetAddress.getByName("鳳梨罐頭");String ip = address.getHostAddress();System.out.println(ip);//10.35.165.80String name = address.getHostName();System.out.println(name);//鳳梨罐頭} }

網(wǎng)絡(luò)編程（Socket編程）

發(fā)送端/客戶端接收端/服務(wù)器端不管UDP還是TCP都要滿足以下條件兩端都必須要有Socket對象（”套接字“）；發(fā)送端或者客戶端必須綁定主機(jī)IP以及端口接收端或者服務(wù)器端必須指定端口號

1.使用UDP協(xié)議發(fā)送數(shù)據(jù)

1）創(chuàng)建發(fā)送端的socket對象2）常見數(shù)據(jù)報包（DatagramSocket） 包括數(shù)據(jù)內(nèi)容 ip 端口名3）使用發(fā)送端的socket發(fā)送數(shù)據(jù)報包4）釋放資源close

接收端不能開多次 只能開一次 因?yàn)槎丝谝呀?jīng)’'被占用了

UDP發(fā)送

package com.qf.udp_02;import java.net.*;/*** 使用UDP協(xié)議發(fā)送數(shù)據(jù)* 1)創(chuàng)建發(fā)送端的socket對象* 2)創(chuàng)建"數(shù)據(jù)報包"--里面包括:數(shù)據(jù)內(nèi)容,ip地址,端口號* 3)使用發(fā)送端的Socket對象發(fā)送"數(shù)據(jù)報包"* 4)釋放資源*/ public class UdpSend {public static void main(String[] args) throws Exception {//1)創(chuàng)建發(fā)送端的socket對象 ---java.net.DatagramSocket:此類表示用于發(fā)送和接收數(shù)據(jù)報數(shù)據(jù)包的套接字//public DatagramSocket()throws SocketExceptionDatagramSocket ds = new DatagramSocket() ;//2)創(chuàng)建"數(shù)據(jù)報包"--里面包括:數(shù)據(jù)內(nèi)容,ip地址,端口號//java.net DatagramPacket//參數(shù)1:分組數(shù)據(jù)(字節(jié)數(shù)組)//參數(shù)2:包的長度//參數(shù)3:ip地址對象//參數(shù)4:端口號//public DatagramPacket(byte[] buf,int length,InetAddress address,int port)byte[] bytes = "hello,udp我來了".getBytes() ;int length = bytes.length ;InetAddress inetAddress = InetAddress.getByName("10.35.165.17") ;int port = 6666 ;DatagramPacket dp = new DatagramPacket(bytes,length,inetAddress,port) ;//使用發(fā)送端的Socket對象發(fā)送"數(shù)據(jù)報包"//public void send(DatagramPacket p)throws IOException從此套接字發(fā)送數(shù)據(jù)報包ds.send(dp) ;//釋放資源ds.close();} }

UDP接受

package com.qf.udp_02;import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.SocketException;/*** Udp接收端* 1)創(chuàng)建接收端的Socket對象* 2)創(chuàng)建一個"數(shù)據(jù)報包"在里面自定義緩沖區(qū):將發(fā)送端是數(shù)據(jù)存儲到緩沖區(qū)中(字節(jié)數(shù)組,長度:1024或者1024的整數(shù)倍)* 3)使用2)接收容器(緩沖區(qū)),接收發(fā)送端的數(shù)據(jù)* 4)解析接收容器中的實(shí)際內(nèi)容* 5)展示數(shù)據(jù)即可* 6)釋放接收端的資源** 注意:* 接收端開啟一次就可以;否則* Exception in thread "main" java.net.BindException: Address already in use: Cannot bind*/ public class UdpReceive {public static void main(String[] args) throws Exception {//1)創(chuàng)建接收端的Socket對象//public DatagramSocket(int port)throws SocketExceptionDatagramSocket ds = new DatagramSocket(6666) ;//2)創(chuàng)建一個"數(shù)據(jù)報包"在里面自定義緩沖區(qū):將發(fā)送端是數(shù)據(jù)存儲到緩沖區(qū)中(字節(jié)數(shù)組,長度:1024或者1024的整數(shù)倍)//參數(shù)1:用于保存?zhèn)魅?#34;數(shù)據(jù)報"的緩沖區(qū)。//參數(shù)2:要讀取的字節(jié)數(shù)//public DatagramPacket(byte[] buf,int length)byte[] buffer = new byte[1024] ;DatagramPacket dp = new DatagramPacket(buffer,buffer.length) ;//3)使用2)接收容器(緩沖區(qū)),接收發(fā)送端的數(shù)據(jù)//public void receive(DatagramPacket p)throws IOException從此套接字接收數(shù)據(jù)報包ds.receive(dp) ;//4)解析接收容器中的實(shí)際內(nèi)容//public byte[] getData() :解析數(shù)據(jù)報包中DatagramPacket緩沖的實(shí)際的字節(jié)數(shù)組byte[] bytes = dp.getData();//public int getLength():解析數(shù)據(jù)報包中DatagramPacket中的實(shí)際字節(jié)數(shù)組長度int length = dp.getLength();//展示數(shù)據(jù)String message = new String(bytes,0,length) ;//誰發(fā)送的數(shù)據(jù)---獲取ip地址字符串形式//數(shù)據(jù)報包DatagramPacket--->public InetAddress getAddress()//InetAddress:ip地址--->String getHostAddress()String ip = dp.getAddress().getHostAddress() ;System.out.println("data from is--->"+ip+",data is--->"+message) ;//釋放資源ds.close();} }

2.鍵盤錄入版本

UDP發(fā)送

package UDPDemo2;import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.net.SocketException;public class TestSend {public static void main(String[] args) {DatagramSocket ds=null;try {ds= new DatagramSocket();BufferedReader br = new BufferedReader(new InputStreamReader(System.in));System.out.println("請輸入對話");String line=null;while((line=br.readLine())!=null) {DatagramPacket dp = new DatagramPacket(line.getBytes(), line.getBytes().length, InetAddress.getByName("10.35.165.80"), 1234);ds.send(dp);}} catch (SocketException e) {e.printStackTrace();}catch (IOException e) {e.printStackTrace();}finally {if(ds!=null){ds.close();}}} }

UDP接受

package UDPDemo2;import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.SocketException;public class TestReceive {public static void main(String[] args) {try {DatagramSocket ds = new DatagramSocket(1234);while(true){byte[] buffer=new byte[1024];DatagramPacket dp = new DatagramPacket(buffer, buffer.length);ds.receive(dp);String message = new String(dp.getData(), 0, dp.getLength());String IP=dp.getAddress().getHostAddress();System.out.println("來自"+IP+"IP的信息："+message);}} catch (SocketException e) {e.printStackTrace();}catch (IOException e) {e.printStackTrace();}finally {}} }

線程版本寫在同一個對話框的

發(fā)送端資源類

package com.qf.udp_04;import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress;/*** 發(fā)送端的資源類*/ public class SendTread implements Runnable{private DatagramSocket ds ;public SendTread(DatagramSocket ds){this.ds = ds ;}@Overridepublic void run() {try {//鍵盤錄入數(shù)據(jù)--->BufferedReaderBufferedReader br = new BufferedReader(new InputStreamReader(System.in)) ;String line = null ;while((line=br.readLine())!=null){//數(shù)據(jù)報包:將數(shù)據(jù)發(fā)送接收端DatagramPacket dp = new DatagramPacket(line.getBytes(),line.getBytes().length,InetAddress.getByName("10.35.165.17"),10086) ;//發(fā)送數(shù)據(jù)ds.send(dp) ;}} catch (IOException e) {e.printStackTrace();} finally {ds.close();}} }

接收端資源類

package com.qf.udp_04;import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket;/*** 接收端的資源類*/ public class ReceiveThread implements Runnable{private DatagramSocket ds ;public ReceiveThread(DatagramSocket ds){this.ds = ds ;}@Overridepublic void run() {try {//不斷的展示數(shù)據(jù)while(true){//接收數(shù)據(jù):接收容器byte[] buffer = new byte[1024] ;DatagramPacket dp = new DatagramPacket(buffer,buffer.length) ;//接收ds.receive(dp) ;//解析緩沖區(qū)(接收容器)的數(shù)據(jù)String message = new String(dp.getData(),0,dp.getLength()) ;//獲取ip地址String ip = dp.getAddress().getHostAddress() ;System.out.println("data from --->"+ip+",content is--->"+message);}} catch (IOException e) {e.printStackTrace();}//接收端不需要釋放資源,一直開啟狀態(tài)} }

測試類

package com.qf.udp_04;import java.net.DatagramSocket; import java.net.SocketException;/*** 需要優(yōu)化:* 發(fā)送端不斷鍵盤錄入數(shù)據(jù),接收端不斷展示數(shù)據(jù),在一個窗口中聊天!* 使用多線程的方式:開啟兩條線程,一條線程:發(fā)送端發(fā)送數(shù)據(jù)* 另一條線程:接收端不斷接收數(shù)據(jù),展示數(shù)據(jù)*/ public class ChatRoom {public static void main(String[] args) {try {//創(chuàng)建發(fā)送端SocketDatagramSocket sendDs = new DatagramSocket() ;//創(chuàng)建接收端的SocketDatagramSocket receiveDs = new DatagramSocket(10086) ;//創(chuàng)建發(fā)送端的線程所在的資源類對象SendTread st = new SendTread(sendDs) ;//創(chuàng)建接收端的線程所在資源類對象ReceiveThread rt = new ReceiveThread(receiveDs) ;//創(chuàng)建線程Thread t1 = new Thread(st) ;Thread t2 = new Thread(rt) ;//啟動線程t1.start();t2.start();} catch (SocketException e) {e.printStackTrace();}} }

總結(jié)

以上是生活随笔為你收集整理的第五周地狱总结的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。