JavaSe基本知識

package com.cfl.util;

import org.apache.commons.collections.map.HashedMap;

import java.util.Map;

public enum Resouce {

_51JOB("51job", 1), ZHILIAN("zhilian", 2), DAJIE("dajie", 3),
HIATOU("haitou", 4), LAGOU("lagou", 5), SHIXIZENG("shixiseng", 6);

private String name ;

private int index ;

private Resouce(String name , int index ){
    this.name = name ;
    this.index = index ;
}

public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public int getIndex() {
    return index;
}
public void setIndex(int index) {
    this.index = index;
}

}

4.3.4 數據類型的劃分

注意：（1）java基本數據類型長度不受系統影響（2）float f = 12.3f 必須加f

4.3.5 基礎數據類型的轉換

（1）boolean 不能和其餘類型相互轉換

（2）容量小自動轉換成容量大的。容量大的轉換容量小的，必須強轉,可能形成數據丟失。

Java語言提供了八種基本類型。六種數字類型（四個整數型（默認是int 型），兩個浮點型（默認是double 型）），一種字符類型，還有一種布爾型。

byte：

byte數據類型是8位、有符號的，以二進制補碼錶示的整數；（256個數字），佔1字節
最小值是-128（-2^7）；
最大值是127（2^7-1）；
默認值是0；
byte類型用在大型數組中節約空間，主要代替整數，由於byte變量佔用的空間只有int類型的四分之一；
例子：byte a = 100，byte b = -50。

short：

short數據類型是16位、有符號的以二進制補碼錶示的整數，佔2字節
最小值是-32768（-2^15）；
最大值是32767（2^15 - 1）；
Short數據類型也能夠像byte那樣節省空間。一個short變量是int型變量所佔空間的二分之一；
默認值是0；
例子：short s = 1000，short r = -20000。

int：

int數據類型是32位、有符號的以二進制補碼錶示的整數；佔3字節
最小值是-2,147,483,648（-2^31）；
最大值是2,147,485,647（2^31 - 1）；
通常地整型變量默認爲int類型；
默認值是0；
例子：int a = 100000, int b = -200000。

long：

long數據類型是64位、有符號的以二進制補碼錶示的整數；佔4字節
最小值是-9,223,372,036,854,775,808（-2^63）；
最大值是9,223,372,036,854,775,807（2^63 -1）；
這種類型主要使用在須要比較大整數的系統上；
默認值是0L；
例子： long a = 100000L，int b = -200000L。
long a=111111111111111111111111(錯誤，整數型變量默認是int型)

long a=111111111111111111111111L(正確，強制轉換)

float：

float數據類型是單精度、32位、符合IEEE 754標準的浮點數；佔4字節    -3.4*E38- 3.4*E38。。。浮點數是有舍入偏差的
float在儲存大型浮點數組的時候可節省內存空間；
默認值是0.0f；
浮點數不能用來表示精確的值，如貨幣；
例子：float f1 = 234.5f。
float f=6.26(錯誤  浮點數默認類型是double類型)
float f=6.26F（轉換正確，強制）
double d=4.55(正確)

double：

double數據類型是雙精度、64位、符合IEEE 754標準的浮點數；
浮點數的默認類型爲double類型；
double類型一樣不能表示精確的值，如貨幣；
默認值是0.0d；
例子：double d1 = 123.4。

boolean：

boolean數據類型表示一位的信息；
只有兩個取值：true和false；
這種類型只做爲一種標誌來記錄true/false狀況；
默認值是false；
例子：boolean one = true。

char：

char類型是一個單一的16位Unicode字符；用 ‘’表示一個字符。。java 內部使用Unicode字符集。。他有一些轉義字符  ，2字節
最小值是’\u0000’（即爲0）；
最大值是’\uffff’（即爲65,535）；能夠當整數來用，它的每個字符都對應一個數字

（3）實數，默認爲double

（4）整數，默認爲int

4.4 運算符和表達式

（1）

（2）自增，自減

（3）邏輯運算符---短路

（4）優先級

（5）三目運算符

4.5 分支

（1）if--else

（2）switch

注意： java 6及如下只能探測int（或自動轉爲int，如：short）的值,java 7及以上能夠探測swString的值

4.6 循環

4.6.1 for,while 和 do--while

（1）異同

for和while是先判斷再執行
do...while是先執行一次再判斷繼不繼續
因此for和while語句塊可能一次都不執行，可是do...while至少會執行一次

(2)當循環次數不太肯定，用while。

(3)continue對while和do-while影響很大

4.6.2 break 和 continue

（1） break跳出整個循環，注意不是跳出if

（2） continue 跳出本次循環，進入下一次循環

4.7 方法

4.8 變量的做用域

4.9 遞歸調用

5. 面向對象

5.1 編程語言的發展

5.2 面向過程的設計思想

5.3 面向對象的設計思想

5.4 對象和類的概念

5.5 類之間的關係

(1)關聯

每每是類中的方法的參數和另外的類有關

（2）繼承

（3）彙集和組合

（4）實現關係

5.6 對象和引用

（1）java中除了基本類型外，都叫引用類型.

5.7 java類的定義

(1) 內存解析

（2）類和對象的關係

5.8 構造函數

(1) 使用new+構造方法建立一個新的對象

（2）與類同名，無返回值

（3）初始化類

（4）執行順序

package constructor;

public class Z {
    Z(){
        System.out.println("Z");
    }
}

package constructor;

public class A extends Z{
    A(){
        System.out.println("A");
    }
    
    static{
        System.out.println("static");
    } 
}

main

package constructor;

public class Main {
    public static void main(String[] args) {
        A a = new A(); 
    }
}

結果

static
Z
A

5.9 對象的建立和使用

（1）內存解析

（2）方法重載

5.10 this關鍵字

5.11 package 和import

（1）默認引用java.lang

5.12 訪問控制

5.13 類的繼承

（1）java是單繼承

（2）構造方法

--子類構造的過程當中，必須調用基類的構造方法。

--子類構造方法能夠用super顯示調用基類的構造方法，不調，則默認調用無參數構造方法

--子類構造方法能夠用super顯示調用基類的構造方法,必須寫在子類構造方法的第一行

--若是子類沒有顯式調用基類的構造方法，而基類又沒有無參數構造方法則報錯

5.14 方法的重寫

（1）重寫要考慮訪問限制

5.14 final關鍵字

5.15 Object類

（1）是全部java類的基類

（2）equals方法（比較是否指向一個地方）

5.16 對象轉型

（1）基類引用能夠指向其子類

（2）基類不可訪問子類新增長的成員

（3）可使用對象instanceof類名來判斷該引用型變量所「指向」的對象是否屬於該類，或其子類

（4）子類對象當基類對象來用，叫向上轉型

（5）父類當子類對象來用，叫向下轉型.(強制轉換)

Animal a = new Animal();

a = new Dog();//

if(a instanceof Dog )
{
    Dog g = (Dog) a;//強制轉換,數據仍在
}

5.17 多態

5.18 抽象類

（1）用abstract關鍵字來修飾一個類,這個類叫抽象類;用abstract來修飾一個方法叫抽象方法

（2）含有抽象方法的必須聲明爲抽象類,抽象類必須被繼承。

（3）（繼承了抽象類）的非抽象類,抽象方法必須被重寫,（繼承了抽象類）的抽象類能夠不重寫。

（4）抽象類不能實例化

（5）抽象方法只需聲明,而不須要實現

5.19 final關鍵字

（1）final的值不能改變

（2）final的方法不能被重寫

（3）final的類不能被繼承

寫類庫用的比較多

5.20 接口

（1）是抽象方法和常量值的定義的集合

這是爲了不多繼承的父類變量的重複，設置爲靜態變量，讓他不屬於任何類。

（2）一種特殊的抽象類，只包含常量和方法的定義,沒有變量和方法實現。

6. 異常（Exception）

（1）全部異常類的根源：Throwable

（2）Error ：系統異常，沒法處理

（3）Exception ：可處理可catch的錯誤

（4）RuntimeException ：

--頻繁出現，能夠不捕捉,如：被0除，下標溢出。

（5）必須捕捉的Excetion 如 IOException

（6）有返回值的方法，return語句在try{}中，必須先執行完finally再返回。

package exception;

public class Main {
    public static void main(String[] args) {
        int k = f();
        System.out.println(k);
    }

public static int f(){
	
	int i = 2 ;
	int j = 1 ;
	try{
		int x = i/j ;
		return 0 ;
	}catch(Exception e){
		e.printStackTrace();
	}
	finally{
		System.out.println("finally");
	}	
	return 0 ;
}

}

結果

finally
0

（7）先捕捉小的異常，再捕捉大的

（8）異常和重寫

7. 數組（Array）

7.1 一維數組

（1）動態初始化

int a = new int [3];
a[0] = 1 ;
a[1] = 2 ;
1[2] = 3;

（2）靜態初始化

int a = {1,2,3};

Date days []{
    new Date(1,4,2018),
    new Date(1,5,2018)
}

(3) 默認值

Date days[] = new Date[3];
System.out.println(days[0]);

結果：null

7.2 二維數組

(1) 靜態初始化

int a[][] = new {{1,2,3},{3,4,5,6},{7,8,9}};

(2) 數組的聲明應該按照高維到低維順序(左到右)

8. 基礎類（經常使用類）

8.1 String 和 StringBuffer

（1）String 經常使用方法

（2）StringBuffer 經常使用方法

（3）String和StringBuffer比較

--Stirng 是不可變的字符序列，修改時構建新的，是不斷copy

--StringBuffer是可變的，可直接修改

8.2 包裝類

8.3 Math和File

（1）Math 經常使用方法

（2）File 經常使用方法

--遞歸列出文件樹形結構

9. 輸入輸出流（I/O Stream）

9.1 Java流式輸入輸出原理

9.2 Java流類的分類

9.3 輸入/輸出流類

--站在程序角度

9.3.1 InputStream

（1）組織關係

（2）基本方法

9.3.2 OutputStream

（1）組織關係

（2）基本方法

9.3.3 Reader

（1）組織關係

（2）基本方法

9.3.4 Writer

（1）組織關係

（2）基本方法

9.4 常見的節點流和處理流

--原始的管道，節點流。套在其餘管道流上的，叫處理流

（1）節點流

（2）處理流

9.5 文件流

--例子 FileInputStream

package io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class IOMain {
    public static void main(String[] args) {
	
	FileInputStream fis = null;
	
	FileOutputStream fos = null;
	
	try {
		 fis = new FileInputStream("C:/Users/L/Desktop/test2.txt");
		 
		 fos = new FileOutputStream("C:/Users/L/Desktop/x.txt");
		 
		 int c ;
		 
		 while((c=fis.read())!=-1){
			 fos.write(c);
			 fos.flush();
		 }
		 System.out.println("ok");
		 
	} catch (FileNotFoundException e) {
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}
}

--FileReader

package io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class IOMain2 {
    public static void main(String[] args) {
	
	FileReader fis = null;
	
	FileWriter fos = null;
	
	try {
		 fis = new FileReader("C:/Users/L/Desktop/test2.txt");
		 
		 fos = new FileWriter("C:/Users/L/Desktop/x.txt");
		 
		 int c ;
		 
		 while((c=fis.read())!=-1){
			 fos.write(c);
			 System.out.println((char)c);
			 fos.flush();
		 }
		 System.out.println("ok");
		 
	} catch (FileNotFoundException e) {
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}
}

--BufferedReader

package io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class IOMain3 {
    public static void main(String[] args) {
	
	BufferedReader fis = null;
	
	BufferedWriter fos = null;
	
	try {
		
		 fis = new BufferedReader(new FileReader("C:/Users/L/Desktop/test2.txt"));
		 
		 fos = new BufferedWriter(new FileWriter("C:/Users/L/Desktop/y.txt"));
		 
		 String c ;
		 
		 while((c=fis.readLine())!=null){
			 fos.write(c);
			 System.out.println(c);
			 fos.flush();
		 }
		 System.out.println("ok");
		 
	} catch (FileNotFoundException e) {
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}
}

9.6 緩衝流

9.7 數據流

9.8 轉換流

9.9 Print流

9.9 Object流

10.容器/泛型（Collection / Generic）

--1 1 3 6 1個圖，1個類，3個知識點，6個接口

10.1 組織關係圖

10.2 一個類

10.3 6個接口

10.3.1 Collection接口

10.3.2 Set

--數據對象無順序，不能夠重複（equals），能夠和集合相呼應

--重寫equals和hashcode,肯定判斷重複的條件

--JDK API中Set的容器類有HashSet，和TreeSet

10.3.3 List

--數據對象有順序，能夠重複

--JDK API中List的容器類有ArrayList，LinkList

10.3.4 Map

--鍵值對存儲，鍵不可重複（覆蓋）

--JDK API中Set的容器類有HashMap，和TreeMap

--基本方法

--打包，解包（強制轉換）

--hashMap的實現原理（JDK7）

https://blog.csdn.net/jeffleo/article/details/54946424

--JDK7 和 JDK8 hashMap的實現原理異同

http://www.importnew.com/23164.html

--各類容器實現類的實現原理（也有hashMap）

http://wiki.jikexueyuan.com/project/java-collection/hashmap.html

10.3.5 Iterator

（1）三個方法

--hasNext() , next() , remove()

10.3.6 Comparable接口

--注意實現Comparable接口，經過實現comparaTo方法，肯定排序方式

10.4 衡量標準（如何選擇數據結構）

--Array 讀快改慢

--Linked 讀慢改快

--Hash 二者之間

10.5 3個知識點

--加強for

--Generlic（泛型）容器聲明時肯定對象的類型

--打包，解包

11. 線程（Thread）

11.1 線程的基本概念

--線程是一個程序的不一樣執行路徑

（1）直接調用run方法

和普通的方法調用沒有區別

11.2 線程的建立和啓動

（1）繼承Thread

（2）實現Runnable接口 (推薦)

11.3 線程的調度和優先級

11.4 線程的狀態控制

11.4.1 狀態轉換圖

11.4.1 線程控制的基本方法

（1）sleep方法是一個靜態方法

Thead.sleep() //當前正在執行的線程睡眠

（2）join方法

11.5 線程的同步

（1）synchronized

synchronized 關鍵字，表明這個方法加鎖,至關於無論哪個線程(例如線程A)，運行到這個方法時,都要檢查有沒有其它線程B(或者C、 D等)正在用這個方法(或者該類的其餘同步方法)，有的話要等正在使用synchronized方法的線程B(或者C 、D)運行完這個方法後再運行此線程A,沒有的話,鎖定調用者,而後直接運行。它包括兩種用法:synchronized 方法和 synchronized 塊。

Java語言的關鍵字，可用來給對象和方法或者代碼塊加鎖，當它鎖定一個方法或者一個代碼塊的時候，同一時刻最多隻有一個線程執行這段代碼。當兩個併發線程訪問同一個對象object中的這個加鎖同步代碼塊時，一個時間內只能有一個線程獲得執行。另外一個線程必須等待當前線程執行完這個代碼塊之後才能執行該代碼塊。然而，當一個線程訪問object的一個加鎖代碼塊時，另外一個線程仍能夠訪問該object中的非加鎖代碼塊。

（2）wait() 須要使用synchronized ，讓訪問本對象的線程（得到鎖的線程）等待，釋放鎖

（3）notify() 通常和wait()配對使用，叫醒一個在本對象睡眠的線程。

--ProducerConsumer

package thread;

public class ProducerConsumer {
    public static void main(String[] args) {
        Repository re = new Repository();
        Producer p[] = new Producer[4];
        Customer c[] = new Customer[2];
	
	for (int i = 0; i < p.length; i++) {
		p[i] = new Producer(re);
		new Thread(p[i]).start();
	}
	
	for (int i = 0; i < c.length; i++) {
		c[i] = new Customer(re);	
		new Thread(c[i]).start();
	}
	
	
}

} --Book

class Book {
    int id ;
    
    public Book(int id) {
        super();
        this.id = id;
    }
    
    @Override
    public String toString() {
        return "book : " + id;
    }

}

--Repository

class Repository {

int index = 0 ;

Book[] book = new Book[5];



public int getIndex() {
	return index;
}

public void setIndex(int index) {
	this.index = index;
}

public Book[] getBook() {
	return book;
}

public void setBook(Book[] book) {
	this.book = book;
}

public synchronized void push(Book b){
	while(index==book.length){
		try {
			System.out.println("倉庫滿了，等待");
			this.wait();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	this.notifyAll();
		
	book[index] =  b;
	
	index++;
} 
 
public synchronized Book pop(){
	Book b ;	

	while(index == 0){
		try {
			System.out.println("  倉庫沒有書，等待");
			this.wait();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	this.notifyAll();
	
	System.out.println("index"+index);
	
	
	index--;
	
	b = book[index];

	return b;
}

}

--Producer

class Producer implements Runnable{

Repository repository = null;

public Producer(Repository repository) {
	this.repository = repository;
}

@Override
public void run() {
	for (int i = 0; i < 2000; i++) {
		Book b = new Book(i);
		repository.push(b);
		System.out.println("生產了"+b+"   倉庫目前書的數量：" + repository.getIndex());
		
		try {
			Thread.sleep((long) (1000*Math.random()));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
}

--Customer

class Customer implements Runnable{

Repository repository = null;	

public Customer(Repository repository) {
	super();
	this.repository = repository;
}

@Override
public void run() {
	for (int i = 0; i < 2000; i++) {
		Book b = repository.pop();
		System.out.println("消費了"+b+"  倉庫目前書的數量：" + repository.getIndex());
		try {
			Thread.sleep((long) (1000*Math.random()));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

}

注意：

while(index==book.length){
		try {
			System.out.println("倉庫滿了，等待");
			this.wait();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

要用while不用if，不然被叫醒後，不會再判斷是否index==book.lengt，而是繼續往下執行。

12.網絡編程（TCP/UDP）

--網絡編程！=網站編程

12.1 網絡基礎

12.2 TCP/IP協議

12.3 IP地址

12.4 Socket通訊

（1）TCP/UDP

13. GUI

14. Meta Data

15 正則表達式

import java.io.*;
import java.util.Scanner;
import java.util.regex.*;

public class Example {
    public static void main( String args [])
    {
            Scanner read = new Scanner (System.in);
            
            System.out.println("Please input String :");
            
            /**********************   
            *    X+ 表示X出現了1次或屢次
            *    X？ 表示出現了0次或1次
            *    \56表示小數點
            *    X{n} 表示剛好出現n次
            *    X{n,} 表示X出現次數>=n
            *    XY表示X的後綴爲Y
            *    X|Y 表示X或Y
            *    \\p{Alpha}表示字母
            *    \\w  表示可用於標識符的字符
            *    [a-z&&[def]] 表明 d e f中任意一個 （交）
            *    [a-f&&[^bc]]  表明 adef 的差 
            *    
            *    \\d表示0-9中任何一個數字
            */
            
//    	    String s = "(http://|www)\56?\\w+\56{1}\\w+\56{1}\\p{Alpha}+";  //篩選網址
            
//    	    String s  = "[abc]";   //[]表示其中任何一個   
            
//    	    String s ="[a-d]"; //  a-d 表示從a到d中一個
            
//例14    	String s ="[0-9]+\56?[0-9]*";  //篩選出字符串中的浮點數

            //String s ="1{3,4}"; //  注意貪婪匹配，輸入1111 111 第一次1111 第二次111
            
//    	    String s ="a1*"; //        注意貪婪匹配，輸入1111 111 第一次1111 第二次111
            
            String s ="P=\\{+.+\\}+";
            
            Pattern pattern = Pattern.compile(s);   //匹配條件
                        
            Matcher matcher = pattern.matcher(read.nextLine());  //要匹配的目標字符串
            

            
            while(true)
            {
                if (matcher.find())
                {

                    System.out.printf("%s can find ! , %d--%d\n",matcher.group(),matcher.start(),matcher.end());
                    
                    break;
                }
                else 	
                {
                    break;  	  		
                }
            }
//         	System.out.println("字母個數爲： "+n);

    
    }	  	
                
    }

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。

JavaSe基本知識

JavaSe複習

1. java體系

2. java核心體制

2.1 java虛擬機

2.2 java回收機制

3. 環境配置

4. 基礎語法

4.1 標識符

4.1.1 什麼是表示符

4.1.2 命名規則

4.2 關鍵字

4.3 數據類型

4.3.1 常量

4.3.2 變量

4.3.3 枚舉類型

4.3.4 數據類型的劃分

4.3.5 基礎數據類型的轉換

4.4 運算符和表達式

4.5 分支

4.6 循環

4.6.1 for,while 和 do--while

4.6.2 break 和 continue

4.7 方法

4.8 變量的做用域

4.9 遞歸調用

5. 面向對象

5.1 編程語言的發展

5.2 面向過程的設計思想

5.3 面向對象的設計思想

5.4 對象和類的概念

5.5 類之間的關係

5.6 對象和引用

5.7 java類的定義

5.8 構造函數

5.9 對象的建立和使用

5.10 this關鍵字

5.11 package 和import

5.12 訪問控制

5.13 類的繼承

5.14 方法的重寫

5.14 final關鍵字

5.15 Object類

5.16 對象轉型

5.17 多態

5.19 final關鍵字

5.20 接口

6. 異常（Exception）

7. 數組（Array）

7.1 一維數組

7.2 二維數組

8. 基礎類（經常使用類）

8.1 String 和 StringBuffer

8.2 包裝類

8.3 Math和File

9. 輸入輸出 流 （I/O Stream）

9.1 Java流式輸入輸出原理

9.2 Java流類的分類

9.3 輸入/輸出流類

9.3.1 InputStream

9.3.2 OutputStream

9.3.3 Reader

9.3.4 Writer

9.4 常見的節點流和處理流

9.5 文件流

9.6 緩衝流

9.7 數據流

9.8 轉換流

9.9 Print流

9.9 Object流

10.容器/泛型 （Collection / Generic）

10.1 組織關係圖

10.2 一個類

10.3 6個接口

10.3.1 Collection接口

10.3.2 Set

10.3.3 List

10.3.4 Map

10.3.5 Iterator

10.3.6 Comparable接口

9. 輸入輸出流（I/O Stream）

10.容器/泛型（Collection / Generic）

11. 線程（Thread）

12.網絡編程（TCP/UDP）