java菜鳥教程+視訊筆記

阿新 • • 發佈：2019-01-26

1、java中區域性變數是在棧上分配的；

2、陣列是儲存在堆上的物件，可以儲存多個同類型變數；

3、在Java語言中，所有的變數在使用前必須宣告。

4、區域性變數沒有預設值，所以區域性變數被聲明後，必須經過初始化，才可以使用。

5、內建型別有預設值，引用物件的預設值是null；

6、非靜態例項變數、非靜態方法是通過物件例項進行呼叫的，不能直接從靜態方法中呼叫；比如java原始檔中main方法中不可以直接呼叫非靜態方法；

7、靜態變數、例項變數具有預設值。數值型變數的預設值是0，布林型變數的預設值是false，引用型別變數的預設值是null。

8、在構造方法中，當例項變數的名稱跟區域性變數的名稱一致時，例項變數的使用就要用this了。

9、靜態變數（類變數）除了被宣告為常量外很少使用。常量是指宣告為public/private，final和static型別的變數。常量初始化後不可改變。

10、靜態變數儲存在靜態儲存區。經常被宣告為常量，很少單獨使用static宣告變數。

11、類變數被宣告為public static final型別時，類變數名稱一般建議使用大寫字母。如果靜態變數不是public和final型別，其命名方式與例項變數以及區域性變數的命名方式一致。

12、方法名：所有的方法名都應該以小寫字母開頭。如果方法名含有若干單詞，則後面的每個單詞首字母大寫。

13、類名：對於所有的類來說，類名的首字母應該大寫。如果類名由若干單片語成，那麼每個單詞的首字母應該大寫，例如 MyFirstJavaClass 。

14、 StringBuffer 之間的最大不同在於 StringBuilder 的方法不是執行緒安全的（不能同步訪問）。

15、String 類是不可改變的，所以你一旦建立了 String 物件，那它的值就無法改變了。如果需要對字串做很多修改，那麼應該選擇使用 StringBuffer & StringBuilder 類。

16、Java 語言中提供的陣列是用來儲存固定大小的同類型元素。

17、java遍歷二維陣列：

package com.example.test;


import java.io.*;
public class EmployeeTest{
	
    public static void main(String[] args){
    	String s[][]=new String[2][];
    	s[0]=new String[2];
    	s[1]=new String[3];
    	s[0][0]=new String("Good");
    	s[0][1]=new String("Luck");
    	s[1][0] = new String("to");
    	s[1][1] = new String("you");
    	s[1][2] = new String("!");
    	System.out.println(s.length);
    	for(int a=0;a<s.length;a++) {
    		for(int i=0;i<s[a].length;i++) {
    			System.out.print(s[a][i]+" ");
    		}
    		System.out.println();
    	}
    }
}

執行結果：

18、休眠三秒：

try {
    		System.out.println(new Date()+"\n");
    		Thread.sleep(1000*3);// // 休眠3秒
    		System.out.println(new Date()+"\n");
    	}catch(Exception e) {
    		System.out.println("Got an exception!");
    	}

執行結果：

19、計算日期間隔：

try {
            long start = System.currentTimeMillis( );
            System.out.println(new Date( ) + "\n");
            Thread.sleep(5*60*10);
            System.out.println(new Date( ) + "\n");
            long end = System.currentTimeMillis( );
            long diff = end - start;
            System.out.println("Difference is : " + diff);
         } catch (Exception e) {
            System.out.println("Got an exception!");
         }

執行結果：

20、從控制檯讀取資料

帶reader的是字元流

// 使用 BufferedReader 在控制檯讀取字元

// 使用 System.in 建立 BufferedReader

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

從控制檯讀取字串

str = br.readLine();

從控制檯讀取多字元輸入

c = (char) br.read();

21、控制檯輸出

PrintStream 繼承了 OutputStream類，並且實現了方法 write()。這樣，write() 也可以用來往控制檯寫操作。

      int b; 
      b = 'A';
      System.out.write(b);
      System.out.write('\n');

注意：write() 方法不經常使用，因為 print() 和 println() 方法用起來更為方便。

22、讀寫檔案

位元組流寫檔案易出現亂碼（位元組流是二進位制）

不使用位元組流專用字元流：

package com.example.test;


import java.io.*;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;
public class EmployeeTest{
	
    public static void main(String[] args) throws IOException{
    	File f = new File("a.txt");
        FileOutputStream fop = new FileOutputStream(f);//位元組流輸出流
        // 構建FileOutputStream物件,檔案不存在會自動新建
        
        OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");//字元流寫檔案
        // 構建OutputStreamWriter物件,引數可以指定編碼,預設為作業系統預設編碼,windows上是gbk
        
        writer.append("中文輸入");
        // 寫入到緩衝區
        
        writer.append("\r\n");
        //換行
        
        writer.append("English");
        // 重新整理快取衝,寫入到檔案,如果下面已經沒有寫入的內容了,直接close也會寫入
        
        writer.close();
        //關閉寫入流,同時會把緩衝區內容寫入檔案,所以上面的註釋掉
        
        fop.close();
        // 關閉輸出流,釋放系統資源
     
        FileInputStream fip = new FileInputStream(f);//位元組流
        // 構建FileInputStream物件
        
        InputStreamReader reader = new InputStreamReader(fip, "UTF-8");//字元流
        // 構建InputStreamReader物件,編碼與寫入相同
     
        StringBuffer sb = new StringBuffer();
        while (reader.ready()) {//判斷此流是否已準備好被讀取,是一個非阻塞的方法，所以會立刻返回，由於伺服器沒有準備好被讀，所以會立刻返回，所以讀取到的都是null
          sb.append((char) reader.read());
          // 轉成char加到StringBuffer物件中
        }
        System.out.println(sb.toString());
        reader.close();
        // 關閉讀取流
        
        fip.close();
        // 關閉輸入流,釋放系統資源
     
    }
    
    
}

23、重寫

重寫是子類對父類的允許訪問的方法的實現過程進行重新編寫, 返回值和形參都不能改變。即外殼不變，核心重寫！

儘管物件引用b屬於Animal型別，但是它執行的是Dog類的move方法。

這是由於在編譯階段，只是檢查引數的引用型別。

然而在執行時，Java虛擬機器(JVM)指定物件的型別並且執行該物件的方法。

因此在上面的例子中，之所以能編譯成功，是因為Animal類中存在move方法，然而執行時，執行的是特定物件的方法。

24、方法的重寫規則

引數列表必須完全與被重寫方法的相同；
返回型別必須完全與被重寫方法的返回型別相同；
訪問許可權不能比父類中被重寫的方法的訪問許可權更低。例如：如果父類的一個方法被宣告為public，那麼在子類中重寫該方法就不能宣告為protected。
父類的成員方法只能被它的子類重寫。
宣告為final的方法不能被重寫。
宣告為static的方法不能被重寫，但是能夠被再次宣告。
子類和父類在同一個包中，那麼子類可以重寫父類所有方法，除了宣告為private和final的方法。
子類和父類不在同一個包中，那麼子類只能夠重寫父類的宣告為public和protected的非final方法。
重寫的方法能夠丟擲任何非強制異常，無論被重寫的方法是否丟擲異常。但是，重寫的方法不能丟擲新的強制性異常，或者比被重寫方法宣告的更廣泛的強制性異常，反之則可以。
構造方法不能被重寫。

如果不能繼承一個方法，則不能重寫這個方法。

25、過載(Overload)

過載(overloading) 是在一個類裡面，方法名字相同，而引數不同。返回型別可以相同也可以不同。

每個過載的方法（或者建構函式）都必須有一個獨一無二的引數型別列表。

最常用的地方就是構造器的過載。

26、方法的過載規則：

被過載的方法必須改變引數列表(引數個數或型別不一樣)；
被過載的方法可以改變返回型別；
被過載的方法可以改變訪問修飾符；
被過載的方法可以宣告新的或更廣的檢查異常；
方法能夠在同一個類中或者在一個子類中被過載。

無法以返回值型別作為過載函式的區分標準。

27、過載和重寫的區別：

28、重寫+過載=總結

總結

方法的重寫(Overriding)和過載(Overloading)是java多型性的不同表現，重寫是父類與子類之間多型性的一種表現，過載可以理解成多型的具體表現形式。

(1)方法過載是一個類中定義了多個方法名相同,而他們的引數的數量不同或數量相同而型別和次序不同,則稱為方法的過載(Overloading)。
(2)方法重寫是在子類存在方法與父類的方法的名字相同,而且引數的個數與型別一樣,返回值也一樣的方法,就稱為重寫(Overriding)。

(3)方法過載是一個類的多型性表現,而方法重寫是子類與父類的一種多型性表現。

29、多型

多型是同一個行為具有多個不同表現形式或形態的能力。

多型就是同一個介面，使用不同的例項而執行不同操作

多型性是物件多種表現形式的體現。

多型的優點
1. 消除型別之間的耦合關係
2. 可替換性
3. 可擴充性
4. 介面性
5. 靈活性

6. 簡化性

多型存在的三個必要條件
繼承
重寫

父類引用指向子類物件比如：Animal ad=new Dog();

30、虛方法

當使用多型方式呼叫方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，再去呼叫子類的同名方法。

多型的好處：可以使程式有良好的擴充套件，並可以對所有類的物件進行通用處理。

例項中，例項化了兩個 Salary 物件：一個使用 Salary 引用 s，另一個使用 Employee 引用 e。

當呼叫 s.mailCheck() 時，編譯器在編譯時會在 Salary 類中找到 mailCheck()，執行過程 JVM 就呼叫 Salary 類的 mailCheck()。
因為 e 是 Employee 的引用，所以呼叫 e 的 mailCheck() 方法時，編譯器會去 Employee 類查詢 mailCheck() 方法。

在編譯的時候，編譯器使用 Employee 類中的 mailCheck() 方法驗證該語句，但是在執行的時候，Java虛擬機器(JVM)呼叫的是 Salary 類中的 mailCheck() 方法。

31、虛方法出現在Java的多型特性中

Java虛方法你可以理解為java裡所有被overriding的方法都是virtual的,所有重寫的方法都是override的。

在JVM位元組碼執行引擎中，方法呼叫會使用invokevirtual位元組碼指令來呼叫所有的虛方法。

需要注意虛方法和抽象方法並不是同一個概念

32、多型的實現方式

方式一：重寫：

這個內容已經在上一章節詳細講過，就不再闡述，詳細可訪問：Java 重寫(Override)與過載(Overload)。

方式二：介面

1. 生活中的介面最具代表性的就是插座，例如一個三接頭的插頭都能接在三孔插座中，因為這個是每個國家都有各自規定的介面規則，有可能到國外就不行，那是因為國外自己定義的介面型別。

2. java中的介面類似於生活中的介面，就是一些方法特徵的集合，但沒有方法的實現。具體可以看 java介面這一章節的內容。

方式三：抽象類和抽象方法

33、java抽象類

抽象類除了不能例項化物件之外，類的其它功能依然存在，成員變數、成員方法和構造方法的訪問方式和普通類一樣。

由於抽象類不能例項化物件，所以抽象類必須被繼承，才能被使用。

1. 抽象類不能被例項化(初學者很容易犯的錯)，如果被例項化，就會報錯，編譯無法通過。只有抽象類的非抽象子類可以建立物件。
2. 抽象類中不一定包含抽象方法，但是有抽象方法的類必定是抽象類。

3. 抽象類中的抽象方法只是宣告，不包含方法體，就是不給出方法的具體實現也就是方法的具體功能。

4. 構造方法，類方法（用static修飾的方法）不能宣告為抽象方法。

5. 抽象類的子類必須給出抽象類中的抽象方法的具體實現，除非該子類也是抽象類。

34、繼承：

java繼承中對建構函式是不繼承的，只是呼叫（隱式或顯式）。

在建立子類的物件時，Java虛擬機器首先執行父類的構造方法，然後再執行子類的構造方法。在多級繼承的情況下，將從繼承樹的最上層的父類開始，依次執行各個類的構造方法，這可以保證子類物件從所有直接或間接父類中繼承的例項變數都被正確地初始化。

建立有參建構函式後，系統就不再有預設無參建構函式。

如果沒有任何建構函式，系統會預設有一個無參建構函式。

35、抽象類和介面的區別：

抽象類中：

可以有構造方法；

方法可以是隱式抽象的；也可以是實現了的方法體；

成員變數可以是各種型別的；

抽象類是可以有靜態程式碼塊和靜態方法；不能有宣告為static的抽象方法；

構造方法，類方法（用static修飾的方法）不能宣告為抽象方法。

原因：Java抽象類中不能有靜態的抽象方法，可以有靜態的成員方法。抽象類是不能例項化的，即不能被分配記憶體;而static修飾的方法在類例項化之前就已經別分配了記憶體，這樣一來矛盾就出現了：抽象類不能被分配記憶體，而static方法必須被分配記憶體。所以抽象類中不能有靜態的抽象方法。定義抽象方法的目的是重寫此方法，但如果定義成靜態方法就不能被重寫。

介面中：

不能有構造方法；

方法宣告都是隱式抽象的public abstract方法；

介面中的成員變數只能是 public static final 型別的；

介面中不能含有靜態程式碼塊以及靜態方法(用 static 修飾的方法)

介面中的方法也只能是 public abstract修飾的，不能加上static。介面是不能例項化的，即不能被分配記憶體，而static修飾的方法在類例項化之前就已經別分配了記憶體，這樣一來矛盾就出現了：介面不能被分配記憶體，而static方法必須被分配記憶體。所以介面中不能有靜態的抽象方法。

36、介面

當類實現介面的時候，類要實現介面中所有的方法。否則，類必須宣告為抽象的類。

介面沒有構造方法，因為介面不能例項化；

37、集合與泛型

第一：集合框架常用的介面有哪些？

複雜方式儲存物件是值鍵值對映的時候；

java集合框架就是提供一些介面和類，位於java.util包中；

Iterator（操作集合的迭代器）、Map、Collection是介面；虛線空心箭頭是子介面繼承父介面；長方形實現是實現類；

utilties是工具類：有Collections、Arrays;看見util就是工具類；

第二：這些介面有哪些特點？

Collection介面儲存一組不唯一、無序的物件。

List介面儲存一組不唯一（可重複）、有序（儲存空間連續）（插入順序）的物件；

Set介面儲存一組唯一，無序的物件

Map介面儲存一組鍵值物件，提供key到value的對映；

37.2、ArrayList（是一個可變陣列）

ArrayList是連續的空間，長度可變；

LinkedList是可不連續的空間；

shift+alt+s:生成getter和setter

ctrl+shift+o或者Ctrl+1導包；

集合有了list以後，在記憶體中就開闢空間了；

ArrayList有個固定的長度，插入資料超過後，會自動擴充；

package com.example.test;

public class NewTitle {
	private int id;
	private String newsName;
	private String creater;
	public NewTitle() {}
	public NewTitle(int id ,String newsName,String creater) {
		this.id=id;
		this.newsName=newsName;
		this.creater=creater;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getNewsName() {
		return newsName;
	}
	public void setNewsName(String newsName) {
		this.newsName = newsName;
	}
	public String getCreater() {
		return creater;
	}
	public void setCreater(String creater) {
		this.creater = creater;
	}
	
	
	
	
	
}

package com.example.test;

import java.util.ArrayList;
import java.util.List;


public class ArrayListDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		NewTitle news1=new NewTitle(1,"title1","admin");
		NewTitle news2=new NewTitle(2,"title2","admin");
		NewTitle news3=new NewTitle(3,"title3","admin");

		ArrayList list=new ArrayList();
		//List list=new ArrayList();//這種介面是向上轉移，面向介面程式設計的時候經常用
		list.add(news1);
		list.add(news2);
		list.add(news3);
		
		int nums=list.size();
		System.out.println("共有"+nums+"條標題");
		System.out.println("*******************");
		for(int i=0;i<nums;i++) {
			NewTitle newsTitle=(NewTitle) list.get(i);//找到對應位置上的元素；即：Object
			System.out.println(newsTitle.getNewsName());
		}
	}

}

執行結果：

標紅色的是Collection介面的方法；

clear()是清空集合；isEmpty()返回是True代表清空了；iterator()返回這個集合的迭代器；toArray()集合變成陣列或者序列；

37.3、LinkedList(是一個列表)

注意:add（）和addLast（）的區別

package com.example.test;

import java.util.LinkedList;
import java.util.List;


public class LinkedListDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		NewTitle news1=new NewTitle(1,"title1","admin");
		NewTitle news2=new NewTitle(2,"title2","admin");
		NewTitle news3=new NewTitle(3,"title3","admin");
		NewTitle news4=new NewTitle(4,"title4","admin");

		LinkedList list=new LinkedList();
		//List list=new ArrayList();//這種介面是向上轉移，面向介面程式設計的時候經常用
		list.add(news1);
		list.add(news2);
		list.add(news3);
		list.add(1,news4);
		
		System.out.println(list.contains(news4));
		
		
		int nums=list.size();
		System.out.println("共有"+nums+"條標題");
		System.out.println("*******************");
		for(int i=0;i<nums;i++) {
			NewTitle newsTitle=(NewTitle) list.get(i);//找到對應位置上的元素；即：Object
			System.out.println(newsTitle.getNewsName());
		}
		NewTitle news5=new NewTitle(5,"titleFirst","admin");
		NewTitle news6=new NewTitle(6,"titleLast","admin");
		NewTitle news7=new NewTitle(7,"title","admin");

		list.addFirst(news5);
		list.addLast(news6);//在當前基礎上新增的末尾；
		list.add(news7);//在集合的尾部依次新增；所以在news6的後面
		int nums1=list.size();
		System.out.println("*******************");

		for(int i=0;i<nums1;i++) {
			NewTitle newsTitle=(NewTitle) list.get(i);//找到對應位置上的元素；即：Object
			System.out.println(newsTitle.getNewsName());
		}
		System.out.println("**********************");
		list.removeFirst();
		list.removeLast();
		NewTitle t=(NewTitle)list.removeFirst();
		for (int i=0;i<list.size();i++) {
			NewTitle newsTitle=(NewTitle)list.get(i);
			System.out.println(newsTitle.getNewsName());
		}
	}

}

eclipse除錯F6是跳過方法，F5是進入放法；

注意：ArrayList再插入元素時，是插入位置的元素依次往後移；

LinkedList在插入元素時，只是插入結點位置不一樣；其他不變，只是修改next和previous

LinkedList常用方法：

總結：

37.4、HashSet

java虛擬機器會管理記憶體空間，可能劃分為棧（存放平時的變數），堆（存放的是物件），方法區（和類相關的位元組碼資料、類中的方法）

new：生成物件；

型別變數：是變數；

Set存放的就是物件的引用，s1、s2引用的同一個物件；所以s1和s2是重複的物件；

Set是類似於map的一個數據結構；

HashMap有個hash碼，計算兩個hash碼，如果java和Java的hash碼一樣或者相近的，就會放到一個地方，同一個位置。

若不同key的hascode相同，則儲存在同一個陣列地址連結串列上，儲存格式為entry（key,value）

第一、set增加位置是隨機的，先加的s1還是s2不確定，總之最後新增的會覆蓋掉重複的；

set介面如何判斷加入物件是否已經存在吶？

採用物件的equals（）方法比較兩個物件是否相等，即時候指向的是同一個物件；若返回值是True，則後面的值會覆蓋掉前面的值！注意：在String中equals是比較兩個字串的內容（可以是分別new的）是否一樣，可能是兩個引用，String類重寫過equals方法，只要字串值一樣，則認為是一個物件，set就會只加一個！

注意set中沒有get方法：因為set中是無序的，存放的時候是亂的，所以不能通過下標找到對應元素；

那如何實現元素輸出吶？

答：可以通過增強型for來進行；

迭代器可以定位到集合裡面的每一個元素：有方法hasnext()，判斷有沒有下一個元素---返回boolean；如果有（hasnext）下一個元素，取下一個元素就是next（）方法；

iterator遍歷的時候是拿元素作為一個集合去遍歷；不會像是陣列一樣從0開始去找；找元素的集合；

package com.example.test;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SetDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Set set=new HashSet();
		String s1=new String("java");
		String s2=s1;
		String s3=new String("Java");
		String s4=new String("JDK");
		System.out.println(s1.equals(s2));//即值不一樣
		System.out.println(s3.equals(s1));
		set.add(s1);
		set.add(s2);
		set.add(s3);
		set.add(s4);
		System.out.println(set.size());
		//方法一：增強型for
		for(Object obj:set) {//拿出set的每個元素放到obj中
			String sObj=(String)obj;
			System.out.println(sObj);
		}
		System.out.println("********************");
		//方法二：迭代器（與型別是無關的）
		Iterator itor=set.iterator();//是Collection中方法
		while(itor.hasNext()) {
			String sItor=(String)itor.next();
			System.out.println(sItor);
		}
	}

}

執行結果為：

list獲取元素的方法：

set獲取元素的方法：

List和Set是Collection的子介面，注意介面可以多繼承，但是沒有辦法例項化，

Map不是Collection的子介面；

Ctrl+shift+o是匯入多個包；

Iterator迭代器，是與Collection和Map無關的一個介面

37.5 Map

Map：中的key是唯一的，無序是Set；值value可以重複，還無序，是Collection

package com.example.test;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//Map map=new HashMap();
		HashMap map=new HashMap();
		map.put("China", "中國");//相當於List的add，第一個引數是key,第二個引數是value
		map.put("FR","法國");
		map.put("JP","日本");
		System.out.println(map.size());
		//如何獲取元素?
		Set s=map.keySet();
		
		Iterator itor=s.iterator();
		while(itor.hasNext()) {
			String keystr=(String)itor.next();
			String valstr=(String)map.get(keystr);
			System.out.println(valstr);
		}
		System.out.println("**************");
		for(Object obj:s) {
			String se=(String)obj;
			String valstr=(String)map.get(se);
			System.out.println(valstr);
		}
	}

}

執行結果：

迭代器是什麼型別的介面？

答：Iterator型別的；介面也是一種型別，可通過介面宣告介面型別的物件，只不過new的時候沒有辦法建立介面類的物件，因為介面沒有辦法例項化。介面有實現類，即通過父類型別指向子類型別物件。也叫建立了一個介面類的物件。

map中的方法Set<Map.Entry<K,V>> entrySet（）：返回鍵值對集合,型別是Map.Entry<K,V>的集合Set，如下圖；

package com.example.test;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//Map map=new HashMap();
		HashMap map=new HashMap();
		map.put("China", "中國");//相當於List的add，第一個引數是key,第二個引數是value
		map.put("FR","法國");
		map.put("JP","日本");
		System.out.println(map.size());
		//如何獲取元素?
		Set s=map.keySet();//返回所有的 鍵
		System.out.println(s);
		//方法一：通過迭代器獲取值
		Iterator itor=s.iterator();
		while(itor.hasNext()) {
			String keystr=(String)itor.next();
			String valstr=(String)map.get(keystr);
			System.out.println(keystr+"---"+valstr);
		}
		//通過鍵獲取值
		System.out.println("**************");
		for(Object obj:s) {
			String se=(String)obj;
//			if (se.equals("China")) {;
//				//map.remove(se);
//			}
//			else {
			String valstr=(String)map.get(se);
			System.out.println(se+"---"+valstr);
//			}
		}
		
		//方法三：獲得鍵值對
		System.out.println("**************");
		Set kvSets=map.entrySet();//Set中每個元素都是Map.Entry型別，鍵值對形式
		for(Object me:kvSets) {
			Map.Entry meNew=(Map.Entry)me;
			String key=(String)meNew.getKey();
			String value=(String)meNew.getValue();
			System.out.println(key+"---"+value);
		}
		System.out.println("*************");
		map.clear();
		System.out.println(map.isEmpty());
	}

}

執行結果：

練習題：

38、泛型：

解決了，取元素時，不用再強制型別轉換；

所有的集合類和介面都實現了泛型；

解釋：ArrayList陣列以前能放Object型別的物件，現在加上泛型後只能裝Student型別的物件。取資料時就不用再進行型別轉換了！而Poem型別的物件是不能加到ArrayList中的。

操作空物件就會報NullpointerException，即null.say();

泛型的好處：資料新增的時候更安全；往外取資料的時候不用再型別轉換；

ArrayList用泛型：

package com.example.test;

import java.util.ArrayList;
import java.util.List;


public class ArrayListDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		NewTitle news1=new NewTitle(1,"title1","admin");
		NewTitle news2=new NewTitle(2,"title2","admin");
		NewTitle news3=new NewTitle(3,"title3","admin");
		NewTitle news4=new NewTitle(4,"title4","admin");

		//ArrayList list=new ArrayList();
		//List list=new ArrayList();//這種介面是向上轉移，面向介面程式設計的時候經常用
		ArrayList <NewTitle> list=new ArrayList<NewTitle>();

		list.add(news1);
		list.add(news2);
		list.add(news3);
		list.add(1,news4);
		//list.add("aaa");
		System.out.println(list.contains(news4));
		
		int nums1=list.size();
		System.out.println("共有"+nums1+"條標題");

		System.out.println(list.remove(news4));//boolean
		System.out.println(list.remove(1));//Object
		int nums=list.size();
		System.out.println("共有"+nums+"條標題");
		System.out.println("*******************");
		for(int i=0;i<nums;i++) {
			NewTitle newsTitle=list.get(i);//找到對應位置上的元素；即：Object
			System.out.println(newsTitle.getNewsName());
		}
		System.out.println(list.toArray());
		list.clear();
		System.out.print(list.isEmpty());
		int nums2=list.size();
		System.out.println("共有"+nums2+"條標題");
	}

}

執行結果：

Map用泛型：

每個Map.Entry鍵值對的鍵型別是String，值型別是String，所以有Map.Entry<String,String>,所有的鍵值對又是組成Set。所以有了型別Set<Map.Entry<String,String>>

package com.example.test;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//Map map=new HashMap();
		HashMap<String,String> map=new HashMap<String,String>();
		map.put("China", "中國");//相當於List的add，第一個引數是key,第二個引數是value
		map.put("FR","法國");
		map.put("JP","日本");
		System.out.println(map.size());
		//如何獲取元素?
		Set<String> s=map.keySet();//返回所有的 鍵
		System.out.println(s);
		//方法一：通過迭代器獲取值
		Iterator<String> itor=s.iterator();
		while(itor.hasNext()) {
			String keystr=itor.next();
			String valstr=map.get(keystr);
			System.out.println(keystr+"---"+valstr);
		}
		//通過鍵獲取值
		System.out.println("**************");
		for(String obj:s) {
			String se=obj;
//			if (se.equals("China")) {;
//				//map.remove(se);
//			}
//			else {
			String valstr=map.get(se);
			System.out.println(se+"---"+valstr);
//			}
		}
		
		//方法三：獲得鍵值對
		System.out.println("**************");
		Set<Map.Entry<String,String>> kvSets=map.entrySet();//Set中每個元素都是Map.Entry型別，鍵值對形式
		for(Map.Entry<String,String> me:kvSets) {
			//Map.Entry<String,String> meNew=(Map.Entry<String,String>)me;
			String key=me.getKey();
			String value=me.getValue();
			System.out.println(key+"---"+value);
		}
		System.out.println("*************");
		map.clear();
		System.out.println(map.isEmpty());
	}

}

執行結果為：

39、Collections:

呼叫sort方法時，會根據集合裡面的型別（比如是元素是：String）的自然排序規則（就是比較字母在26個裡面的ASCII）去排序；

但是如果集合裡面是Dog型別吶？怎麼排序吶？

compareTo()的方法體就是排序規則；

對集合中的什麼型別進行排序，就讓該類要實現Comparable介面，去重寫compartTo()方法；

package com.example.test;

public class Student implements Comparable{//實現介面，普通類得把介面的抽象方法給實現；
	private int id;
	private String name;
	private  String sex;
	public Student() {
		super();//Object為父類
		// TODO Auto-generated constructor stub
	}
	public Student(int id,String name,String sex) {
		super();
		this.id=id;
		this.name=name;
		this.sex=sex;
	}
	//Shift+alt+s
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	@Override
	public int compareTo(Object o) {
		// TODO Auto-generated method stub
		//如果我比你大，則返回1；
		//stu是傳過來要進行比較的學生物件；
		Student stu=(Student)o;
		//要讓stu和我當前的這個學生物件（this）進行比較；
		if(this.id==stu.id) {
			return 0;
		}
		else if (this.id>stu.id) {
			return 1;
		}
		else if (this.id<stu.id) {
			return -1;
		}
		return 0;
	}
}

package com.example.test;

import java.util.ArrayList;
import java.util.Collections;

public class StuListDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student stu1=new Student(1,"zhangsan","男");
		Student stu2=new Student(2,"zhangsan2","男");
		Student stu3=new Student(3,"zhangsan3","男");
		ArrayList<Student> list=new ArrayList<Student>();
		list.add(stu1);
		list.add(stu2);
		list.add(stu3);
		Collections.sort(list);//不知道student型別按什麼排序；得自定義排序規則
		for(Student stu:list) {
			System.out.println(stu.getId()+"--"+stu.getName());
		}
	}

}

執行結果：

用name來比較大小吶？

package com.example.test;

import java.util.ArrayList;
import java.util.Collections;

public class StuListDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student stu1=new Student(1,"zhangsan","男");
		Student stu2=new Student(2,"heh","男");
		Student stu3=new Student(3,"yes","男");
		ArrayList<Student> list=new ArrayList<Student>();
		list.add(stu1);
		list.add(stu2);
		list.add(stu3);
		Collections.sort(list);//不知道student型別按什麼排序；得自定義排序規則
		for(Student stu:list) {
			System.out.println(stu.getId()+"--"+stu.getName());
		}
	}

}

package com.example.test;

public class Student implements Comparable{//實現介面，普通類得把介面的抽象方法給實現；
	private int id;
	private String name;
	private  String sex;
	public Student() {
		super();//Object為父類
		// TODO Auto-generated constructor stub
	}
	public Student(int id,String name,String sex) {
		super();
		this.id=id;
		this.name=name;
		this.sex=sex;
	}
	//Shift+alt+s
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	@Override
	public int compareTo(Object o) {
		// TODO Auto-generated method stub
		//如果我比你大，則返回1；
		//stu是傳過來要進行比較的學生物件；
//		Student stu=(Student)o;
//		//要讓stu和我當前的這個學生物件（this）進行比較；
//		if(this.id==stu.id) {
//			return 0;
//		}
//		else if (this.id>stu.id) {
//			return 1;
//		}
//		else if (this.id<stu.id) {
//			return -1;
//		}
//		return 0;
		String s="aaa";
		Student stu=(Student)o;
		return this.name.compareTo(stu.name);//String 類已經重寫過compareTo了。要用規則直接呼叫即可；
	}
}

執行結果：

其中String類中compartTo()方法是：

java菜鳥教程+視訊筆記

22、讀寫檔案

23、重寫

24、方法的重寫規則

25、過載(Overload)

26、方法的過載規則：

27、過載和重寫的區別：

28、重寫+過載=總結

29、多型

30、虛方法

31、虛方法出現在Java的多型特性中

32、多型的實現方式

33、java抽象類

34、繼承：

35、抽象類和介面的區別：

36、介面

37、集合與泛型

第一：集合框架常用的介面有哪些？

第二：這些介面有哪些特點？

37.2、ArrayList（是一個可變陣列）

37.3、LinkedList(是一個列表)

37.4、HashSet

37.5 Map

38、泛型：

39、Collections:

相關推薦