所有的流在使用完畢時，都需要調(diào)用close方法進行關(guān)流，釋放資源。
由于流操作都會有異常，如果發(fā)生異常就有可能導(dǎo)致close方法不能被調(diào)用
所以，IO異常一定要處理，close方法寫在finally語句中
1.InputStream : 輸入字節(jié)流 方法： read()從流(關(guān)聯(lián)的設(shè)備)中讀一個字節(jié)
** int read(buf):從流中讀取n個字節(jié)放入緩沖區(qū)，方法會返回一個讀取字節(jié)的個數(shù) ips-->buf
讀到一個-1，說明讀到了流的末尾
------------------------------------------------------------------------------------------
|---FileInputStream: 重載的構(gòu)造函數(shù) (String fileName) (File file)
2.OutputStream： 輸出字節(jié)流 :方法 write(int c)將一個字節(jié)寫入流 (byte)c
write(buf,offset,len)將指定字節(jié)數(shù)組的一部分寫入流。 buf-->ops
-------------------------------------------------------------------------------------------
|---FileOutputStream: 重載的構(gòu)造函數(shù) (Strng fileName) (String fileName, boolean append)
append:指定數(shù)據(jù)是否追加到文件的末尾，默認是false，覆蓋原有的數(shù)據(jù)，
設(shè)置為true，將數(shù)據(jù)追加到文件的末尾
3.Reader：輸入字符流 int read() 讀一個字符 int read(buf) buf是char[]類型
|---FileReader: FileReader = InputStreamReader(FileInputStream) 只做了一件事：解碼(父類在做)
4.Writer：輸出字符流 write(int c) (char)c \ write(String str)
|---|---FileWriter: FileWriter = OutputStreamWriter(FileOutputStream) 只做了一件事：編碼
理解(會用)：
1.裝飾設(shè)計模式： 對原有的類的進行包裝，對方法進行增強
BufferedReader：實現(xiàn)緩沖的功能 創(chuàng)建包裝流對象的時候，必須組合一個被包裝的底層流
增加了一個新方法 String readLine() 讀一行
|--LineNumberReader: 增加了行號功能，getLineNumber() 、setLineNumber()
BufferedWriter：實現(xiàn)了緩沖功能 new BufferedWriter(new FileWriter("1.txt");
增加了新方法 newLine() 另起一行
BufferedInputStream：實現(xiàn)緩沖的功能
BufferedOutputStream：實現(xiàn)緩沖的功能
2.InputStreamReader： 轉(zhuǎn)換流 : 包裝，實現(xiàn)了編碼解碼的功能
new InputStreamReader(new FileInputStream("1.txt"));
3.使用包裝流包裝System.in，讀鍵盤方便，可以讀一行
BufferedReader br =
new BufferedReader(new InputStreamReader(System.in));
String line = br.readLine();
IO需要會寫的程序： BufferedReader和BufferedWriter包裝InputStream和OutputStream，讀一行寫一行
BufferedReader和BufferedWriter包裝Reader和Writer
BufferedInputStream和BufferedOutputStream包裝InputStream和OutputStream
用基礎(chǔ)流讀寫，自定義數(shù)組作為緩沖區(qū)，實現(xiàn)拷貝
-------以下做一個總結(jié):
io流:數(shù)據(jù)傳輸?shù)闹修D(zhuǎn)站-->IO流-->目的地
IO流一般都是成對出現(xiàn)的,也就是說按照流的分向:輸入流-->輸出流
IO流按照操作來分: 字節(jié)流-->字符流
一.字符流
基類:Reader(讀)Writer(寫)
|-Reader
|--BufferedReader:對Reader進行了包裝,提供了緩沖區(qū)(8192),有ReadLine()方法
構(gòu)造函數(shù):BufferedReader(Reader r);
|--InputStreamReader:轉(zhuǎn)換流:將字節(jié)流轉(zhuǎn)換成字符流:new InputStreamReader(System.in);
|--FileReader:讀取文件的字符流,FileReader(File file) FileReader(String fileName);
|-Writer
|--BufferedWriter:包裝流:常用的方法write(String s)、flush()刷新 newLine()換行
構(gòu)造函數(shù):BufferedWriter(Writer w);
|--OutputStreamWriter:轉(zhuǎn)換流: new OutputStreamWriter(System.out);
|--FileWriter:寫入文件,FileWriter(File file) FileWriter(String fileName)
FileWriter(File file,boolean append),FileWriter(String fileName,boolean append)
當(dāng)append為true,將寫入到文件的末尾處,當(dāng)為false時,從文件開頭開始寫.就會覆蓋原來的.默認為false
二.字節(jié)流:
|-InputStream(輸入流)
|--FileInputStream:讀取文件的字符流,和FileReader基本是一樣
|--FilterInputStream:過濾流,一般不使用,只是針對了InputStream進行了包裝
|--BufferedInputStream:包裝類:BufferedReader(InputStream in),提供緩存功能
|-OutputStream(輸出流)
|--FileOutputStream:寫入文件的字符流,和FileWriter基本一樣
|--FilterOutputStream
|--BufferedOutputStream:包裝類:BufferedWriter(OutputStream out);
三.使用IO流必須要捕獲異常,原因在于我們必須要還資源(關(guān)閉流)
1 FileWriter fw = null;
2 try
3 {
4 fw = new FileWriter("src/1.txt");
5 }
6 catch(IOException e)
7 {
8 e.printStractTrace();
9 }
10 finally
11 {
12 try{if(fw!=null)fw.close();}catch(IOException){e.printStackTrace();}
13 }
四.File文件類
1.構(gòu)造方法:
File(File parnt,String child)
根據(jù)prent抽象路徑名和child路徑名字符串創(chuàng)建一個新的file實例.
File(String pathname)
通過將給定的路徑名字來創(chuàng)建一個新的file實例.
File(String parent, String child)
根據(jù) parent 路徑名字符串和 child 路徑名字符串創(chuàng)建一個新 File 實例.
2.常用方法:
isFile:判斷對象是否是一個標準文件
isDirectory:判斷對象是否為一個文件夾
isAbsolute:判斷是否為一個絕對路徑
exists:判斷對象指定的文件是否存在
createNewFile:根據(jù)對象的描述創(chuàng)建一個對象
getName:獲得文件名
getPath:獲得路徑名
getParent:獲得文件的父級抽象路徑
getAbsolutepath:獲得文件的絕對路徑名
mkdir:創(chuàng)建此抽象路徑指定的目錄,(只能在存在的文件夾下創(chuàng)建一個目錄)
mkdirs:創(chuàng)建此抽象路徑指定的目錄,包括所有必須但不存在的目錄.創(chuàng)建多級目錄(c:/a/b/c)
list(FilenameFilter filter)：根據(jù)指定過濾器遍歷文件夾中的所有文件，返回String[]
如果對象為標準文件，則返回null，如果對象是一個空文件夾，則返回空數(shù)組。length為0
FilenameFilter是一個接口，只有一個方法accept，我們需要實現(xiàn)接口的accept方法。
實現(xiàn)類是給list方法自動調(diào)用的
方法的參數(shù)是list方法傳給我們的，返回的結(jié)果也是給list方法去用。
listFiles：和list基本一樣，返回值類型不一樣，返回File[]。
常用案例：遍歷目錄下所有的文件和文件夾 拷貝一個文件夾 .
五:RandomAccessFile 文件流,可以讀寫
1.RandomAccessFile(File file,String mode)、RandomAccessFile(String fileName,String mode)
mode:常用的: r,只讀 rw讀寫
2.有很多read和write方法.
seek方法,指定從那個位置開始讀seek(0) ,從原有的位置覆蓋掉
skipBytes(int n)：跳過多少個字節(jié)
六:PrintStream、PrintWriter打印流
有一個特殊的方法print可以實現(xiàn)打印
write方法是直接將字節(jié)和字符寫出去
print：首先調(diào)用對象的toString方法轉(zhuǎn)成字符串(如果是基本數(shù)據(jù)類型，會先自動裝箱)
再將字符串編碼成字節(jié)數(shù)組，調(diào)用write方法寫出去
七:SequenceInputStream序列流
可以將多個字節(jié)流組合起來
構(gòu)造方法：SequenceInputStream(Enumeration<? extends InputStream> e)
//Enumeration可以通過Vector來獲得，如果用的是ArrayList，如何獲得呢？
SequenceInputStream(InputStream in1,InputStream in2)
八:ObjectInputStream、ObjectOutputStream操作對象的字節(jié)流
一般成對出現(xiàn)
使用writeObject方法寫入的對象，只能由readObject方法讀出來
操作的對象必須實現(xiàn)java.io.Serializable序列化接口，該對象才可以被序列化和反序列化。
序列化: Java中規(guī)定的一種保存對象的數(shù)據(jù)格式
九:DataInputStream、DataOutputStream操作基本數(shù)據(jù)類型，格式化數(shù)據(jù)
readInt、writeInt等方法。
writeInt寫入一個整數(shù)，文件大小為4字節(jié)。證明就是把基本數(shù)據(jù)類型對應(yīng)的字節(jié)寫出去了，沒有丟失精度
十:ByteArrayInputStream、ByteArrayOutputStream對Byte數(shù)組進行讀寫的字節(jié)流，針對內(nèi)存進行讀寫
源和目的地都是內(nèi)存，一般用于對內(nèi)存中的數(shù)據(jù)進行處理。
十一:PipedInputStream、PipedOutputStream管道流
1、輸入管道流
構(gòu)造方法：PipedInputStream(PipedOutputStream pos)實現(xiàn)拼接
也可以通過connect(PipedOutputStream pos)方法進行拼接
2、輸出管道流
構(gòu)造方法：PipedOutputStream(PipedInputStream pis)實現(xiàn)拼接
也可以通過connect(PipedInputStream pis)方法進行拼接
1 --Test:序列化與反序列化..
2 package com.java.kudy_Say;
3
4 import java.io.FileNotFoundException;
5 import java.io.FileOutputStream;
6 import java.io.IOException;
7 import java.io.ObjectOutputStream;
8 import java.io.Serializable;
9 import java.util.ArrayList;
10 import java.io.ObjectInputStream;
11 import java.io.FileInputStream;
12 /*
13 序列化與反序列化的過程
14 */
15 public class Test {
16
17 public static void main(String[]args) throws FileNotFoundException, IOException,ClassNotFoundException
18 {
19
20 /* Student s1 = new Student("張三",18);
21 Student s2 = new Student("王五",19);
22 Student s3 = new Student("李四",20);
23 Student s4 = new Student("大毛",21);
24 ObjectOutputStream oos =
25 new ObjectOutputStream(new FileOutputStream("f:/a.txt"));
26 ArrayList<Student> al = new ArrayList<Student>();
27 al.add(s1);
28 al.add(s2);
29 al.add(s3);
30 al.add(s4);
31 oos.writeObject(al);
32 oos.close();//關(guān)閉流
33 //首先我們把內(nèi)容放到一個集合里面去
34 */
35 ObjectInputStream ois =
36 new ObjectInputStream(new FileInputStream("f:/a.txt"));
37 ArrayList<Student> al = (ArrayList<Student>)ois.readObject();
38 for(Student s :al)
39 System.out.println(s);
40 ois.close();
41
42
43
44 }
45 }
46
47 //必須要實現(xiàn)一個類
48 class Student implements Serializable
49 {
50 private String name;
51 private int age;
52 Student(){}
53 Student(String name,int age)
54 {
55 this.name = name;
56 this.age = age;
57 }
58 public String toString()
59 {
60 return name+"@"+age;
61 }
62 }
posted @
2012-08-18 19:51 、小細 閱讀(269) |
評論 (0) |
編輯 收藏教程由JAVA中文網(wǎng)整理校對發(fā)布(javaweb.cc)
Abstract Window Toolkit(AWT)抽象窗口工具集
一個用本地圖形組件實現(xiàn)的圖形接口。這些組件提供了大部分的本地組件。這個接口正逐步被Swing組件所替代，參見Swing Set.
Abstract 抽象的
一個Java語言中的關(guān)鍵字，用在類的聲明中來指明一個類是不能被實例化的，但是可以被其它類繼承。一個抽象類可以使用抽象方法，抽象方法不需要實現(xiàn)，但是需要在子類中被實現(xiàn)
abstract class 抽象類
含有一個或多個抽象方法的類，不能被實例化。定義抽象類的目的是使其他類能夠從它繼承，并且通過實現(xiàn)抽象方法使這個類具體化
abstract method 抽象方法
沒有實現(xiàn)的方法
access control 訪問控制
控制用戶或程序訪問資源的權(quán)限，保證資源的一致性的方法
API 應(yīng)用程序接口
Application Programming Interface的縮寫。指導(dǎo)應(yīng)用程序開發(fā)人員訪問類方法和類狀態(tài)的說明
applet 小應(yīng)用程序
通常在Web瀏覽器中執(zhí)行的一個Java組件，同樣可以在其他的支持applet模型的應(yīng)用程序或設(shè)備中執(zhí)行
Applet container applet容器
一個支持applet的容器
argument 參數(shù)
在函數(shù)調(diào)用中使用的數(shù)據(jù)項。一個參數(shù)可以是常量、變量或表達式
array 數(shù)組
相同類型的數(shù)據(jù)的集合，每一個數(shù)據(jù)項通過一個整數(shù)唯一標識
ASCII
American Standard Code for Information Interchange的縮寫。一個標準的7位字符編碼，參見Unicode
Bean
一個可以重用的組件，可以通過組合Bean來創(chuàng)建應(yīng)用程序
bean-managed persistence
當(dāng)一個實體bean實例和資源管理器交換數(shù)據(jù)的時候，由實體bean實例來管理
bean-managed transaction
Enterprise Bean定義事務(wù)的界限的時候
binary operator 二值操作符
有兩個操作數(shù)的操作符
bit 位
計算機中表示信息的最小單位，只有0和1兩個值
bitwise operator 位操作符
并行的對一個或多個操作數(shù)的位進行單獨的操作。比如二進制邏輯運算符（&,|,^），二進制移位符（<<,>>,>>>）和求補運算符（~）
block 塊
在Java語言中，任何被大括號括起來的程序段。
boolean 邏輯型
指一個表達式或一個變量只能有true或者false兩種類型。Java語言提供了boolean類型以及true和false兩個常量
break
一個Java的關(guān)鍵字，用來改變程序執(zhí)行流程，立刻從當(dāng)前語句的下一句開始執(zhí)行從。如果后面跟有一個標簽，則從標簽對應(yīng)的地方開始執(zhí)行
business logic 商業(yè)邏輯
實現(xiàn)某個應(yīng)用功能的代碼。在Enterprise JavaBeans模型中，這種邏輯是由某個Enterprise Javabean的方法實現(xiàn)的。
business method 商業(yè)方法
某個Enterprise Javabean的方法用來實現(xiàn)商業(yè)邏輯或者某個應(yīng)用的規(guī)則。
Byte 字節(jié)
順序的8位bit，Java語言中有對應(yīng)的byte類型
bytecode 字節(jié)碼
由Java編譯器生成的跟機器相關(guān)代碼，由Java解釋器執(zhí)行
callback methods 回調(diào)方法
組件的方法，由存放該組件的容器來調(diào)用的，用來在組件生命周期中通知它重要的事件
case
Java語言的關(guān)鍵字，用來定義一組分支選擇，如果某個值和switch中給出的值一樣，就會從該分支開始執(zhí)行。
casting
強制類型轉(zhuǎn)化換
catch
Java的一個關(guān)鍵字，用來聲明當(dāng)try語句塊中發(fā)生運行時錯誤或非運行時異常時運行的一個塊。
char
Java語言的一個關(guān)鍵字，用來定義一個字符類型
class 類
在Java語言中定義一個特定類的實現(xiàn)。一個類的定義包含成員變量，成員方法，還有這個類實現(xiàn)的接口，以及這個類的父類。如果沒有顯式指明父類，那么它的父類會隱式的被認為是Object。
class method 類方法
不需要引用特定對象就可以使用的方法，類方法的作用域是全局的，而不是某個特定的類實例，也被稱作靜態(tài)方法static method，參看instance method
classpath 類路徑
Classpath是一個環(huán)境變量，用來向Java虛擬機和基于Java的應(yīng)用程序指明系統(tǒng)類庫和用戶類庫的位置（比如，工具包在JDK1.1.X/bin目錄中）
class variable 類變量
一個和整個類相關(guān)的數(shù)據(jù)項，而不是只和某個實例，類變量在類定義中定義，也被稱作static field,參看instance variable.
codebase
和<APPLET>標簽中的Code屬性配合給出找到applet類的完整路徑：Code給出文件的名字，Codebase指出包含該文件的URL路徑
comment 注釋
在編程語言中被編譯器忽略的解釋性語句。在Java中注釋使用//或/*…*/定界
compiler 編譯器
一個把源代碼翻譯成機器可以執(zhí)行的代碼的程序。Java編譯器把Java源碼翻譯成Java虛擬機能夠識別的字節(jié)碼，參見interpreter
component 組件
一種被容器所支持的應(yīng)用級的軟件單元。組件在使用的時候是可配置的。J2EE平臺定義了四種類型的組件：Enterprise Bean，Web components，applets和application client。
component contract
組件和它的容器之間的規(guī)范。這種規(guī)范包括：組件的生命周期的管理，一個上下文的接口，組件可以通過它獲得容器的信息和服務(wù)，以及每個容器必須提供的一系列服務(wù)。
component environment
應(yīng)用程序組件提供商定義的一個集合，使組件在J2EE組件的名字空間中可見。環(huán)境選項由組件的使用描述符指明。每一個組件命名并訪問它的環(huán)境配置值通過使用java:comp/evn JNDI上下文。這些值可以是組件所依賴的一個對象，比如JDBC DataSouce，或者一個簡單值，比如一個稅率。
Connector 連接器
一個標準的擴充機制使容器可以提供到EISs的連接。一個連接器連接到特定的EIS，由資源適配器和針對EIS的應(yīng)用開發(fā)工具組成。一個資源適配器插入到一個容器通過在連接器體系結(jié)構(gòu)中定義的系統(tǒng)級的聯(lián)系。
connector architecture
一個集成J2EE和EISs的體系結(jié)構(gòu)。這個體系結(jié)構(gòu)中有兩大部分：一個EIS廠商提供的資源適配器和一個允許這個適配器插入的J2EE服務(wù)器。這個體系結(jié)構(gòu)定義了一系列資源適配器為了能插入J2EE服務(wù)器而必須支持的規(guī)范，比如事務(wù)，安全，資源管理。
Constructor 構(gòu)造函數(shù)
一個創(chuàng)建對象的偽方法。在Java語言中構(gòu)造函數(shù)是和類同名的成員函數(shù)。構(gòu)造函數(shù)一般用在new操作符之后。
Container 容器
一個為組件提供生命周期管理，安全，配置，和運行時服務(wù)的實體。每一個類型的容器（EJB, Web, JSP, servlet, applet, 和application client）也會提供各自組件相關(guān)的服務(wù)
container-managed persistence
當(dāng)一個實體bean實例和資源管理器交換數(shù)據(jù)的時候，由資源管理器來管理
container-managed transaction
當(dāng)一個EJB容器定義一個事務(wù)的邊界的時候，一個Bean必須使用這種事務(wù)類型
continue
一個Java的關(guān)鍵字，用來打斷當(dāng)前循環(huán)過程，從當(dāng)前循環(huán)的最后重新開始執(zhí)行，如果后面跟有一個標簽，則從標簽對應(yīng)的地方開始執(zhí)行。
core class 核心類
一個Java平臺上的標準的公共類或接口。Java平臺的核心類，至少在所有的能支持Java的操作系統(tǒng)的平臺上都是可用的。一個完全用Java編寫的程序只需要Java核心類就可以運行了，這意味著它能夠在任何地方運行，參看100% Pure Java(TM).
Core Packages 核心包
在任何Java平臺和任何兼容平臺上必須被支持的API的集合。
Declaration 聲明
一個在標識符和屬性之間建立聯(lián)系的語句，不需要必要的存儲分配或具體實現(xiàn)。參見definition
default 缺省的
一個Java語言的關(guān)鍵字，作為在switch語句中的所有case之后的可選項，如果所有的case條件都沒有被滿足，就會執(zhí)行default語句
delegation 授權(quán)
一種某個負責(zé)人批準另外一個負責(zé)人在一定限制下使用它的身份或特權(quán)的行為
deprecation
指不再推薦的類，接口，構(gòu)造函數(shù)，方法或成員變量，可能在以后的版本中會消失
derived from
類X "derived from" 類Y就是指類X是從類Y繼承過來的，參見subclass, superclass
distributed 分布的
在多于一個的地址空間內(nèi)運行
distributed application 分布式應(yīng)用
由不同的運行于分離的運行環(huán)境下的組件構(gòu)成的應(yīng)用程序，通常是在不同的平臺上通過網(wǎng)絡(luò)互聯(lián)起來。典型的分布式應(yīng)用是二端（Client/Server），三端（client/middleware/server）和n端（client/multiple middleware/multiple server）
do
一個Java語言的關(guān)鍵字，用來聲明一個循環(huán)，這個循環(huán)的結(jié)束條件可以通過while關(guān)鍵字設(shè)置
DOM
Document Object Model的縮寫。一棵由擁有包含遍歷這棵樹并且生成相應(yīng)XML文檔的接口的對象構(gòu)成的樹，符合W3C的規(guī)范
double
一個Java語言的關(guān)鍵字，用來定義一個double類型的變量
EJB container EJB容器
一個實現(xiàn)了J2EE體系結(jié)構(gòu)中EJB組件規(guī)范的容器。這個規(guī)范指定了一個Enterprise bean的運行時環(huán)境，包括安全，一致性，生命周期，事務(wù)，配置，和其他的服務(wù)。一個EJB容器可以由EJB或者J2EE服務(wù)器提供。
EJB Container Provider EJB容器提供商
提供EJB容器的廠商
EJB context EJB上下文
一個允許Enterprise Bean使用容器提供的服務(wù)和獲得客戶-請求（client-invoke）方法調(diào)用者信息的對象
EJB home object
一個提供關(guān)于Enterprise Bean生命周期操作（創(chuàng)建，刪除，查找）的對象。這個對象的類型是由容器的配置工具產(chǎn)生的。EJB home object實現(xiàn)了Enterpeise Bean的home接口。客戶通過引用一個EJB home object來進行生命周期的操作。客戶使用JNDI來定位一個EJB home object
EJB .jar file
一個包含EJB模塊的JAR文件
EJB module
一個由一個或多個Enterprise bean和一個EJB配置描述符組成的軟件單元。
EJB object
實現(xiàn)了enterprise bean的remote接口的對象。客戶不能直接引用一個enterprise bean的實例；客戶總是引用一個EJB object。EJB object的類型是由容器的配置工具生成的。
EJB server
為EJB容器提供服務(wù)的軟件。比如，典型的，一個EJB容器總是依靠一個作為EJB Server一部分的事務(wù)管理器來進行雙向的確認在所有參與的資源管理器之間。J2EE體系結(jié)構(gòu)假設(shè)EJB容器和EJB Server是由同一廠商提供的，所以沒有制定這兩個實體之間的規(guī)范。一個EJB Server可以包含一個或多個EJB Container
EJB Server Provider
提供EJB Server的廠商
EIS resource
一個為客戶提供符合EIS規(guī)范的功能的實體。例子有：一條或多條數(shù)據(jù)庫中的記錄，在一個ERP系統(tǒng)中的一個business object，在一個事務(wù)處理系統(tǒng)中的一個事務(wù)程序
else
一個Java語言的關(guān)鍵字，如果if語句的條件不滿足就會執(zhí)行該語句。
encapsulation 封裝
一個模塊中的內(nèi)部屬性，因為對象會封裝數(shù)據(jù)和實現(xiàn)，使用者可以把對象看作一個能提供服務(wù)的黑匣子。實例變量可以被添加，刪除，或改變。只要這個對象所提供的服務(wù)是不變的，使用這個對象的代碼就可以繼續(xù)使用而不需要修改，參見instance variable, instance method.
enterprise bean
實現(xiàn)商業(yè)任務(wù)和商業(yè)實體的組件；或者是一個entity bean，或者是一個session bean
Enterprise Information System (EIS)
一個包含企業(yè)已經(jīng)存在的獲取企業(yè)級信息的系統(tǒng)的應(yīng)用程序，這些應(yīng)用程序為企業(yè)提供了一個信息結(jié)構(gòu)。一個EIS系統(tǒng)提供很好定義的服務(wù)的集合給它的客戶。這些服務(wù)在客戶看來是本地的和/或者遠程的接口。EIS的例子有：一個ERP系統(tǒng)，一個事務(wù)處理系統(tǒng)的主框架，一個遺留的數(shù)據(jù)庫系統(tǒng)。
Enterprise Bean Provider Enterprise Bean提供商
生產(chǎn)enterprise bean，remote和home接口，配置描述符文件，并把這些打包入JAR文件的應(yīng)用程序開發(fā)人員
Enterprise JavaBeans(TM) (EJB)
一個用于開發(fā)和使用面向?qū)ο蟮模植际降模髽I(yè)級應(yīng)用程序的組件體系結(jié)構(gòu)。使用Enterprise JavaBeans體系結(jié)構(gòu)編寫的軟件是可擴展的，面向事務(wù)的，多用戶的，安全的。
entity bean
一個代表由數(shù)據(jù)庫維護的持久數(shù)據(jù)的enterprise bean。一個entity bean可以管理它自己的持久性，或者把這個功能授權(quán)給它的容器。一個 entity bean由一個主鍵來標識。如果存放entity bean的容器崩潰了，那么這個entity bean，它的主鍵，以及任何遠程的引用都能從崩潰中幸存下來。
ebXML
ebXML建立在XML(Extensive Markup Language)之上，目的是提供一系列模塊化的規(guī)范，使任何地方的任何規(guī)模的企業(yè)都能夠通過Internet指導(dǎo)商業(yè)活動。它提供了公司和組織一個標準的方法來交換數(shù)據(jù)，指導(dǎo)商業(yè)關(guān)系，交流數(shù)據(jù)通過公共的形式，定義并注冊商業(yè)過程
exception 異常
一個在程序執(zhí)行過程中阻止程序正常執(zhí)行的事件，通常是一個錯誤。Java語言通過try，catch和throw關(guān)鍵字支持異常的處理，參見exception
handler
exception handler
一段處理特定類型的異常的代碼。如果程序能夠從異常中恢復(fù)過來，那么在處理完異常之后程序可以繼續(xù)執(zhí)行。
executable content
在HTML文件中執(zhí)行的應(yīng)用程序，參見applet。
extends 繼承
類X 通過extend 類Y來添加功能，或者添加變量，或者添加方法，或者覆蓋類Y的方法。一個接口extends另外一個接口來添加方法。類X稱為類Y的一個子類，參見derived from
field 域
一個類的數(shù)據(jù)成員。除非顯式指明，否則一個field不是static的
final
一個Java語言的關(guān)鍵字。你只能定義一個實體一次，以后不能改變它或繼承它。更嚴格的講：一個final修飾的類不能被子類化，一個final修飾的方法不能被重寫，一個final修飾的變量不能改變其初始值。
finally
一個Java語言的關(guān)鍵字，用來執(zhí)行一段代碼不管在前面定義的try語句中是否有異常或運行時錯誤發(fā)生。
float
一個Java語言的關(guān)鍵字，用來定義一個浮點數(shù)變量
for
一個Java語言的關(guān)鍵字，用來聲明一個循環(huán)。程序員可以指定要循環(huán)的語句，推出條件和初始化變量。
FTP
基本的Internet文件傳輸協(xié)議（File Transfer Protocol）。FTP是基于TCP/IP協(xié)議的，它允許在主機之間通過Internet傳送文件。參見TCP/IP
formal parameter list
在一個方法的定以中指定的參數(shù)。參見actual parameter list
handle
一個標識enterprise bean的對象。客戶可以串行化handle，以后從串行化中恢復(fù)handle來得到一個對enterprise bean的引用
hexadecimal 十六進制的
使用16作為基的計數(shù)系統(tǒng)。記號0-9和a-f（或者A-F）代表了數(shù)字0到15。在Java中16進制數(shù)必須帶有0x前綴。參見octal
hierarchy
關(guān)系的一種分類，除了最高層的對象（通常稱作root），每一個對象有一個專門的上層對象。每個對象可以由一個或多個下層對象在層次關(guān)系中。在Java中，root對象是Object
home interface
enterprise bean兩個接口中的一個。home接口定義了0個或多個方法來創(chuàng)建和刪除一個enterprise bean。對于session bean，home接口定義了創(chuàng)建和刪除方法，然而對于entity bean，home接口定義了創(chuàng)建，查找和刪除的方法。
home handle
一個對象，能夠用來得到對一個home接口的引用。一個home handle能夠被串行化寫入持久存儲器中，通過反串行化來得到這個引用。
HTML
HyperText Markup Language的縮寫。這是一個文件格式，基于SGML，為了超文本在Internet上的傳輸。它十分簡單，允許嵌入圖片，聲音，視頻流，表單域和簡單的文本格式。對其他對象的引用被嵌入到URLs中。
HTTP
HyperText Transfer Protocol的縮寫。Internet的協(xié)議，基于TCP/IP，用來獲得遠程主機上的超文本。參見TCP/IP。
HTTPS
建立在SSL協(xié)議之上的超文本傳輸協(xié)議（HTTP）
IDL
接口定義語言（Interface Definition Language）的縮寫，使用Java(TM)編寫的API提供基于標準的和CORBA的交互性和連接性。
identifier 標識符
在Java程序中一個對象的名稱
IIOP
Internet Inter-ORB Protocol的縮寫。一個用來在CORBA對象請求代理之間交流的協(xié)議。
if
Java編程語言的一個關(guān)鍵字，用來生成一個條件測試，如果條件為真，就執(zhí)行if下的語句。
implements
Java(TM)編程語言的一個關(guān)鍵字，在類的聲明中是可選的，用來指明當(dāng)前類實現(xiàn)的接口。
import
Java(TM)編程語言的一個關(guān)鍵字，在源文件的開始部分指明后面將要引用的一個類或整個包，這樣就不必在使用的時候加上包的名字。
inheritance 繼承
一個概念：一個類型會自動包含其父類型（supertypes）的變量和方法。參見superclass, subclass。
initialization parameter
初始化Servlet上下文的參數(shù)。
instance 實例
一個特定類型的對象。在Java(TM)語言中，一個對象是由new操作符創(chuàng)建的。
instance method 實例方法
任何跟一個類的實例相關(guān)的方法，也稱作method。參見class method。
instance variable 實例變量
任何和一個特定對象相關(guān)的數(shù)據(jù)項。每一個類的實例有一份類定義中聲明的實例變量的拷貝，也稱作field。參見class variable。
instanceof
一個二操作數(shù)的Java(TM)語言關(guān)鍵字，用來測試第一個參數(shù)的運行時類型是否和第二個參數(shù)兼容。
int
Java(TM)的一個關(guān)鍵字，用來定義一個整形變量
interface
Java(TM)的一個關(guān)鍵字，用來定義一系列的方法和常量。它可以被類實現(xiàn)，通過implements關(guān)鍵字。
Internet
一個由全球各個組織，各個國家的數(shù)百萬的主機組成的巨大的一個網(wǎng)絡(luò)。它是由很多小網(wǎng)絡(luò)物理的連接在一起而成的，數(shù)據(jù)通過公共的一組協(xié)議傳輸。
IP
Internet Protocol的縮寫，Internet的基本協(xié)議，它提供不可靠的主機間的數(shù)據(jù)包的傳送。它不保證是否數(shù)據(jù)包能夠正確傳送，需要多久的時間來傳送，或者當(dāng)有多個包時是否按順序到達。建立在該協(xié)議之上的協(xié)議提供連接和可靠性的概念。參見 TCP/IP.
interpreter 解釋器
一個可選解碼并且執(zhí)行代碼中的每一句語句的模塊。Java(TM)解釋器解碼并執(zhí)行為符合Java虛擬機規(guī)范的字節(jié)碼。參見compiler, runtime system。
ISV
Independent Software Vendor的縮寫
本篇文章來自Java中文網(wǎng)：http://javaweb.cc/other/english/2212.shtml
教程由JAVA中文網(wǎng)整理校對發(fā)布(javaweb.cc)
J2EE application
任何可配置的J2EE功能單元。可能是由一個或多個軟件模塊與一個J2EE應(yīng)用程序配置描述符打包成.ear文件。J2EE應(yīng)用程序通常設(shè)計成在多機環(huán)境下運行的分布式應(yīng)用。
J2EE product
一個遵循J2EE平臺規(guī)范的實現(xiàn)。
J2EE Product Provider
提供J2EE產(chǎn)品的生產(chǎn)商。
J2EE server
J2EE Product的運行時部分。一個J2EE提供Web和/或EJB容器。
JAE
Java(TM) Application Environment的縮寫。Java Development Kit (JDK(TM))的源代碼。
JAR Files (.jar)
Java ARchive的縮寫。一種把許多文件聚合到一個文件的一種文件格式。
JAR file format
JAR是一種把許多文件聚合到一個文件的平臺無關(guān)一種文件格式。許多個用Java編寫的applet以及它們所需要的組件（.class文件，圖片，聲音和其他資源文件）能夠被打包到一個JAR文件中，以便以后在單獨一個HTTP請求中就能夠下載到客戶端。它同樣支持文件壓縮和數(shù)字簽名。
Java(TM)
是Sun公司的商標，標識了一系列在獨立的和網(wǎng)絡(luò)化的環(huán)境中創(chuàng)建并安全的運行程序的技術(shù)。
Java Application Environment (JAE)
Java Development Kit (JDK(TM))的源代碼。
Java(TM) 2 Platform, Standard Edition (J2SE platform)
核心的Java技術(shù)平臺
Java(TM) 2 Platform, Enterprise Edition (J2EE platform)
一個用來開發(fā)和配置企業(yè)應(yīng)用程序的環(huán)境。J2EE平臺由一系列的服務(wù)，應(yīng)用程序接口（APIs）和提供開發(fā)多級的，基于Web的功能的協(xié)議組成。
Java(TM) 2 SDK, Enterprise Edition
Sun公司的對J2EE平臺的一個實現(xiàn)。這個實現(xiàn)提供了一個可操作的J2EE平臺的定義。
JavaBeans(TM)
一個可移植的，平臺無關(guān)的，可重用的組件模型。
Java Blend(TM)
一個通過映射數(shù)據(jù)庫數(shù)據(jù)到Java編程環(huán)境中的對象（Object）和映射對象到數(shù)據(jù)庫使程序員能夠簡化數(shù)據(jù)庫應(yīng)用開發(fā)的產(chǎn)品。
Java Card(TM) API
一個和ISO 7816-4兼容的應(yīng)用開發(fā)環(huán)境，集中在smart card上。
JavaCheck(TM)
一個工具，用來檢查一個應(yīng)用程序或一個applet是否符合某個規(guī)范。
Java(TM) Compatibility Kit (JCK)
一個測試包，一組工具，和其它的一些需求，用來檢查一個實現(xiàn)是否和Java平臺規(guī)范和軟件參考實現(xiàn)兼容。
Java Database Connectivity (JDBC(TM))
一個Java平臺和大量數(shù)據(jù)庫平臺之間互聯(lián)的平臺無關(guān)的工業(yè)標準。JDBC(TM)提供了調(diào)用級的API來操作支持SQL語言的數(shù)據(jù)庫。
Java Developer Connection(SM)
一個為個人開發(fā)者設(shè)計的服務(wù)，提供在線訓(xùn)練，產(chǎn)品打折，專題文章，錯誤信息和一些早期的版本兼容性信息。
Java Development Kit (JDK(TM))
一個軟件開發(fā)平臺，支持使用Java語言編寫Applet或應(yīng)用程序。
Java(TM) Enterprise API
這個API使編寫大型的，可能在一個組織中或Internet上與其它應(yīng)用程序共享多媒體數(shù)據(jù)的商業(yè)或數(shù)據(jù)庫應(yīng)用程序變得簡單。在Java(TM)
Enterprise API家族中已經(jīng)有四個APIs被設(shè)計出來。
Java(TM) Foundation Classes (JFC)
一個擴展，把圖形用戶接口加入到抽象窗口工具集（AWT）中。
Java(TM) IDL
一個提供J2EE平臺與CORBA交互能力和互聯(lián)能力的技術(shù)。這些兼容性使J2EE應(yīng)用程序能夠通過OMG IDL和IIOP調(diào)用遠程網(wǎng)絡(luò)上的操作。
Java(TM) Interface Definition Language (IDL)
用Java編寫的APIs，提供標準化的與CORBA（Common Object Request Broker Architecture）的交互能力和互聯(lián)能力。
Java(TM) Message Service (JMS)
使用企業(yè)級消息系統(tǒng)的API，比如IBM MQ Series，TIBCO Reanezvous等。
Java Naming and Directory Interface(TM) (JNDI)
一組用來提供多重命名和目錄服務(wù)的APIs的集合。
JavaOS(TM)
一個基于Java的操作系統(tǒng)，對各種計算和用戶平臺進行了優(yōu)化。JavaOS(TM)操作環(huán)境提供了一個運行時規(guī)范，使Java程序能夠直接運行在硬件平臺之上而不需要宿主操作系統(tǒng)。
Java(TM) Platform
由Java編程語言，一組APIs，類庫，其它在開發(fā)，編譯，錯誤檢查中要用到的程序，和一個能夠裝載并執(zhí)行class文件的Java虛擬機組成。
除此之外，Java平臺的目標是提供一組一致的兼容的實現(xiàn)。符合兼容性規(guī)范的實現(xiàn)能夠得到Sun公司的兼容性標志。
Java 2是當(dāng)前的一代Java平臺。
Jini(TM) Technology
一組Java APIs，可能是任何一個Java 2平臺的可選包。Jini API使網(wǎng)絡(luò)設(shè)備和服務(wù)變得透明，不再需要用戶去管理系統(tǒng)或網(wǎng)絡(luò)使其正常工作。
Jini在目前是任何一個Java平臺版本的一個可選軟件包。
JNDI
Java Naming and Directory Interface(TM)的縮寫，一組用來提供重命名和目錄服務(wù)的APIs的集合。
JPEG
Joint Photographic Experts Group的縮寫。 由這個小組建立的一個圖象文件壓縮標準。它通過幾乎察覺不出的圖象質(zhì)量的損失來實現(xiàn)了巨大的圖象壓縮比。
JRE
Java(TM) runtime environment的縮寫。一個Java Development Kit (JDK(TM))的子集，適合最終用戶和希望重新發(fā)布運行環(huán)境的開發(fā)人員。Java runtime environment由Java虛擬機，Java核心類和支持文件組成。
Just-in-time (JIT) Compiler
一個在Java運行時，把所有字節(jié)碼轉(zhuǎn)換為本地代碼的編譯器。這樣就會加速Java的執(zhí)行，相對Java虛擬機的解釋執(zhí)行。
JVM
參見: Java(TM) Virtual Machine (JVM)
本篇文章來自Java中文網(wǎng)：http://javaweb.cc/other/english/2213.shtml
教程由JAVA中文網(wǎng)整理校對發(fā)布(javaweb.cc)
lexical
關(guān)于如何把源代碼翻譯成各種編譯器能夠識別的記號
literal
整數(shù)，浮點數(shù)，字符的基本表示方法。比如，字面上3.0是一個雙精度浮點數(shù)，"a"是一個字符。
local variable
一個塊中可見的數(shù)據(jù)項，但是對塊外面的代碼是不可見的。比如，任何在一個方法中聲明的變量是一個局部變量，不能在方法外面被使用。
long
Java語言的一個關(guān)鍵字，用來定義一個long類型的變量。
member
類的一個域或者方法，除非顯式指明，否則一個member不是靜態(tài)的。
method
類中定義的一個方法，參見instance method, class method，除非顯式指明，否則一個method不是靜態(tài)的。
module
一個軟件單位，由一個或多個相同容器類型的J2EE組件和一個相同類型的配置描述符組成。有三種module類型：EJB，Web，和Application Client。模塊可以被配置成獨立的單元或嵌入到應(yīng)用程序中。
Mosaic
一個提供簡單圖形界面，使用戶能夠方便的訪問Internet上的數(shù)據(jù)的程序。這些數(shù)據(jù)可能是簡單文件，或者超文本文檔。Mosaic是由NCSA的一個小組編寫的。
multithreaded
描述一個程序，它的代碼被設(shè)計成擁有多個同時被執(zhí)行的部分。參見thread。
object
面向?qū)ο蟪绦虻闹饕囊粋€構(gòu)造塊。每一個對象是一個編程單元，由數(shù)據(jù)（instance methods）和功能（instance methods）組成，參見class。
object-oriented design
一個軟件設(shè)計方法，通過類和對象為抽象和具體的對象的特點建模。
octal
使用8作為基的計數(shù)系統(tǒng)。使用數(shù)字0-7。在Java中8進制數(shù)必須帶有0前綴。參見hexadecimal。
One
Open Net Environment的縮寫，由Sun組織，主要工業(yè)參與商資助，描述了一個易于理解的體系結(jié)構(gòu)，用來創(chuàng)建，編譯和配置Web服務(wù)。ONE是平臺無關(guān)的，基于完全開放的標準。Sun ONE指代一個特定的由Sun和iPlanet提供的對這個體系結(jié)構(gòu)的實現(xiàn)。
Optional Packages
一個或多個APIs的集合，在Java平臺上，它們是可用的，并且可能在兼容平臺上也被支持。
隨著時間推移，Optional Packages可能因為市場需要而變成必需的。
ORB
Object Request Broker的縮寫。一個函數(shù)庫，使CORBA對象能夠定位另一個對象且和它通訊。
OTS
Object Transaction Service的縮寫，一組接口定義使CORBA對象能夠處理事務(wù)。
overloading
在同一個作用域里面使用一個標識符指代多個對象。在Java語言中，你可以overload方法，但不能是變量和操作符。
overriding
在子類中對在父類中定義的方法提供一個不同的實現(xiàn)。
re-entrant enterprise bean
一個enterprise bean，能夠被并發(fā)的，交叉的，或遞歸的調(diào)用，并且相互之間不干擾。
reference
一個內(nèi)容是地址的數(shù)據(jù)元素。
remote interface
enterprise bean兩個接口中的一個。remote接口定義了能夠被客戶調(diào)用的商業(yè)方法。
remove method
在home接口中定義的方法，客戶端可以調(diào)用它來刪除一個enterprise bean。
resource adapter
一個系統(tǒng)級的軟件驅(qū)動，被EJB容器和應(yīng)用程序客戶用來連接到一個EIS。通常一個resource adapter總是針對某一特定EIS的。它以函數(shù)庫的形式提供，運行在使用它的服務(wù)器或客戶地址空間中。一個resource adapter插入到一個容器中。應(yīng)用程序組件配置容器，然后使用客戶端API（由adapter提供的）或者由高層抽象生成的工具來訪問下面的EIS。resource adapter和EJB容器配合提供與EIS連接的下層機制 - 事務(wù)，安全，和連接池。
resource manager
提供訪問一組共享對象的能力。一個recource manager參與一個被事務(wù)管理器外部控制和調(diào)整的事務(wù)。一個resource manager通常和訪問它的客戶運行在不同的主機上和不同的地址空間中。
resource manager connection
代表一個和資源管理器的會話的對象。
resource manager connection factory
一個用來創(chuàng)建資源管理器對象的對象。
本篇文章來自Java中文網(wǎng)：http://javaweb.cc/other/english/2214.shtml
教程由JAVA中文網(wǎng)整理校對發(fā)布(javaweb.cc)
role (development)
在開發(fā)和配置一個基于J2EE技術(shù)的應(yīng)用程序的過程中某個對象起到的作用。role有：應(yīng)用程序組件提供者，應(yīng)用程序編譯者, 應(yīng)用程序配置者
, J2EE平臺提供者, EJB容器提供者, EJB容器提供者, Web容器提供者, Web服務(wù)器提供者,工具提供者和系統(tǒng)管理員。
role (security)
一個抽象的邏輯的用戶組，由Application Assembler定義。當(dāng)一個application被配置的時候，roles被映射到安全標識，比如負責(zé)人或者組，在操作和環(huán)境中。
role mapping
把由容器所識別的組和負責(zé)人和由配置描述符定義的安全角色聯(lián)系起來的一個過程。在組件被安裝到服務(wù)器之前，安全角色必須被配制器映射。
rollback
當(dāng)一個事務(wù)中所有的對數(shù)據(jù)庫的更新被取消的一個點。
root
在對象層次中的一個對象，所有對象都是從它繼承而來的，root對象在層次圖中沒有上層對象，參見hierarchy, class, package。
RPC
Remote Procedure Call的縮寫。通過向遠程主機發(fā)送網(wǎng)絡(luò)數(shù)據(jù)包執(zhí)行，看上去就跟普通的調(diào)用過程（或方法調(diào)用）是一樣的，
runtime system
一個軟件環(huán)境，其中能夠運行為Java虛擬機編譯的程序。runtime system包含了為了裝入用Java編寫的程序，動態(tài)連接本地方法，內(nèi)存管理，異常處理和實現(xiàn)一個Java虛擬機（可能是Java一個解釋器）所必須的代碼。SAX
Simple API for XML的縮寫。一個為訪問XML文檔提供的事件驅(qū)動的，串行訪問的機制。
Sandbox
由許多的系統(tǒng)組件組成，從作為應(yīng)用程序一部分運行的安全管理器，到Java虛擬機中的和語言本身的安全措施。SandBox保證一個不可信任的，可能惡意攻擊的應(yīng)用程序不能訪問系統(tǒng)資源。
scope
一個特性標識，用來規(guī)定哪些地方標識符是可見的。Java環(huán)境中的大多數(shù)標識符擁有類或者局部的scope。實例變量和類變量有類的scope；它們在類的外部或者子類中使用時必須在它們前面加上一個類名前綴（對類變量和類方法）或者類實例名。所有其他的在方法內(nèi)部定義的變量具有局部scope；它們只能在封閉的塊中使用。
Secure Socket Layer (SSL)
一個為了個人隱私在Web服務(wù)器和瀏覽器之間進行加密的協(xié)議。
security attributes
一組和負責(zé)人相關(guān)聯(lián)的屬性。Security attributes能夠和一個負責(zé)人相關(guān)聯(lián)，通過J2EE產(chǎn)品提供商制定的認證協(xié)議。
本篇文章來自Java中文網(wǎng)：http://javaweb.cc/other/english/2215.shtml
教程由JAVA中文網(wǎng)整理校對發(fā)布(javaweb.cc)
security constraint
一個明確的方法來注釋想要的對Web內(nèi)容的保護。一個security constraint由一系列Web資源，一個認證限制和用戶數(shù)據(jù)限制組成。
security context
一個對象，封裝了跟安全有關(guān)的兩個實體之間的共享狀態(tài)信息。
security permission
由J2SE定義的J2EE平臺用來表述應(yīng)用組件供應(yīng)商必須遵循的編程限制的一個機制。
security permission set
J2EE產(chǎn)品提供商為每一個組件類型的執(zhí)行所必須提供的安全允許的最小集合。
security policy domain
一個作用域，其中安全策略被定義并且由安全管理員強制執(zhí)行。一個security policy domain有以下的幾個特征：
它有一組用戶（或者負責(zé)人）
它有一個很好定義的認證協(xié)議來認證用戶
它可能有組的概念來簡化安全策略的設(shè)置
security technology domain
一個作用域，其中同樣的安全機制被用來強制執(zhí)行一個安全策略。在單個technology domain中可以存在多個security policy domain。
server principal
服務(wù)器在操作系統(tǒng)中執(zhí)行的地位。
servlet
一種擴展Web服務(wù)器功能的Java程序，動態(tài)生成文檔，并且使用使用請求應(yīng)答的方式和用戶交互。
stream
Stream是一個簡單的從發(fā)送著到接受者的數(shù)據(jù)字節(jié)流。有兩種基本的分類，所以java.io包包含兩個抽象類（InputStream和OutputStream）。
subarray
一個在另一個數(shù)組中的數(shù)組。
subclass
從某個類派生出來的類，可能是和一個或多個類之間的關(guān)系。參見superclass, supertype。
subtype
如果類型X繼承或者實現(xiàn)了類型Y，那么X是Y的一個subtype。參見supertype。
superclass
一個類，某個類是從它派生而來的，可能是和一個或多個類之間的關(guān)系。參見subclass, subtype。
super
Java語言的一個關(guān)鍵字，用來訪問父類的類成員。
supertype
一個類型的父類型是指它所實現(xiàn)的所有接口和繼承的類型，參見subtype, superclass。
switch
Java語言的關(guān)鍵字，用來計算一個變量，在后面用來匹配由case語句指定的值，以決定執(zhí)行哪一組語句。
Swing Set
一系列圖形用戶接口GUI）組件的代碼名稱，能夠在任何支持Java虛擬機的本地平臺上一致的運行。因為它們是完全用Java語言編寫的，這些組件可能提供的功能比本地平臺提供的等價功能更為強大。（和AWT對比）
synchronized
Java語言的關(guān)鍵字，當(dāng)它用來修飾一個方法或者一個代碼塊的時候，能夠保證在同一時刻最多只有一個線程執(zhí)行該段代碼。（
TCP/IP
Transmission Control Protocol based on IP的縮寫。這是一個Internet協(xié)議，提供可靠的基于流的從一個主機到另一個的數(shù)據(jù)傳輸。參見IP。
Technology Compatibility Kit (TCK)
一個測試包，一組工具，和其它必需的東西，用來證明一個特定的Sun的技術(shù)的實現(xiàn)是否和應(yīng)用程序規(guī)范兼容或者是否和Sun和Sun設(shè)計的參考實現(xiàn)兼容。
this
Java語言的關(guān)鍵字，用來代表它出現(xiàn)的類的一個實例。this可以用來訪問類變量和類方法。
UDDI
Universal Description Discovery and Integration的縮寫。UDDI提供了一個全局的，公共的，基于XML的，在線的商業(yè)注冊，商業(yè)用戶通過它可以注冊并宣傳它們的Web服務(wù)。UDDI定義Internet版的白頁和黃頁電話號碼本。
Unicode
ISO 10646定義的16位長的字符集。參見ASCII。Java環(huán)境中所有的源代碼都是用Unicode編寫的。
URI
Uniform Resource Identifier的縮寫。一個用來標識抽象或物理資源的簡潔字符串。一個URI或者是一個URL或者是一個URN。URLs和URNs是具體的確實存在的實體。URI是一個抽象的父類。
URL
Uniform Resource Locator的縮寫。一個使用文本指代WWW網(wǎng)站上任意數(shù)據(jù)的標準。一個URL通常是這樣的"protocol://host/localinfo"，protocol指明傳輸對象的時候使用的協(xié)議（比如HTTP或FTP），host指明在Internet上找到一臺主機的名字，localinfo是一個傳遞給遠程主機上協(xié)議處理器的字符串（常常是一個文件名）。
URL path
通過一個HTTP請求傳遞的URL，來使用一個servlet。URL由Context Path + Servlet Path + PathInfo組成，其中被請求的servlet是與Context Path相關(guān)聯(lián)的servlet上下文的一部分。如果這個上下文是默認的上下文，以Web服務(wù)器的URL名字空間的基目錄為根，那么這個路徑前綴將會是一個空字符串。否則這個路徑前綴以/開始，但是不是以/結(jié)束。Servlet Path部分直接和激活這個請求的映射對應(yīng)。這個路徑以/字符開始。PathInfo是請求路徑的一部分，但不是Context Path或者Servlet Path的一部分。
URN
Uniform Resource Name的縮寫。唯一標識一個實體的標識符，但是不能給出實體的位置。系統(tǒng)可以先在本地尋找一個實體，在它試著在Web上找到該實體之前。它也允許Web位置改變，然而這個實體卻還是能夠被找到。
variable
由一個標識符命名的數(shù)據(jù)項。每一個variable有一種類型，比如一個整數(shù)或者一個對象，和一個作用域。參見class variable, instance variable, local variable。
virtual machine
一個抽象的計算設(shè)備規(guī)范，可以使用不同的方法實現(xiàn)，軟件的或者硬件的。你把程序編譯成virtual machine的指令集和你把程序編譯成微處理器指令集是十分相似的。Java(TM) virtual machine*由字節(jié)碼指令集合，一組寄存器，一個堆棧，一個垃圾收集堆和一個存放方法的區(qū)域
本篇文章來自Java中文網(wǎng)：http://javaweb.cc/other/english/2216.shtml
教程由JAVA中文網(wǎng)整理校對發(fā)布(javaweb.cc)
vocabulary
傳統(tǒng)上，軟件程序被編寫，然后編譯成直接和計算機中驅(qū)動微處理器工作的操作系統(tǒng)相關(guān)的機器碼。Java平臺通過提供一個程序編寫編譯，然后能夠通過網(wǎng)絡(luò)傳輸并且在任何由足夠兼容性的虛擬機的平臺上運行的模型減輕了這種依賴型。
這個模型提供了額外的好處，高安全性，即因為程序可以被虛擬機驗證一致性在通過網(wǎng)絡(luò)傳輸之后，也因為虛擬機運行在安全的"sandbox"的中，能夠阻止一些特定的破壞性的行為。
軟件開發(fā)人員已經(jīng)投入Java語言的懷抱，因為它減少了編寫程序和支持軟件代碼的費用和時間。他們不再需要為不同的操作系統(tǒng)和不同的微處理器重新編寫功能相同的代碼。正在配置應(yīng)用程序的公司和組織喜歡Java，因為它減少了購買和修改不同版本的應(yīng)用程序使其適應(yīng)各自網(wǎng)絡(luò)環(huán)境中各種類型的計算機和服務(wù)器的費用。
void
Java語言的關(guān)鍵字，用在Java語言的方法聲明中說明這個方法沒有任何返回值。"void"也可以用來表示一句沒有任何功能的語句。
volatile
Java語言的關(guān)鍵字，用在變量的聲明中表示這個變量是被同時運行的幾個線程異步修改的。
一個UNIX命令，使用它將會等待所有的后臺進程結(jié)束，并且報告他們的結(jié)束狀態(tài)。
Web application, distributable
用J2EE技術(shù)編寫的應(yīng)用程序，所以它可以被配置到一個分布運行在一臺或多臺主機的多個Java虛擬機中的Web容器中。這種類型的應(yīng)用程序的配置描述符使用可分布的元素。
Web component
一個通過相應(yīng)為請求提供服務(wù)的組件，或者是一個Servlet或者是一個JSP頁面。
Web container
實現(xiàn)J2EE體系結(jié)構(gòu)中Web組件協(xié)議的容器。這個協(xié)議規(guī)定了一個Web組件運行時的環(huán)境，包括安全，一致性，生命周期管理，事務(wù)，配置和其它的服務(wù)。一個提供和JSP和J2EE平臺APIs界面相同服務(wù)的容器。一個Web container 由Web服務(wù)器或者J2EE服務(wù)器提供。
Web container, distributed
一個Web容器，能夠運行一個標記為分布式的，在同一臺主機或不同主機上的多個Java虛擬機中運行的Web應(yīng)用程序。
Web server
提供訪問Inetrnet，Intranet或者Extranet服務(wù)的軟件。一個Web server運行在Web站點上，提供對HTTP和其它協(xié)議的支持，并且運行服務(wù)器端的程序（比如CGI腳本或者servlets）來實現(xiàn)一定的功能。在J2EE體系結(jié)構(gòu)中，Web Server為Web容器提供服務(wù)。比如，一個Web容器通常依靠Web Server來處理HTTP消息。J2EE平臺假設(shè)一個Web容器總是運行在同一個廠商提供的Web Server之上，所以沒有制定這兩個實體之間的協(xié)議。一個Web Server可以運行一個或多個Web容器。
posted @
2012-08-18 19:48 、小細 閱讀(134) |
評論 (0) |
編輯 收藏
Map集合
1.Map存儲了一系列鍵值的映射關(guān)系
2.Map集合需要保證鍵的唯一性
3.可以通過鍵獲取到值,反之則不能
4.Map集合存儲元素使用put(key,valus)方法.
5.遍歷Map集合的兩種遍歷方式
a)通過KeySet方法返回由鍵組成的集合,迭代集合里面的元素拿到所有的鍵再通過get方法根據(jù)鍵來獲取值
b)通過entrySet方法返回鍵所映射的關(guān)系組成的集合,迭代該集合就拿到一個鍵值映射的關(guān)系,再通過getKey獲取到鍵,再通過getValue()方法獲取到值
HashMap
線程不安全,存儲速度快,允許存放null鍵,null值
通過HashSet保持鍵的唯一性
Hashtable
線程安全,存儲速度慢,不允許存放null鍵與null值
TreeMap
通過二叉樹的原理保證了鍵的唯一性
對鍵進行了排序,排序原理與SetMap相同.
(如果想要使用這個方法,必須要沖構(gòu)造方法里面重寫Comparator 或者從對象所屬的類繼承Comparator實現(xiàn)這個接口)
Properties
Hashtable的子類,所以是線程安全的.
用于讀寫配置文件,一般配置項等號兩邊都是String,所以集合中的兩個列保存的都是String類型的數(shù)據(jù).
這個集合中只能存String,所以不能使用泛型.
/*JavaAPI總結(jié):application programming interface應(yīng)用程序編程接口 sun公司提供給我們用的程序
一、String、StringBuffer、StringBuilder
1、String類是字符串常量
2、String池：String s = "abc" 和String s = new String("abc")的區(qū)別
3、String類的常用方法：charAt、indexOf、toCharArray、substring、split、compareTo、equals
4、StringBuffer：字符串容器，長度可變，一般用于字符串的增減刪的操作。reverse方法反向
String s = "abc"; s = s + "xxx";//String長度不可變，因為是常量
5、StringBuilder線程不安全，StringBuffer線程安全
二、集合類
|-Iterable：實現(xiàn)增強for循環(huán)
|--Collection:單列，按照一種或多種規(guī)則來存儲一系列元素
|---List:有序，允許有重復(fù)元素
|----AbstractList：抽象類，實現(xiàn)了iterator方法。
|-----ArrayList：數(shù)組實現(xiàn)，查找塊，增刪慢
|-----Vector：和ArrayList一樣，只是線程安全
|-----LinkedList：鏈表實現(xiàn)，查找慢，增刪塊
|---Set：無序，不允許有重復(fù)元素
|----HashSet：通過哈希算法保證元素不重復(fù)，對象要正確重寫equals和hashCode方法
|----HashTable：同上，但是線程安全
|----TreeSet：通過樹狀結(jié)構(gòu)保證元素不重復(fù)，兩種方式
1、按照元素的自然順序進行排序，前提是元素具備比較功能，實現(xiàn)了Comparable接口的compareTo方法
2、在構(gòu)造TreeSet實例時，傳入一個比較器，實現(xiàn)Comparator接口的compare方法
|-Map：保存的是鍵值對應(yīng)關(guān)系，其中鍵不允許有重復(fù)，可以通過keySet方法拿到一個包含所有鍵的Set
再調(diào)用get(key)方法通過鍵拿到value
|--HashMap:通過HashSet的原理保證鍵不重復(fù)。
|--TreeMap：通過TreeSet的原理保證鍵不重復(fù)
|--Properties：用于讀取配置文件，不需要聲明泛型，因為鍵和值都只能為String類型。
list方法將集合中的配置項輸出到一個打印流
load方法將一個輸入流中的配置項存到集合中
Jdk1.5新特性泛型，減少集合存元素時錯誤發(fā)生的幾率。
Jdk1.5出現(xiàn)Iterable，為了實現(xiàn)增強for循環(huán) for(元素類型 變量：集合或數(shù)組)
工具類：
Collections：集合工具類，sort、binarySearch、reverse
Arrays：數(shù)組工具類，sort。。。。
三、包裝類
1、Integer x = 0;x = x + 1; 裝箱-拆箱-裝箱（jdk1.5）
2、Interger.parseInt(String)將字符串轉(zhuǎn)為int型
四、System類
1、System類的常用方法：gc()垃圾回收、exit(0)終止程序、currentTimeMillis()獲得自1970年1月1日零時
以來的毫秒數(shù)、getProperty方法獲得系統(tǒng)屬性。
2、兩個靜態(tài)成員變量：in和out
in：標準輸入流，InputStreamReader類型
out：標準打印流，PrintStream類型
五、Runtime類
表示運行時，exec方法，在后臺新開啟一個窗口運行命令，是當(dāng)前窗口的子窗口，繼承所有窗口屬性
六、日期對象
1、Date：大部分方法已過時，用new Date()創(chuàng)建日期對象表示當(dāng)前時間
2、DateFormat：將日期格式化，抽象類
DateFormat df = DateFormat.getInstance(); String dateStr = df.format(new Date);
3、Calendar對象：
Calendar c = Calendar.getInstance();
可以將類中定義的常量當(dāng)做參數(shù)傳入get和set方法來獲得和設(shè)置時間。
add方法，增加時間值，具體增加哪一項，就看傳入的常量，調(diào)用完此方法，時間對象就被改變了。
*/
面試題目總結(jié):
一、請說說ArrayList、Vector和LinkedList的區(qū)別
這三者都是單列集合Collection下List集合的實現(xiàn)類，所以他們的共同點，元素有序，允許重復(fù)元素
不同點：
ArrayList和Vector底層都是數(shù)組實現(xiàn)，這樣的實現(xiàn)注定查找快、增刪慢
ArrayList和Vector的區(qū)別在于線程安全問題，Vector支持線程同步，是線程訪問安全的，而ArrayList線程不安全
LinkedList底層是鏈表結(jié)構(gòu)，查找元素慢、增刪元素速度快，線程不安全。
二、請說說HashSet原理，并寫程序證明
HashSet在存元素時，會調(diào)用對象的hashCode方法計算出存儲位置，然后和該位置上所有的元素進行equals比較，
如果該位置沒有其他元素或者比較的結(jié)果都為false就存進去，否則就不存。
這樣的原理注定了元素是按照哈希值來找存儲位置，所有無序，而且可以保證無重復(fù)元素
我們在往HashSet集合存儲元素時，對象應(yīng)該正確重寫Object類的hashCode和equals方法
正因為這樣的原理，HashSet集合是非常高效的。
比如，要查找集合中是否包含某個對象，首先計算對象的hashCode，折算出位置號，到該位置上去找就可以了，而不用和所有的元素都比較一遍
三、Collection和Collections的區(qū)別
兩者沒有任何關(guān)系
Collection是單列集合的父接口，JDK1.5中定義了Iterable接口作為Collection父類，為了實現(xiàn)增強for循環(huán)
Collections是工具類，提供了關(guān)于集合的常用操作，例如，排序、二分法查找、反轉(zhuǎn)元素等
1 Collections 的應(yīng)用:
2
3 1.
4 package com.javami.kudyMap;
5 import java.util.ArrayList;
6 import java.util.Collections;
7 import java.util.Comparator;
8 import java.util.List;
9 public class ColletionsTest {
10 public static void main(String[]args)
11 {
12 /*
13 * Collections工具類:提供關(guān)于集合的常用操作.
14 */
15 ArrayList<String> al = new ArrayList<String>();
16 al.add("ab");
17 al.add("aadc");
18 al.add("aaa");
19 al.add("hgdfakjg");
20 al.add("xhyns");
21 al.add("yyiouop");
22 al.add("qq");
23 al.add("zdff");
24
25 /*
26 for(String s : al)
27 System.out.println(s+" ");
28 */
29
30 /*Collections.sort(al); //list是一個接口 父類型的應(yīng)用可以指向子類型的對象..
31 for(String s : al)
32 System.out.println(s+" ");*/
33 Collections.sort(al, new StringComparator());
34 /*
35 * 第一種方法 : 通過比較器來對比排序 可以在構(gòu)造方法里面.
36 * 或者在對象里面實現(xiàn)這個比較器.當(dāng)new 這個實現(xiàn)接口.它會自動調(diào)用比較器的方法進行比較
37 */
38 System.out.println("通過StringComparator()方法已經(jīng)排序好-----");
39 for(String s : al)
40 System.out.print(s+" ");
41 /*
42 * 使用了API里面的方法!
43 //binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
44 int pos = Collections.binarySearch(al,"aaa",new StringComparator());
45 System.out.println(pos);//因為我們需要通過比較才可以!
46 */
47 int pos = MyCollections.binarySearch(al,"dasdas",new StringComparator());
48 System.out.println(pos);
49 }
50
51 }
52
53 /*
54 * 比較器: 先比較 長短,再比較順序
55 */
56 class StringComparator implements Comparator<String>
57 {
58
59 @Override
60 public int compare(String s1, String s2)
61 {
62 //首先比較長度,再按照字典順序
63 int num = s1.length()- s2.length();
64 if(num !=0)
65 return num;
66 return s1.compareTo(s2);
67
68 }
69
70 }
71
72 //實現(xiàn)一個二分查找
73 class MyCollections
74 {
75 private MyCollections(){}//私有化
76 public static<T> int binarySearch(List<T> l,T key,Comparator<T> com)
77 {
78 int min = 0;
79 int max = l.size()-1;
80 int mid = 0;
81 while(max >=min)
82 {
83 mid = (min+max) / 2;
84 //判斷比較器里面有沒有!
85 if(com.compare(key,l.get(mid))>0)//找到集合位置的值
86 min = mid+1;
87 else if(com.compare(key, l.get(mid))<0)
88 max = mid-1;
89 else
90 return mid;
91 }
92
93 //判斷mid位置的元素和key的大小
94 if(com.compare(key, l.get(mid))>0)
95 return -mid-2;
96 return -mid-1;
97
98 }
99 }
100
101 2.必須要通過比較器比較才能實現(xiàn)二分查找:
102
103 package com.javami.kudyAPI;
104 import java.util.ArrayList;
105 import java.util.Collections;
106 import java.util.Comparator;
107
108 public class Test {
109 public static void main(String[]args)
110 {
111 ArrayList<String> al = new ArrayList<String>();
112 al.add("as");
113 al.add("scx");
114 al.add("dsad");
115 al.add("hellsda");
116 al.add("dsazxc");
117 al.add("dascxxc");
118 //在通過二分查找之前我們要經(jīng)過排序'
119 System.out.println("還沒有排序之前");
120 for(String s : al)
121 System.out.print(s+" ");
122
123
124 //第二部 : 當(dāng)你調(diào)用二分查找之后.會調(diào)用比較器進行比較.是經(jīng)過排序后的才可以進行二分查找
125 //比較器一定要傳過來
126 int num = Collections.binarySearch(al, "dsaas",new Comparator<String>(){
127
128 @Override
129 public int compare(String s1, String s2) {
130 int num = s1.length() - s2.length();//比較長度
131 if(num != 0)
132 return num;
133 return s1.compareTo(s2); //按字典順序排
134 }
135
136 });
137 System.out.println(num+1);
138 }
139 }
140
141
142 日期的應(yīng)用:
143
144 package com.javami.kudyAPI;
145 import java.util.Calendar;
146 public class CalendarTest {
147
148 /**
149 * @param args
150 */
151
152 public static void main(String[] args)
153 {
154 Calendar calendar = Calendar.getInstance();
155 printCalendar(calendar);
156 int nums = getDayNum(2012);
157 System.out.println(nums);
158
159 //----------------
160 Calendar startDay = Calendar.getInstance();//獲取當(dāng)前的日歷
161 Calendar finishDay = getFinishDay(startDay);
162 int num = finishDay.get(Calendar.DAY_OF_YEAR) - calendar.get(Calendar.DAY_OF_YEAR);
163 System.out.println(num+"天數(shù)");
164 }
165
166 //計算出某年的2月份有多少天
167 public static int getDayNum(int year)
168 {
169 //1.獲取一個日歷
170 Calendar calendar = Calendar.getInstance();
171
172 /*
173 * set(int year, int month, int date)
174 設(shè)置日歷字段 YEAR、MONTH 和 DAY_OF_MONTH 的值。
175 */
176 calendar.set(year,2,1); //2月份其實就是中國的三月
177 //日歷字段 DAY_OF_YEAR獲取到年中的月份 , -1 其實就是2月份
178 calendar.add(Calendar.DAY_OF_YEAR,-1);
179 return calendar.get(Calendar.DAY_OF_MONTH); //獲取到二月份的天數(shù)
180 }
181
182 //一個項目做100天，周末休息，五一和十一各休息一天，今天開始做，哪天完工
183 //一個項目做100天，周末休息，五一和十一各休息一天，今天開始做，哪天完工
184 public static Calendar getFinishDay(Calendar c) {
185 for(int i=0; i<100; i++) {
186
187 //如果是星期六或者星期天(get 和 set 的字段數(shù)字，指示一個星期中的某天。)
188 if(c.get(Calendar.DAY_OF_WEEK)==1||c.get(Calendar.DAY_OF_WEEK)==7)
189 i--;
190 //(get 和 set 的字段數(shù)字，指示一個月中的某天。)
191 else if(c.get(c.DAY_OF_MONTH)==1&&(c.get(c.MONTH)==4||c.get(c.MONTH)==9))
192 i--;
193 c.add(Calendar.DAY_OF_YEAR, 1);
194 }
195 return c;
196 }
197 //代表是一個時間
198 public static void printCalendar(Calendar calendar)
199 {
200 int year = calendar.get(calendar.YEAR); //年
201 int month = calendar.get(calendar.MONTH); //月
202 int day = calendar.get(calendar.WEEK_OF_MONTH);//日
203 int week = calendar.get(calendar.DAY_OF_WEEK);//星期
204 int hour = calendar.get(calendar.HOUR_OF_DAY); //時間
205 int minute = calendar.get(calendar.MINUTE);//分
206
207 String StringWeek = null;
208 switch(week)
209 {
210
211 case 1:
212 StringWeek = "星期天";
213 break;
214 case 2:
215 StringWeek = "星期一";
216 break;
217 case 3:
218 StringWeek = "星期二";
219 break;
220 case 4:
221 StringWeek = "星期三";
222 break;
223 case 5:
224 StringWeek = "星期四";
225 break;
226 case 6:
227 StringWeek = "星期五";
228 break;
229 case 7:
230 StringWeek = "星期六";
231 break;
232 }
233 //并接成字符串
234 String str = ""+year+"-"+(month+1)+"-"+day+"-"+week+"-"+hour+"-"+minute;
235 System.out.println(str);
236 }
237
238
239 }
posted @
2012-08-07 01:10 、小細 閱讀(326) |
評論 (0) |
編輯 收藏
集合類：
為什么使用集合類?
在面向?qū)ο蟮木幊趟枷胫校际且詫ο蟮男问綄κ挛镞M行描述的,為了保證對象的生命周期，我們需要持有對象
（什么叫做持有對象呢?Person p = new Person()）
數(shù)組和集合類的區(qū)別?
1.數(shù)組和集合類都是容器，都能存儲對象
2.集合類優(yōu)點就是長度可變,而數(shù)組一旦定義.長度是不能修改的.
集合的特點：
集合類可用于存儲對象.
集合類的長度可變
一個集合可以存儲多種類型的對象..
Collection 接口：
1.一個獨立的元素的序列，這些元素從一條或多條規(guī)則
2.collection接口下分為list集合和Set集合
3.list集合的特點是元素有序，可以允許有重復(fù)的元素
4.set集合的特點是元素?zé)o序，不允許有重復(fù)的元素
↓↓
List（子接口）
↓↓
ArrayList(實現(xiàn)類)
1.底層數(shù)組實現(xiàn)，查找快，增刪慢
2.線程不安全
----------------------------------
Vector（實現(xiàn)類）
1.與ArrayList基本一樣
2.線程安全
----------------------------------
LinkedList(實現(xiàn)類)
1.底層是鏈表的實現(xiàn)
2.增刪快，查找慢
{
List集合元素存取方法一致
使用add()方法增加元素
由于List集合有序，可以使用get()方法獲取元素
元素的迭代(Iterator)
通過集合對象的iterator()方法獲得迭代器Iterator
通過Iterator迭代器的hasNext()方法判斷是否存在下一個元素
通過Iterator迭代器的next()方法獲取下一個元素
元素的迭代(Enumeration)
迭代Vector集合中的元素可以使用Enumeration
通過Enumeration的hasNextElements()方法判斷是否還有元素
通過Enumeration的nextElement()方法返回下一個元素
}
↓↓
Set（子接口）
↓↓
Set集合無須，不允許有重復(fù)的元素
1.set集合通過存入對象的equals方法來保證集合中沒有重復(fù)的元素
HashSet（實現(xiàn)類）
HashSet是set的子類，因而沒有重復(fù)元素
底層使用了哈希算法保證沒有重復(fù)元素
存儲對象時，先調(diào)用對象的HashSet（）方法，找到存儲位置，再和當(dāng)前的存儲位置上已經(jīng)存在的元素通過equals()方法進行比較，如果返回false，才能進行存儲
往HashSet集合里存儲的對象必須是重寫HahCode 和equals()方法。
TreeSet（實現(xiàn)類）
TreeSet集合通過二叉樹算法保證無重復(fù)元素，并對元素進行排序
第一種方式: 如果對象實現(xiàn)了Comparable接口，就可以存入TreeSet集合 因為它會自動的去調(diào)用里面的一個比較方法.所以在Person里面重寫
第二種方式: 如果對象沒有實現(xiàn)Comparable接口，在創(chuàng)建TreeSet對象時，需要給構(gòu)造函數(shù)扔進一個比較器，實現(xiàn)Comparator接口 .(必須要在匿名內(nèi)部類重寫.或者繼承一個類來重寫)
----------------------------------
Map接口：
1.一組成對的“鍵值對”對象，允許根據(jù)鍵來查找值
2.Map集合的健值不允許有重復(fù)的，所以Map所有的鍵都構(gòu)成了一個Set集合
Iterable接口：
1.JDK1.5新定義的接口作為Collection的父接口
2.主要就是實現(xiàn)了增強for循環(huán)
jdk1.5的新特征：
泛型:
由于集合可以存儲不同數(shù)據(jù)類型的對象，所以取元素(地址)時會導(dǎo)致類型轉(zhuǎn)換錯誤
jdk1.5新增加了泛型，為了減少操作集合的出錯里
例如： ArrayList<Person> arraylist = new ArrayList<Person>();
比喻： 我在每一個掛了一個牌子.只能是Person 使用.做了一個限制..
使用泛型的好處：
1.提高的代碼的安全性
2.講運行期間的問題轉(zhuǎn)到了編譯期間的問題（你懂的~~）
3.省起了類型轉(zhuǎn)換的麻煩
4.泛型類的出現(xiàn)優(yōu)化了程序設(shè)計
增強for循環(huán)：
新接口Iterable中定義了增強for循環(huán)
可以通過增強for循環(huán)對數(shù)組和集合進行遍歷
在迭代集合元素時，需要定義了泛型才能使用for循環(huán)
可變參數(shù)：
有的時候在設(shè)計方法時無法確定將來別人會傳入的參數(shù)個數(shù)
JDK1.5增加了新特性可變參數(shù)，在函數(shù)中只聲明參數(shù)類型，不規(guī)定個數(shù)
方法接受的參數(shù)實際上是一個數(shù)組，可以在方法中遍歷數(shù)組
可變參數(shù)只能被定義為函數(shù)的最后一個形參
語法格式： 返回值 函數(shù)名(參數(shù)類型… 形參)
1 package com.javami.kudy.javaapin.StringStudy;
2
3 public class Test {
4 public static void main(String[]args)
5 {
6 show(33,45,7657,332,11,5465);
7 }
8
9 public static void show(int ... i)
10 {
11 for(int num : i)
12 System.out.println(num);
13 }
14 }
posted @
2012-08-07 01:09 、小細 閱讀(103) |
評論 (0) |
編輯 收藏第一:
package com.javami.kudy.javaapi1.StringStudy;
public class StringDemo {
/*面試題：
* 1.Stirng s = "abc" String s = new String("abc"); //有什么區(qū)別?
* 2.String s = new String("abc"); 創(chuàng)建了幾個對象 2個(池里沒有)或1個(池里有了)，
* 3.String s = "a" + "b" + "c" + "d"; 創(chuàng)建了幾個對象？ 創(chuàng)建了1個對象
* 4.String s1 = "a"; String s2 = "b"; String s3 = s1 + s2; s3=="ab"?
*/
public static void main(String[]args)
{
/*
* 1.String池,由于字符串操作很頻繁.java針對String對象提供了緩沖池
* s1首先會在緩沖池里面看一下有沒有"abc" 如果沒有的.那么把對象創(chuàng)建的引用返回給s1
* 當(dāng)s2開始執(zhí)行.會檢查緩沖池里面有沒有.如果有的.直接把對象的地址返回給s2 .所以是相等的.。
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2);
*/
/*
String s1 = "abc";
String s2 = new String(s1);
outcome ： false
s2在堆內(nèi)存中創(chuàng)建了一個對象(把地址返回來~),并且在堆內(nèi)存里面的緩沖池里面創(chuàng)建一個"abc"(這個是對象里面的一個拷貝副本)
做java的日常維護.所以那么這兩個地址一比較.就會不相等..
*/
/*
String s1 = "a"+"b"+"c";
String s2 ="abc";
outCome = "true";
因為java編譯器有個合并已知量的功能,在編譯階段"a"+"b"+"c" 合并為"abc"并且保存在緩沖池里面
所以s2在檢測緩沖池里面.檢測到已經(jīng)有了.直接把對象的引用所返回來.那么證明了s1 s2 是同一個地址/所以比較出來為true
*/
/*
String s1 = new String("abc");
String s2 = new String("abc");
這兩個里面創(chuàng)建了多少個對象呢?
解答： 首先會在堆內(nèi)存中創(chuàng)建一個對象.在檢測池里面有沒有,沒有也在了緩沖池里面創(chuàng)建了一個.做日常的維護
s2也會在堆內(nèi)存中創(chuàng)建一個對象.這時候檢測到池里面已經(jīng)有了.所以就不再創(chuàng)建/
說百了也就是3個..
一般面試簡單的就直接說：2個就可以.
*/
/*
* String 是一個常量,是不能改變的量
* 內(nèi)部實現(xiàn)：
* StringBuilder sb = new StringBuilder(s1);
* sb.append(s2);
* s3 = sb.toString(); //轉(zhuǎn)換回字符串
* 返回調(diào)用方法的都是創(chuàng)建一個對象的
*
*/
String s1 = "a";
String s2 = "b";
String s3 = s1 + s2;
System.out.println(s3=="ab"); //直接返回一個flase
}
}
第二:
package com.javami.kudy.javaapi1.StringStudy;
import java.io.UnsupportedEncodingException;
public class DecodeTest {
/*
* 解碼： 用錯誤的碼再變回來.然后用正確的編碼方式就可以
* 編碼錯誤： 沒辦法,神仙也救不了
*/
public static void main(String[]args) throws UnsupportedEncodingException
{
String str1 = "中國人"; //使用gb2312編碼
// 使用平臺的默認字符集將此 String 編碼為 byte 序列，并將結(jié)果存儲到一個新的 byte 數(shù)組中。
byte[] newbyte = str1.getBytes();
String str2 = new String(newbyte);
System.out.println(str2);
String str3 = new String(newbyte,"iso-8859-1");
//System.out.println(str3);編碼的信息出錯
newbyte = str3.getBytes("iso-8859-1");
String str4 = new String(newbyte);
System.out.println(str4);
byte[]new1 = str1.getBytes("iso-8859-1");
//一開始編碼的信息就出錯!因為我的計算機根本就沒有這個編碼
String s6 = new String(new1);
new1 = s6.getBytes("iso-8859-1");
String st7 = new String(new1);
System.out.println(st7);
}
}
第三:
package com.javami.kudy.javaapi1.StringStudy;
public class StringTest {
/*String 為什么要重寫toString()方法呢?
解答：因為在String如果不重寫Object的toString方法.那么直接復(fù)用父類的方法.打印出的是對象.
這顯然不是String想要得到的結(jié)果
*/
public static void main(String[]args)
{
String s1 = "kudy";
System.out.println(s1.charAt(3)); //索引是從零開始\
String s2 ="abcde";
String s3 = "aBcddddd";
System.out.println(s2.compareToIgnoreCase(s3));
String s4 = "abc";
String s5 = "def";
System.out.println((s4.concat(s5)).toString());
boolean is = s4.contains(s5);
System.out.println(is);
String fileName = "Demo.jdk";
if(fileName.endsWith(".java"))
System.out.println("您是java文件");
String s6 = "cnabcdbvklabcjdhfabcdhla";
int newint = s6.indexOf("abc",0); //注意：索引是從零開始
System.out.println(newint);
String s7 = "abc";
String s8 = new String("abc");
s8.intern();
System.out.println(s7 == s8);
String s9 = "cascascacvdfdjkgksd";
int num = s9.lastIndexOf("k",s9.length()-1);
System.out.println(num);
String s10 = "abc";
String s11 = s10.replace("abc","***");
System.out.println(s11);
String s12 = "hello.java";
String s13 = s12.replace("java","jdk" );
System.out.println(s13);
/*
* 把有逗號的內(nèi)容去掉。
*/
String s14 = "ab,cd,ef";
String [] s15 = s14.split(",");
for(String num1 : s15)
System.out.print(num1);
String s16 = "abcbsbdasdas";
char[] newchar = s16.toCharArray();
for(char num2 : newchar)
System.out.print(num2);
System.out.println();
/*
* 但注意中間的是不能去掉的~~
*/
String s17 = " abc def ";
String s18 = s17.trim();
System.out.println(s18);
}
}
第四:
1 package com.javami.kudy.javaapi1.StringStudy;
2
3 import java.io.IOException;
4
5 public class StringUtil {
6 private StringUtil(){} //私有化
7
8 /* 查找子字符串在字符串中出現(xiàn)的位置 例：“ab”在"habjklabljhlabhjdjfla"出現(xiàn)的位置為：1 6 12
9 * 思路：
10 * 1.定義一個StringBuilder容器，用于存儲位置，定義一個pos變量記住出現(xiàn)的位置，初始值為0
11 * 2.定義一個while循環(huán)，查找子串出現(xiàn)的位置
12 * 3.調(diào)用indexOf方法，從起始位置開始查找出子串首次出現(xiàn)的位置
13 * 4.如果pos為-1，說明沒找到，應(yīng)該結(jié)束循環(huán)
14 * 5.將位置存入StringBuilder容器，再加一個逗號分隔
15 * 6.從找到的位置加上子串的長度作為新的起始位置，
16 * 7.循環(huán)結(jié)束，將StringBuffer轉(zhuǎn)為String字符串，調(diào)用split方法以逗號進行分隔，獲得了String數(shù)組
17 * 8.準備一個新的int數(shù)組，長度和String數(shù)組一樣，遍歷String數(shù)組，將每個元素轉(zhuǎn)為int存入int數(shù)組
18 */
19 public static int[]findIndexOfSubstr(String str, String substr)
20 {
21 StringBuilder sb = new StringBuilder();
22 int pos = 0;
23 while(true)
24 {
25 pos = str.indexOf(substr,pos);
26 if(pos ==-1)
27 break;
28 sb.append(pos+",");
29 pos+=substr.length(); //pos假設(shè)找ab 找到1 + 2 等于三.剛好從第三個開始找~
30 }
31 if(sb.length() == 0) //容器什么都沒有！
32 return null; //一個都找不到
33 String s = sb.toString(); //轉(zhuǎn)換成字符串形式
34 String[] parts = s.split(",");
35 int[] arr = new int[parts.length];
36 for(int i=0; i<parts.length; i++)
37 {
38 arr[i] = Integer.parseInt(parts[i]);
39 }
40 return arr;
41 }
42
43 /*
44 * 設(shè)計一個方法，讀取鍵盤輸入的一行（只支持英文字母）
45 * 提示：System.in.read()讀取鍵盤上的一個字符
46 * 思路：
47 * 1.定義一個容器StringBuilder容器
48 * 2.定義一個while循環(huán),循環(huán)讀取鍵盤.
49 * 3.如果讀到回車或者\n 就跳出循環(huán)
50 * 4.存入StringBuilfer容器中
51 * 5.循環(huán)結(jié)束,返回一個toString轉(zhuǎn)換為字符串
52 */
53 public static String readLine() throws IOException
54 {
55 StringBuilder sb = new StringBuilder();
56 while(true)
57 {
58 int ch = System.in.read();
59 if(ch == '\r') //如果回車 跳出去
60 continue;
61 if(ch == '\n') //等上面的執(zhí)行完畢.再來
62 break;
63 sb.append((char)ch);
64 }
65 return sb.toString(); //轉(zhuǎn)換成字符串
66 }
67
68 /*
69 * *將給定的字節(jié)數(shù)組截取一部分，進行解碼，要求輸出完整的漢字，例如："abc中國人"截取6個 輸出的是abc中
70 * 思路：
71 * 1.遍歷數(shù)組被截取的部分,
72 * 2.判斷正負數(shù)，統(tǒng)計負數(shù)個數(shù)為count
73 * 3.判斷count的奇偶，奇數(shù)減去1，偶數(shù)不變
74 * 4.解碼
75 * 漢字是占了2個字節(jié)?我們怎么判斷它是漢字呢?
76 * 漢字的第一位字節(jié)保證是負數(shù)!第二個是正數(shù)
77 *
78 */
79 public static String decode(byte[]buf, int len)
80 {
81 int count = 0;
82 for(int i=0; i<buf.length;i++)
83 if(buf[i]<0)
84 count++; //如果第一個字節(jié)是負數(shù)的.是代表漢字馬上來到.咱們+1
85 if(count % 2 == 1)
86 len--;
87 return new String(buf,0,len);
88 /*程序流程圖： 咱們輸入一個buf len = 5
89 * for 執(zhí)行5次
90 * 因為一個漢字是占了2個字節(jié).而第一個字節(jié)保證是負數(shù)
91 * 如果 buf[i]里面的是負數(shù)的 count +1 = 1
92 * 如果 % 2 等于1代表的是： 咱們len 傳遞進來的就減去一個字節(jié).
93 *
94 */
95 }
96
97 public static String decodeBYGBK(byte[]buf,int len)
98 {
99 boolean b = false;
100 for(int i=0; i<buf.length; i++)
101 if(b)
102 b = false;
103 else if(buf[i]<0)
104 b = true;
105 if(b)
106 len --;
107 return new String(buf,0,len);
108
109 }
110
111 /*
112 * 查找一個字符串出現(xiàn)次數(shù)最多的字符 abvjdabahabballfja 出現(xiàn)次數(shù)最多的為:a 6
113 * 思路：
114 * 1.調(diào)用toCharArray字符串把字符串轉(zhuǎn)換成字符數(shù)組
115 * 2.定義max，用于記住出現(xiàn)最多字符的次數(shù)，定義一個maxChar記住出現(xiàn)最多的字符
116 * 3.定義一個循環(huán)，每次循環(huán)都統(tǒng)計一個字符出現(xiàn)最多的次數(shù)，每次讓次數(shù)和max比.誰最大就換,結(jié)束條件。當(dāng)長度的數(shù)組
117 * 為零
118 * 4.定義一個count，記住本次統(tǒng)計字符的次數(shù)
119 * 5.循環(huán)遍歷數(shù)組，統(tǒng)計第一個字符出現(xiàn)的次數(shù)
120 * 6.讓次數(shù)和max比，如果max大，讓max記住它的次數(shù)，讓maxchar記住當(dāng)前的字符
121 * 7.將當(dāng)前的字符從數(shù)組中刪除
122 * ------
123 * 將此字符串轉(zhuǎn)換為一個新的字符數(shù)組。
124 */
125
126 public static char searchMaxChar(String str)
127 {
128 char[] buf = str.toCharArray();
129 int max = 0;
130 char maxChar = 0;
131 while(buf.length>0)
132 {
133 int count = 0; //個數(shù)等于0
134 char firstChar = buf[0];
135 for(char c : buf)
136 if(c ==firstChar)
137 count++;
138 if(count>max) //max 已經(jīng)是默認記住上一個的值！
139 {
140 max = count;
141 maxChar = firstChar; //如果你是最多的就讓給你~~
142 }
143 //把當(dāng)前的字符刪除！
144 buf = deleteChar(buf,firstChar,count);
145 }
146 return maxChar;
147 }
148
149 private static char[] deleteChar(char[] buf, char firstChar, int count)
150 {
151 char[]arr = new char[buf.length-count];
152 int pos = 0;
153 for(int i=0; i<buf.length; i++)
154 {
155 if(buf[i]==firstChar)
156 continue;
157 arr[pos++] = buf[i];
158 }
159 return arr;
160 }
161 /* 查找兩個字符串中的最大子串 jflwertyakjfa;l fjdlkwertyjf;ajf 最大子串：werty
162 * 1.判斷出兩個字符串的長短，找出較長的和較短的
163 * 2.循環(huán)遍歷較短的字符串的所有子串，由長到短遍歷
164 * 定義一個循環(huán)，每次遍歷一種長度的子串，將i作為長度，i的取值: length~1
165 * 定義一個內(nèi)層循環(huán)，具體遍歷某一種長度的子串，j做為子串的開始位置， j取值：0~length-i
166 * 截取子串，substring 起始位置:j 結(jié)束位置:j+i
167 * 3.每次變量，都判斷子串是否為較長的字符串的子串，如果是，直接返回
168 * 4.循環(huán)結(jié)束，依然沒有返回，說明沒有相同子串，返回null
169 */
170 public static String searchMaxSubStr(String s1, String s2)
171 {
172 String longStr = s1.length() > s2.length() ? s1 : s2;
173 String shortStr = s1.length() > s2.length() ? s2 : s1;
174 for(int i=shortStr.length(); i>0; i--)
175 {
176 for(int j=0;j<shortStr.length()-i+1;j++)
177 {
178 String sub = shortStr.substring(j, j+i); //例如： abcd 放到sub里面去
179 //abcd abc ab a 和它里面的做一個對比
180 //當(dāng)且僅當(dāng)此字符串包含指定的 char 值序列時，返回 true。
181 if(longStr.contains(sub))
182 //判斷長的字符串里面是否包含這個
183 return sub; //如果包含直接返回.沒有包含
184 }
185 }
186 return null;
187 }
188 }
189
190
191 ----------------------
192
193 package com.javami.kudy.javaapi1.StringStudy;
194
195 public class StringUtilTest {
196 public static void main(String[]args) throws Exception
197 {
198 /*
199 String str = "dsdcvcvxvczxbedfaacff";
200 String substr = "y";
201 //遍歷a 出現(xiàn)的位置
202 int[]arr = StringUtil.findIndexOfSubstr(str, substr);
203 if(arr ==null)
204 {
205 System.out.println("找不到！");
206 return ;
207 }
208 for(int num : arr)
209 {
210 System.out.print(num+" ");
211 }
212 System.out.println();
213
214 */
215 /*
216 * 再輸入byte的時候就結(jié)束,不斷的去讀
217
218 while(true)
219 {
220 String str2 = StringUtil.readLine();
221 if("bye".equals(str2))
222 break;
223 System.out.println(str2);
224 }
225 System.out.println("程序結(jié)束");
226 */
227 byte[] buf = "abc中國人".getBytes();
228 //String s3 = StringUtil.decode(buf, 3);
229 String s3 = StringUtil.decodeBYGBK(buf, 5);
230 System.out.println(s3);
231
232 char maxChar = StringUtil.searchMaxChar("dasfasdfaaaaaaaasfgdagfafgsad");
233 System.out.println(maxChar);
234
235 String s33 = "jflwertyakjfa;l";
236 String s44 = "fjdlkwertyjf;ajf";
237 String s55 =StringUtil.searchMaxSubStr(s33,s44);
238 System.out.print(s55);
239 }
240
241 }
posted @
2012-08-07 01:07 、小細 閱讀(247) |
評論 (0) |
編輯 收藏