Java基礎知識學習筆記總結
Java學習筆記總結
java基礎複習
1、 抽象類可以有構造器,可以有一個非抽象的父類
2、 垃圾回收機制回收的是堆裡面的記憶體,棧裡面的資料自動入棧自動出棧
3、 引用型別的資料在堆當中,記憶體中操作的只有棧,new關鍵字在堆裡面分配一塊記憶體
4、 java中是值傳遞
5、 String是不可變字元,即一旦分配了記憶體,此記憶體的值將不會改變,又將String賦值是,會重新分配一塊記憶體,字串池: StringBuffer
6、 在堆中的東西叫物件
Ø 執行時異常:
ArithmeticException 當出現異常的運算條件時,丟擲此異常。例如,一個整數“除以零”時,丟擲此類的一個例項。
ArrayIndexOutOfBoundsException用非法索引訪問陣列時丟擲的異常。如果索引為負或大於等於陣列大小,則該索引為非法索引。
ArrayStoreException試圖將錯誤型別的物件儲存到一個物件陣列時丟擲的異常。如:
Objectx[] = new String[3];
x[0]= new Integer(0);
ClassCastException檢視將物件轉換為不是例項的子類時,丟擲該異常。如:
Objectx = new Integer(0);
System.out.println((String)x);
illegalArgumentException表明向方法傳遞了一個不合法或不正確的引數
NegativeArraySizeException如果應用程式檢視建立大小為負的陣列,則丟擲該異常
Ø 編譯時異常:
NoSuchMethodException無法找到某一特定方法時,丟擲該異常
7、 unicode碼範圍
漢字:[\u4e00,\u9fa5]
數字:[0x30,0x39]
小寫字母:[0x61,0x7a]
大寫字母:[0x41,0x5a]
8、 final類
final類能夠修飾非抽象類、非抽象類成員方法和變數(靜態變數、例項變數、區域性變數)
final類不能被繼承,沒有子類
final方法可以被繼承,但不能被子類的方法覆蓋
final成員變量表示常量,宣告成員變數時,必須賦值(要麼在宣告的時候賦值,要麼在構造器中賦值),賦值後不能被改變
publicfinal
E= x;
}
final不能用於修飾構造方法2.5
9、 static只能修飾成員變數,表示所有物件共享這個資料
static能夠修飾成員變數和方法,內部類,也可以形成靜態static程式碼塊,不能修飾區域性變數
被static修飾的成員變數可以直接用類名來呼叫,語法如下:
類名.靜態放大名();
類名.靜態變數名;
靜態方法中不能用this和super關鍵字,不能直接訪問不帶static的成員變數和成員方法
因為static方法獨立於任何例項,因此static方法必須被實現,而不能是抽象的abstract
先執行靜態程式碼塊,再執行構造器
10、static和final一塊表示什麼
staticfinal用來修飾成員變數和成員方法,可理解為全域性變數(java中沒有全域性變數的概念)
staticfinal修飾變數,表示一旦給值就不可修改,並且通過類名就可以訪問
staticfinal修飾方法,表示不可覆蓋,並可通過類名直接訪問
staticfinal修飾一些容器型別(ArrayList、HashMap)的變數,不可以改變容器變數本省,但可以修改容器中存放的物件
11、類成員變數分類
被static修飾的變數叫靜態變數或者類變數;
沒有被static修飾的變數叫例項變數。
12、命令列引數
java主類引數(即命令列引數)
eclipse中java輸入命令列引數,在選定的類中,點選右鍵run as—Runconfigurations—Arguments-Program arguments-Variables-選擇string_prompt
13、Integer.valueOf(String)將字串轉換成Integer包裝類
14、一個.java檔案中可以有很多類。不過注意以下幾點:
a、public 許可權的類只能有一個(也可以一個都沒有,但最多隻有1個)
b、這個.java檔案的檔名必須是public類的類名(一般的情況下,這裡放置main方法是程式的入口。)
c、若這個檔案中沒有public的類,則檔名隨便是一個類的名字即可
d、用javac 編譯這個.java檔案的時候,它會給每一個類生成一個.class檔案
15、面向物件、面向過程
面向物件的三大特性:封裝、繼承、多型
面向過程:C語言的底層語言的特性
16、類和物件:
一個類中可以有多個物件,類是對物件的描述
一個類中的成員:
欄位:封裝private
方法:類的行為
構造器:與類同名,沒有返回值。作用:初始化成員變數。預設構造器:無參且同名沒有返回值,當一個類顯示的表明構
造器,則類不自己建立預設構造器
內部類
17、類之間的關係:繼承耦合度最高
A.繼承(is-a): 單繼承多實現 extends 優點:減少了程式碼的冗餘、缺點:耦合度太高
B.實現:
C.組合(has-a):
合成:個體和整體的關係,個體與整體生命週期相同,公司和部門的關係
聚合:個體和整體的關係,生命週期不同,學生和學校的關係
關聯:雙向關聯
Class Person{
Petpet;}
ClassPet{
Personowner;
}
D.依賴(use-a):一個類作為另一個類方法的引數或者是返回值,稱為依賴
18、java設計原則
低耦合高內聚
可擴充套件性和可維護性
19、繼承:
子類中的成員:
1)從父類中繼承的視覺化(非私有的)的成員(欄位、方法),不能繼承父類的構造器
2)子類所特有的成員(欄位、方法、構造器)
3)過載父類的成員(方法) 多型
過載的條件:
a)發生在同一個類或者父子類之間
b)方法名稱相同,引數列表(引數的個數,引數的資料型別、引數的順序)不同
c)返回值無所謂
d)訪問許可權無所謂
歧義過載:
ma(12,34)//歧義過載,編譯錯誤
publicvoid ma(int i,double j){//列印1}
publicvoid ma(double i,int j){//列印2}
構造器過載:
this:
this.成員(欄位、方法):呼叫本類的欄位、方法
this(引數列表):呼叫本類的其他構造方法,必須在構造方法的第一句
public Person(int age){
this(age,””);//呼叫下面那個構造器
}
publicPerson(int age,String name){
this.age= age;//呼叫本類的欄位
this.name= name;
}
super:父類的物件
super.成員:呼叫父類的成員(方法、欄位)
super(引數列表):呼叫父類的構造方法,必須位於子類構造方法的第一句
如果父類中沒有無參的構造器,在子類中必須顯式的呼叫父類帶引數的構造方法(super(引數類表或者this(引數列表))); 如果父類有無參的構造器,則子類中可以不用顯式呼叫父類的構造器,因為系統預設呼叫super();
4)重寫父類的成員(方法) 多型
重寫的條件 :
a)發生在父子類之間
b)方法名稱相同,引數列表(引數的個數,引數的資料型別、引數的順序)相同
c)返回值必須相同
d)子類覆蓋方法的訪問許可權大於等於父類被覆蓋方法的訪問許可權
e)子類不能丟擲比父類異常更大的異常(RuntimeException例外)
5)隱藏父類的成員(欄位)
多型物件:呼叫隱藏成員,呼叫的是父類的
呼叫覆蓋成員,呼叫的是子類的
20、static:類成員
欄位:所有物件共享
方法:靜態方法不能直接訪問非靜態的成員,如果需要訪問,產生例項訪問;
非靜態方法能夠直接訪問靜態成員和非靜態成員
靜態方法中不能有this、super關鍵字
塊:記憶體中只執行一次,通常用來初始化靜態成員
內部類
21、final:終態的
變數:不能第二次賦值,而且必須有初始值
方法:不能被重寫
類:不能被繼承
22、abstract:
抽象方法必須在抽象類中,抽象類中不一定要有抽象方法
抽象類沒有例項
抽象類可以有父類,父類可以是抽象類也可以是非抽象類
抽象類有構造器,不能用來產生本類例項,構造器用來間接產生子類例項時使用
abstract不能與static、final、private一起使用
23、異常處理:
1)try{}catch()finally{}
2)throws 方法聲明後 throws 異常類
3)throw 句子(通常是if)後throw 異常類的例項
4)自定義異常類 extends Exception或者RuntimeException
24、方法重寫(override)和 過載(overlord)的區別
重寫override:子類中出現與父類中籤名相同的方法、訪問修飾符要等於高於父類、返回值型別,引數列表都相同
過載overlord:一個類內部出現兩個及兩個以上方法名相同、引數列表不同(引數型別,引數個數,引數型別的順序)的方法
25、動態多型和靜態多型
動態多型(執行時多型):執行過程中才知道呼叫那個方法,指的是方法重寫
靜態多型(編譯時多型):編譯時就知道所呼叫的方法,指的是方法過載
26、如果父類中沒有空參構造
那麼子類必須同super()的方式顯示的呼叫父類構造
建議:如果父類中出現帶參構造,那麼必須手動新增空參構造
例:下列程式碼的執行結果是( B)
classA{
public A(int a){System.out.println(“A”);}
}
class B extends A{
publicB(){
super(5);//必須加上這一塊,用super()顯示的呼叫父類中的方法
}
public voidma(){System.out.println(“ma”);}
}
public class test{
public static void main(String[]args){
B b=new B();
b.ma();
}
}
A. 列印輸出ma
B. 編譯錯誤
C. 列印輸出A
D. 列印輸出A ma
27、 static:
表示靜態的,修飾的內容屬於類成員;被該類的所有物件共享,建議使用類名.的方式訪問;修飾的內容在類載入的時候,執行;只能訪問被static修飾的內容;修飾的內容只在類載入的時候執行一次。
可以修飾的內容:修飾屬性、修飾方法、作為程式碼塊使用 jdbc 載入驅動的時候
static{
Class.forName("");//作為程式碼塊使用
}
特點:
1.修飾的內容屬於類成員
2.修飾的方法,不能被重寫,可以被過載
3.修飾的內容,執行一次
例:public class HelloWorld{
public staticvoid main(String args[]){
method();
}
public voidmethod(){
try{
System.out.println("hello我執行");
}
finally{
System.out.println("我就不執行");
}
}
}
編譯執行後,輸出結果是什麼?(D )
A."hello 我執行"
B."我就不執行"
C."hello 我執行"
"我就不執行"
D.程式碼不能編譯
因為main方法是用static修飾的靜態方法,呼叫的方法也必須用static修飾,而method();方法沒有被static修飾
28、hashcode()返回的是物件的記憶體地址對應的int型別資料,但是我們可以重寫hashCode()方法,返回的就不再是記憶體地址。
hashcode()相同的物件,這兩個物件不一定相同;如果兩個物件相同,則hashcode()一定相同。
29、java中的訪問修飾符
public: 所有
protected: 自己、同一包中、子類可以訪問
default: 預設什麼都不加,就是default,自己、同一包中可以訪問,但是比protected級別要低即限制更多
friendly: 自己、同一包中可以訪問
private: 自己
例:以下程式碼的執行結果是:( C )
1. abstract class abstrctIt {
2. abstractfloat getFloat ();
3. }
4. public class AbstractTest extends AbstractIt {
5. privatefloat f1 = 1.0f;
6. privatefloat getFloat () {return f1;}
7. }
A. 編譯成功
B. 第6行產生錯誤,導致執行失敗
C. 第6行產生錯誤,導致編譯失敗
D. 第5行產生錯誤,導致編譯失敗
預設什麼不加的訪問修飾符是default,default比private限制少(即更高階),比protected限制多,所有第六行重寫方法用的private訪問修飾符比父類低階,所有會出現編譯失敗
30、Math.random()獲取[0,1)的值,取不到1;
用法:(int)Math.random()*n+1;取到1到n之間的整數
31、陣列、集合、字串之間的轉換
a. Arrays.asList() //將陣列轉換成集合
例:List list = Arrays.asList(names);//將陣列轉換成集合。
b.String.valueOf() //將陣列轉換成字串、也可將整數轉換成字串
例:char []ch1 = {'a','c','a','b','a'};
String str2 = String.valueOf(ch1);
例:int num = 123456;
String str =String.valueOf(num);
c.toCharArray()將字串轉換成陣列
例:String str = "gdfgdfgd";
char[] ch = str.toCharArray();
d.Arrays.toString()將字元陣列變成字串特定格式輸出,如[1,2,3]
例:String str1 = Arrays.toString(ch);
System.out.println(str1);
e.str.reverse();將字串反轉
例:StringBuffersb =new StringBuffer("adfsdsd");
sb.reverse();
f.
32、replace();函式
例1://將字串"abcdabcdabdcadcbadcb"的字元出現的次數輸出
Stringnum = "abcdabcdabdcadcbadcb";
String t = num.replace("a","");
System.out.println(num.length()-t.length());
replaceAll(),用正則表示式
例2://將字串中的數字去除
String num1 = "ab23c7da45bc5da65bd5c67ad7cb9adcb";
String t1 = num1.replaceAll("[0-9]", "");
System.out.println(t1);
例3://計算字串的長度,一個字元算兩個
byte[]b =str.getBytes();
System.out.println(b.length);//若出現一個漢字代表3個位元組的情況,將Utf-8換成GBK就可以了
String m = str.replaceAll("[\u4e00-\u9fa5]", "xx");
System.out.println(m.length());
33、DecimalFormat();將數字轉換成特定的格式
例://陣列格式化 int num = 1234567; 換成123,4567
int num = 1234567;
DecimalFormat f =new DecimalFormat("#,####");
String t =f.format(num);
System.out.println(t);
例: //將陣列轉換成123,4567.89的格式
doubled = 1234567.88898890;
DecimalFormat f =new DecimalFormat("#,####.##");
System.out.println(f.format(d));
34、String型別是否可以被繼承,為什麼?
不能被繼承,因為是被final修飾的類
35、String型別是否是基本型別,比較String型別變數時,== 和equals有何區別?
不是,是引用型別
a.如果 String型別是直接賦值 == 和 equals 效果相同
String a = “abc “;
String b = “abc”;
a ==b 和 a.equals(b)都為true
b.如果String是通過new構建的 == 和equals效果不同
String a = new String(“abc”);
String b = new String(“abc”);
a ==b 結果為false
a.equals(b)結果為true
36、char型別中是否可以存放一個漢字,為什麼?
可以,char型別中存放的資料以Unicode碼存放。
37、Random()函式
//獲取1-35之間的隨機數
//第一種方法
Random r = new Random();
int n = r.nextInt(35)+1;
//第二種方法Math.random()是取得[0,1)之間的隨機小數,取不到1。
int n =(int) (Math.random()*35+1);
java工具類
Object:引用型別的根,是所有類的超類,是java中唯一一個沒有父類的類
1、toString():將物件轉成字串
2、equals()和==的區別:
==:可以判斷基本資料型別和引用資料型別
引用資料型別,表示兩個物件的引用是否相等,即棧裡面引用的地址是否相等
equals:可以判斷引用資料型別
引用資料型別:表示兩個物件的引用是否相等,但是包裝類、String、Date、File除外(這些判斷的是物件的值是否相等,即堆記憶體裡面的值是否相等)
Stringstr1 = “abc”;
//建立一個字串池中的物件,如果裡面有此物件了就不再建立了,直接用即可
Stringstr2 = “abc”;
Stringstr3 = new String(“abc”);
Stringstr4 = new String(“abc”);
//可能產生兩個或一個物件,在堆記憶體中首先new出一個物件,再複製到字串池當中,如果字串池中有此物件,即不復制。所有堆記憶體中的物件是肯定存在的,字串池中的物件不一定
System.out.println(str1==str2);true
System.out.println(str3==str4);false
//str3在堆記憶體中new出一個記憶體、str4在堆記憶體中重新new出一個記憶體,在堆記憶體中相當於等號的右邊。在棧記憶體中,指向堆記憶體中的引用值不一樣,所有為false
System.out.println(str1==str3);false
//str1是在堆記憶體中的字串池裡,為“abc”,str3在堆記憶體new出一個物件‘abc‘佔用一塊記憶體,並且複製到字串池中,如果字串池中有abc了,即不復制。
System.out.println(str1.equals(str2));true
System.out.println(str3.equals(str4));true
System.out.println(str1.equals(str3));true
//equals在String型別比較的堆記憶體的值是否相等,str1字串池中的記憶體為abc,str3在堆記憶體中new出的物件是abc,這兩個物件雖然分配的記憶體不同,但是值相等,所以為true
3、重寫equals方法必須先重寫hashcode方法
相等的物件必須具有相同的雜湊碼,具有相同雜湊碼的物件不一定相等
3、clone()克隆
淺表克隆:複製原物件的所有變數的備份,但是引用型別的變數指向原物件的資料
必須實現一個介面implements Cloneable
重寫Object類的克隆方法clone()
深表克隆:複製原物件的所有變數的備份,包括引用型別
4、反射Class.forName(“com.A”);
破壞了底層的封裝性
5、包裝類
byteByte
shortShort
longLong
floatFloat
doubleDouble
BooleanBoolean
intIntegar
charCharacter
包裝類與字串轉換:
xxxValue():轉換成其他基本型別
包裝類-à字串 toString()
System.out.println(i.toString());
字串-à整形 parseXxx()
int i4 =Integer.parseInt(“123”);
double i5 =Double.parseDouble(“123.456”);
裝箱和拆箱:JDK1.5只會自動裝箱和拆箱
裝箱:基本資料型別轉換為引用資料型別
Integer i5 = 10;
拆箱:引用資料型別轉換為基本資料型別
Integer i5 = 10;
int i6 = i5;
6、String類
charAt()方法:一般與for迴圈一起,遍歷字串
Stringstr = “Hello Java,Hello World”;
for(int i=0;i<str.length();i++){
System.out.println(charAt(i));
}
concat()方法;拼接字串,將指定字串連線到此字串的結尾
str.concat(“s”); //得到Hello Java,Hello Worlds
startWith()方法;測試此字串是否已指定的字首開始,boolean
str. startWith(“Hello”); //true
format()方法:將字串按照某種格式輸出
inti=1;intj=2;
System.out.println(String.format("%d+%d=%d",i,j,i+j));//1+2=3
indexOf(String)方法:輸出字串第一次出現的索引,沒有的話輸出-1
System.out.println(str.indexOf("Hello"));//0
lastIndexOf()方法:輸出字串最後一次出現的索引
replace(old String, new String)方法:替換字串
split()方法:分割字串
substring(int start,int end)方法:擷取字串
toCharArray()方法:變成字元陣列
trim()方法:去掉字串兩端的空格,字串中間的去不掉
toUpperCase()方法:將字串轉化為大寫
7、StringBuffer和StringBuilder區別
StringBuffer執行緒安全的,同步的,效率比較低,JDK1.0之後出現
StringBuilder執行緒不安全,不同步的,效率比較高,JDK1.5之後出現
8、StringBuffer方法
StringBuffersb = new StringBuffer(“aaa”);
append 追加字串
sb.append(“bb”).append(“bb”);
delete 刪除
sb.delete(1,2).delete(1,2);
insert 插入
sb.insert(1,”22”).insert(1,false);
setCharAt 修改
sb.setCharAt(1,’Q’);
replace 替換
sb.replace(1,3,”MMM”);
reverse 反轉
sb.reverse();
10、Math方法
Math.ceil(2.4);//3取比值大的最小整數
Math.ceil(-2.4);//-2
Math.floor(2.5);//2取比值小的最大整數
Math.round(2.5);//3四捨五入
Math.round(-2.5);//-2
Math.random()//範圍是[0,1)
Math.random()*40+60;//取60到99的成績
Random方法:範圍是[0,1)
Randomran = new Random();
for(inti=0;i<10;i++){
intscore = ran.nextInt(41)+60;//從60到100
System.out.println(score);
}
11、Date方法
SimpleDateFormat類:改變時間的格式
SimpleDateFormatsdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Datedate = new Date();
//將日期格式轉換成指定的字串
Stringtime = sdf.format(date);
System.out.println(time);//現在的時間以yyyy/MM/dd HH:mm:ss格式輸出
//將格式化的字串轉換成日期物件
Datedate = sdf.parse(“1995/07/12 03:00:00”);
System.out.println(date);
TimeZone()設定時區
TimeZonetime=TimeZone.getTimeZone("America/Los_Angeles");
Calendar c2=Calendar.getInstance(time,Locale.US);
Date d=c2.getTime();
GregorianCalendar單獨獲取年、月、日
GregorianCalendar gc =newGregorianCalendar(2017,3,5);
System.out.println(gc.get(Calendar.MONTH));
System.currentTimeMillis();通常用於迴圈運算的時間
long startTime = System.currentTimeMillis();
for(){}
longendTime = System.currentTimeMillis();
longtime = endTime- startTime//計算出運算的時間
集合:
1、集合和陣列的區別:
陣列:可以包含基本資料型別或者引用資料型別的物件,資料定長的,訪問較快
集合:只能包含引用資料型別的物件,不定長。
2、集合分類:
Set:集 無序,不重複,父介面為Collection
add();新增元素
addAll(Collection);新增子集合
contains();是否包括元素
containsAll();是否包含子集合
isEmpty();Boolean判斷集合長度是否為0
remove();移除元素
removeAll();移除一個子集合
size();集合的大小
toArray();將集合轉換成資料
Set集合的遍歷 Iterator 迭代器
Setset = new HashSet();
Iteratorit = set.iterator();
while(it.hasNext()){
Objectobj = it.next();
System.out.println(obj);
}
Set集合的遍歷 增強for迴圈
for(Object obj:set){
System.out.println(obj);
}
HashSet和TreeSet的區別:
HashSet:內部物件雜湊存取,順序和輸入的順序不同
TreeSet:元素會進行升序排序(元素是可比較的),順序和輸入的順序也不同
List:列表 有序,重複,父介面為Collection
add();新增元素
addAll(Collection);新增子集合
add(key,元素);插入元素
get(key);獲取元素
indexOf(元素);返回元素的索引值,如果沒有則返回-1
remove(key);移除元素
removeAll();移除一個子集合
set(key,元素);修改元素
toArray();轉換成陣列
List集合的遍歷 普通for迴圈
Listlist = new ArrayList();
for(inti;i<list.size();i++){
Object obj = list.get(i);
System.out.println(obj);
}
List集合的遍歷 增強for迴圈
for(Object obj:list){
System.out.println(obj);
}
List集合的遍歷 Iterator 迭代器
Iterator it = list.iterator();
while(it.hasNext()){
Objectobj = it.next();
System.out.println(obj);
}
ArrayList和LinkedList區別:
ArrayList底層物理儲存為線性的(陣列的儲存方式),查詢效率高,刪除、新增等操作效率比較低
LinkedList底層物理儲存為連結串列的,查詢效率低,刪除、新增效率高
ArrayList和Vector區別:
兩者底層物理儲存為線性的
ArrayList:執行緒不安全,不同步的,資料不安全,效率比較高
Vector:執行緒安全的,同步的,資料安全,效率比較低
Map:字典 鍵值對儲存 key唯一,value可重複
put(key,values);新增元素
putAll(map);新增集合
remove(key);移除一對元素
size();集合長度
containkey(key);是否包含某個鍵
containvalue(value);是否包含某個值
Map集合的遍歷 keySet()
Set set = map.keySet();
Iterator it = set.iterator();
while(it.hasNext){
Object key = it.next();
Object value = map.get(key);
System.out.println(key+”:”+value);
}
Map集合的遍歷 entrySet()
Iterator it = map.entrySet().iterator();
while(it.hasNext()){
Map.Entry entry = (Map.Entry)it.next();
System.out.println(entry.getKey()+”:”+entry.getValue());
}
HashMap和Hashtable的區別:
HashMap:鍵值對允許為null,執行緒不安全,不同步,效率比較高
Hashtable:鍵值對不允許為null,執行緒安全,同步,效率比價低
HashMap和TreeMap的區別:
HashMap:基於雜湊,是無序的
TreeMap:基於樹型結構的,按照鍵升序排序
3、Collections類:
Collections.sort():只針對List集合,集合中的元素必須是可比較的,如果為引用型別,則必須實現Comparator、Compareable(常用)介面
Collections.shuffle(list):打亂順序
Collections.rotate(list,int i):根據指定的長度,輪換指定列表中的長度
Collections.reverse(list):反轉集合
泛型:資料型別引數化
1、public<T> void arr(T t1,T t2){
Ttemp = t1;
t1= t2;
t2= temp;
}
2、泛型:安全的,避免了資料型別轉換的風險
3、泛型約束:entends:如果有多個約束則使用&連線,約束只能有一個類,可以有多個介面
4、萬用字元?
上屆萬用字元:? extends A:表示A或者A的子類
下屆萬用字元:? super A:表示A或者A的父類型別
List<String>list = new ArrayList<String>();
List<?extends Object> listobj = list;//成立
List<Object>listobj = list;//不成立 在泛型中<String>和<Object>是同級關係
檔案
1、構造方法
Filefile1 =new File("D:\\a.txt");
File file2 =new File("d:\\UI","a.txt");
File file3 = new File("D:\\UI");
Filefile4 =new File(file3,"a.txt");
2、mkdirs()建立多層資料夾
File file5 = new File("D:\\UI\\aaa");
if(!file5.exists()){
file5.mkdirs();
}
3、getAbsolutePath()列印檔案路徑
getPath()列印檔案路徑
System.out.println(file5.getAbsolutePath());//D:\UI\aaa
4、getName()()獲取檔名//aaa
5、getParent()獲取檔案目錄,不包含檔名//D:\UI
6、isHidden()檔案是否被隱藏//false
7、isDirectory()判斷是否是資料夾//true
8、isFile() 判斷是否是檔案
9、exists() 判斷是否存在
10、newDate(file5.lastModified()) 獲取最後一次修改的日期
11、length() 檔案的位元組數
12、file5.list() 檔名的遍歷
String[]str =file5.list();
for(String s :str){
System.out.println(s);
}// 3.doc
5.FEM
e.txt
13、file5.listFiles() 檔案的遍歷
File[]files = file5.listFiles();
for(File f :files){
if(f.isFile()){
System.out.println("檔案"+f.getName()+"\t"+new Date(f.lastModified()));
}else{
System.out.println("資料夾"+f.getName());
}
}//檔案3.docFri Feb 24 10:33:28 CST2017
檔案5.FEM Fri Feb 24 10:33:37 CST 2017
檔案e.txt Fri Feb 24 10:33:32 CST 2017
14、File.listRoots(); 碟符的遍歷
File[] f1 = File.listRoots();
for(Filef :f1){
System.out.println(f.toString());
}// C:\
D:\
檔案IO流
1、 位元組流
FileInputStream 輸入流 讀檔案
BufferedInputStream輸入流讀檔案
FileOutputStream輸出流寫入檔案
BufferedOutputStream輸出流寫入檔案
字元流
FileReader輸入流讀檔案
DataInputStream輸入流 讀檔案
FileWriter輸出流 寫入檔案
DataOutputStream輸出流 寫入檔案
2、FileInputStream 讀取英文檔案
FileInputStreamfis = new FileInputStream("D:\\UI\\bbb.txt");
intch = 0;
while((ch= fis.read()) != -1){ //read從此輸入流中讀取一個數據位元組,返回值為int
System.out.print((char)ch);
}
fis.close();//此程式不能讀中文
3、FileInputStream 讀取中文檔案
FileInputStreamfis = n