所有的流在使用完畢時，都需要調用close方法進行關流，釋放資源。
由于流操作都會有異常，如果發生異常就有可能導致close方法不能被調用
所以，IO異常一定要處理，close方法寫在finally語句中
1.InputStream : 輸入字節流 方法： read()從流(關聯的設備)中讀一個字節
** int read(buf):從流中讀取n個字節放入緩沖區，方法會返回一個讀取字節的個數 ips-->buf
讀到一個-1，說明讀到了流的末尾
------------------------------------------------------------------------------------------
|---FileInputStream: 重載的構造函數 (String fileName) (File file)
2.OutputStream： 輸出字節流 :方法 write(int c)將一個字節寫入流 (byte)c
write(buf,offset,len)將指定字節數組的一部分寫入流。 buf-->ops
-------------------------------------------------------------------------------------------
|---FileOutputStream: 重載的構造函數 (Strng fileName) (String fileName, boolean append)
append:指定數據是否追加到文件的末尾，默認是false，覆蓋原有的數據，
設置為true，將數據追加到文件的末尾
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.裝飾設計模式： 對原有的類的進行包裝，對方法進行增強
BufferedReader：實現緩沖的功能 創建包裝流對象的時候，必須組合一個被包裝的底層流
增加了一個新方法 String readLine() 讀一行
|--LineNumberReader: 增加了行號功能，getLineNumber() 、setLineNumber()
BufferedWriter：實現了緩沖功能 new BufferedWriter(new FileWriter("1.txt");
增加了新方法 newLine() 另起一行
BufferedInputStream：實現緩沖的功能
BufferedOutputStream：實現緩沖的功能
2.InputStreamReader： 轉換流 : 包裝，實現了編碼解碼的功能
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
用基礎流讀寫，自定義數組作為緩沖區，實現拷貝
-------以下做一個總結:
io流:數據傳輸的中轉站-->IO流-->目的地
IO流一般都是成對出現的,也就是說按照流的分向:輸入流-->輸出流
IO流按照操作來分: 字節流-->字符流
一.字符流
基類:Reader(讀)Writer(寫)
|-Reader
|--BufferedReader:對Reader進行了包裝,提供了緩沖區(8192),有ReadLine()方法
構造函數:BufferedReader(Reader r);
|--InputStreamReader:轉換流:將字節流轉換成字符流:new InputStreamReader(System.in);
|--FileReader:讀取文件的字符流,FileReader(File file) FileReader(String fileName);
|-Writer
|--BufferedWriter:包裝流:常用的方法write(String s)、flush()刷新 newLine()換行
構造函數:BufferedWriter(Writer w);
|--OutputStreamWriter:轉換流: new OutputStreamWriter(System.out);
|--FileWriter:寫入文件,FileWriter(File file) FileWriter(String fileName)
FileWriter(File file,boolean append),FileWriter(String fileName,boolean append)
當append為true,將寫入到文件的末尾處,當為false時,從文件開頭開始寫.就會覆蓋原來的.默認為false
二.字節流:
|-InputStream(輸入流)
|--FileInputStream:讀取文件的字符流,和FileReader基本是一樣
|--FilterInputStream:過濾流,一般不使用,只是針對了InputStream進行了包裝
|--BufferedInputStream:包裝類:BufferedReader(InputStream in),提供緩存功能
|-OutputStream(輸出流)
|--FileOutputStream:寫入文件的字符流,和FileWriter基本一樣
|--FilterOutputStream
|--BufferedOutputStream:包裝類:BufferedWriter(OutputStream out);
三.使用IO流必須要捕獲異常,原因在于我們必須要還資源(關閉流)
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.構造方法:
File(File parnt,String child)
根據prent抽象路徑名和child路徑名字符串創建一個新的file實例.
File(String pathname)
通過將給定的路徑名字來創建一個新的file實例.
File(String parent, String child)
根據 parent 路徑名字符串和 child 路徑名字符串創建一個新 File 實例.
2.常用方法:
isFile:判斷對象是否是一個標準文件
isDirectory:判斷對象是否為一個文件夾
isAbsolute:判斷是否為一個絕對路徑
exists:判斷對象指定的文件是否存在
createNewFile:根據對象的描述創建一個對象
getName:獲得文件名
getPath:獲得路徑名
getParent:獲得文件的父級抽象路徑
getAbsolutepath:獲得文件的絕對路徑名
mkdir:創建此抽象路徑指定的目錄,(只能在存在的文件夾下創建一個目錄)
mkdirs:創建此抽象路徑指定的目錄,包括所有必須但不存在的目錄.創建多級目錄(c:/a/b/c)
list(FilenameFilter filter)：根據指定過濾器遍歷文件夾中的所有文件，返回String[]
如果對象為標準文件，則返回null，如果對象是一個空文件夾，則返回空數組。length為0
FilenameFilter是一個接口，只有一個方法accept，我們需要實現接口的accept方法。
實現類是給list方法自動調用的
方法的參數是list方法傳給我們的，返回的結果也是給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)：跳過多少個字節
六:PrintStream、PrintWriter打印流
有一個特殊的方法print可以實現打印
write方法是直接將字節和字符寫出去
print：首先調用對象的toString方法轉成字符串(如果是基本數據類型，會先自動裝箱)
再將字符串編碼成字節數組，調用write方法寫出去
七:SequenceInputStream序列流
可以將多個字節流組合起來
構造方法：SequenceInputStream(Enumeration<? extends InputStream> e)
//Enumeration可以通過Vector來獲得，如果用的是ArrayList，如何獲得呢？
SequenceInputStream(InputStream in1,InputStream in2)
八:ObjectInputStream、ObjectOutputStream操作對象的字節流
一般成對出現
使用writeObject方法寫入的對象，只能由readObject方法讀出來
操作的對象必須實現java.io.Serializable序列化接口，該對象才可以被序列化和反序列化。
序列化: Java中規定的一種保存對象的數據格式
九:DataInputStream、DataOutputStream操作基本數據類型，格式化數據
readInt、writeInt等方法。
writeInt寫入一個整數，文件大小為4字節。證明就是把基本數據類型對應的字節寫出去了，沒有丟失精度
十:ByteArrayInputStream、ByteArrayOutputStream對Byte數組進行讀寫的字節流，針對內存進行讀寫
源和目的地都是內存，一般用于對內存中的數據進行處理。
十一:PipedInputStream、PipedOutputStream管道流
1、輸入管道流
構造方法：PipedInputStream(PipedOutputStream pos)實現拼接
也可以通過connect(PipedOutputStream pos)方法進行拼接
2、輸出管道流
構造方法：PipedOutputStream(PipedInputStream pis)實現拼接
也可以通過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();//關閉流
33 //首先我們把內容放到一個集合里面去
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 //必須要實現一個類
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中文網整理校對發布(javaweb.cc)
Abstract Window Toolkit(AWT)抽象窗口工具集
一個用本地圖形組件實現的圖形接口。這些組件提供了大部分的本地組件。這個接口正逐步被Swing組件所替代，參見Swing Set.
Abstract 抽象的
一個Java語言中的關鍵字，用在類的聲明中來指明一個類是不能被實例化的，但是可以被其它類繼承。一個抽象類可以使用抽象方法，抽象方法不需要實現，但是需要在子類中被實現
abstract class 抽象類
含有一個或多個抽象方法的類，不能被實例化。定義抽象類的目的是使其他類能夠從它繼承，并且通過實現抽象方法使這個類具體化
abstract method 抽象方法
沒有實現的方法
access control 訪問控制
控制用戶或程序訪問資源的權限，保證資源的一致性的方法
API 應用程序接口
Application Programming Interface的縮寫。指導應用程序開發人員訪問類方法和類狀態的說明
applet 小應用程序
通常在Web瀏覽器中執行的一個Java組件，同樣可以在其他的支持applet模型的應用程序或設備中執行
Applet container applet容器
一個支持applet的容器
argument 參數
在函數調用中使用的數據項。一個參數可以是常量、變量或表達式
array 數組
相同類型的數據的集合，每一個數據項通過一個整數唯一標識
ASCII
American Standard Code for Information Interchange的縮寫。一個標準的7位字符編碼，參見Unicode
Bean
一個可以重用的組件，可以通過組合Bean來創建應用程序
bean-managed persistence
當一個實體bean實例和資源管理器交換數據的時候，由實體bean實例來管理
bean-managed transaction
Enterprise Bean定義事務的界限的時候
binary operator 二值操作符
有兩個操作數的操作符
bit 位
計算機中表示信息的最小單位，只有0和1兩個值
bitwise operator 位操作符
并行的對一個或多個操作數的位進行單獨的操作。比如二進制邏輯運算符（&,|,^），二進制移位符（<<,>>,>>>）和求補運算符（~）
block 塊
在Java語言中，任何被大括號括起來的程序段。
boolean 邏輯型
指一個表達式或一個變量只能有true或者false兩種類型。Java語言提供了boolean類型以及true和false兩個常量
break
一個Java的關鍵字，用來改變程序執行流程，立刻從當前語句的下一句開始執行從。如果后面跟有一個標簽，則從標簽對應的地方開始執行
business logic 商業邏輯
實現某個應用功能的代碼。在Enterprise JavaBeans模型中，這種邏輯是由某個Enterprise Javabean的方法實現的。
business method 商業方法
某個Enterprise Javabean的方法用來實現商業邏輯或者某個應用的規則。
Byte 字節
順序的8位bit，Java語言中有對應的byte類型
bytecode 字節碼
由Java編譯器生成的跟機器相關代碼，由Java解釋器執行
callback methods 回調方法
組件的方法，由存放該組件的容器來調用的，用來在組件生命周期中通知它重要的事件
case
Java語言的關鍵字，用來定義一組分支選擇，如果某個值和switch中給出的值一樣，就會從該分支開始執行。
casting
強制類型轉化換
catch
Java的一個關鍵字，用來聲明當try語句塊中發生運行時錯誤或非運行時異常時運行的一個塊。
char
Java語言的一個關鍵字，用來定義一個字符類型
class 類
在Java語言中定義一個特定類的實現。一個類的定義包含成員變量，成員方法，還有這個類實現的接口，以及這個類的父類。如果沒有顯式指明父類，那么它的父類會隱式的被認為是Object。
class method 類方法
不需要引用特定對象就可以使用的方法，類方法的作用域是全局的，而不是某個特定的類實例，也被稱作靜態方法static method，參看instance method
classpath 類路徑
Classpath是一個環境變量，用來向Java虛擬機和基于Java的應用程序指明系統類庫和用戶類庫的位置（比如，工具包在JDK1.1.X/bin目錄中）
class variable 類變量
一個和整個類相關的數據項，而不是只和某個實例，類變量在類定義中定義，也被稱作static field,參看instance variable.
codebase
和<APPLET>標簽中的Code屬性配合給出找到applet類的完整路徑：Code給出文件的名字，Codebase指出包含該文件的URL路徑
comment 注釋
在編程語言中被編譯器忽略的解釋性語句。在Java中注釋使用//或/*…*/定界
compiler 編譯器
一個把源代碼翻譯成機器可以執行的代碼的程序。Java編譯器把Java源碼翻譯成Java虛擬機能夠識別的字節碼，參見interpreter
component 組件
一種被容器所支持的應用級的軟件單元。組件在使用的時候是可配置的。J2EE平臺定義了四種類型的組件：Enterprise Bean，Web components，applets和application client。
component contract
組件和它的容器之間的規范。這種規范包括：組件的生命周期的管理，一個上下文的接口，組件可以通過它獲得容器的信息和服務，以及每個容器必須提供的一系列服務。
component environment
應用程序組件提供商定義的一個集合，使組件在J2EE組件的名字空間中可見。環境選項由組件的使用描述符指明。每一個組件命名并訪問它的環境配置值通過使用java:comp/evn JNDI上下文。這些值可以是組件所依賴的一個對象，比如JDBC DataSouce，或者一個簡單值，比如一個稅率。
Connector 連接器
一個標準的擴充機制使容器可以提供到EISs的連接。一個連接器連接到特定的EIS，由資源適配器和針對EIS的應用開發工具組成。一個資源適配器插入到一個容器通過在連接器體系結構中定義的系統級的聯系。
connector architecture
一個集成J2EE和EISs的體系結構。這個體系結構中有兩大部分：一個EIS廠商提供的資源適配器和一個允許這個適配器插入的J2EE服務器。這個體系結構定義了一系列資源適配器為了能插入J2EE服務器而必須支持的規范，比如事務，安全，資源管理。
Constructor 構造函數
一個創建對象的偽方法。在Java語言中構造函數是和類同名的成員函數。構造函數一般用在new操作符之后。
Container 容器
一個為組件提供生命周期管理，安全，配置，和運行時服務的實體。每一個類型的容器（EJB, Web, JSP, servlet, applet, 和application client）也會提供各自組件相關的服務
container-managed persistence
當一個實體bean實例和資源管理器交換數據的時候，由資源管理器來管理
container-managed transaction
當一個EJB容器定義一個事務的邊界的時候，一個Bean必須使用這種事務類型
continue
一個Java的關鍵字，用來打斷當前循環過程，從當前循環的最后重新開始執行，如果后面跟有一個標簽，則從標簽對應的地方開始執行。
core class 核心類
一個Java平臺上的標準的公共類或接口。Java平臺的核心類，至少在所有的能支持Java的操作系統的平臺上都是可用的。一個完全用Java編寫的程序只需要Java核心類就可以運行了，這意味著它能夠在任何地方運行，參看100% Pure Java(TM).
Core Packages 核心包
在任何Java平臺和任何兼容平臺上必須被支持的API的集合。
Declaration 聲明
一個在標識符和屬性之間建立聯系的語句，不需要必要的存儲分配或具體實現。參見definition
default 缺省的
一個Java語言的關鍵字，作為在switch語句中的所有case之后的可選項，如果所有的case條件都沒有被滿足，就會執行default語句
delegation 授權
一種某個負責人批準另外一個負責人在一定限制下使用它的身份或特權的行為
deprecation
指不再推薦的類，接口，構造函數，方法或成員變量，可能在以后的版本中會消失
derived from
類X "derived from" 類Y就是指類X是從類Y繼承過來的，參見subclass, superclass
distributed 分布的
在多于一個的地址空間內運行
distributed application 分布式應用
由不同的運行于分離的運行環境下的組件構成的應用程序，通常是在不同的平臺上通過網絡互聯起來。典型的分布式應用是二端（Client/Server），三端（client/middleware/server）和n端（client/multiple middleware/multiple server）
do
一個Java語言的關鍵字，用來聲明一個循環，這個循環的結束條件可以通過while關鍵字設置
DOM
Document Object Model的縮寫。一棵由擁有包含遍歷這棵樹并且生成相應XML文檔的接口的對象構成的樹，符合W3C的規范
double
一個Java語言的關鍵字，用來定義一個double類型的變量
EJB container EJB容器
一個實現了J2EE體系結構中EJB組件規范的容器。這個規范指定了一個Enterprise bean的運行時環境，包括安全，一致性，生命周期，事務，配置，和其他的服務。一個EJB容器可以由EJB或者J2EE服務器提供。
EJB Container Provider EJB容器提供商
提供EJB容器的廠商
EJB context EJB上下文
一個允許Enterprise Bean使用容器提供的服務和獲得客戶-請求（client-invoke）方法調用者信息的對象
EJB home object
一個提供關于Enterprise Bean生命周期操作（創建，刪除，查找）的對象。這個對象的類型是由容器的配置工具產生的。EJB home object實現了Enterpeise Bean的home接口。客戶通過引用一個EJB home object來進行生命周期的操作。客戶使用JNDI來定位一個EJB home object
EJB .jar file
一個包含EJB模塊的JAR文件
EJB module
一個由一個或多個Enterprise bean和一個EJB配置描述符組成的軟件單元。
EJB object
實現了enterprise bean的remote接口的對象。客戶不能直接引用一個enterprise bean的實例；客戶總是引用一個EJB object。EJB object的類型是由容器的配置工具生成的。
EJB server
為EJB容器提供服務的軟件。比如，典型的，一個EJB容器總是依靠一個作為EJB Server一部分的事務管理器來進行雙向的確認在所有參與的資源管理器之間。J2EE體系結構假設EJB容器和EJB Server是由同一廠商提供的，所以沒有制定這兩個實體之間的規范。一個EJB Server可以包含一個或多個EJB Container
EJB Server Provider
提供EJB Server的廠商
EIS resource
一個為客戶提供符合EIS規范的功能的實體。例子有：一條或多條數據庫中的記錄，在一個ERP系統中的一個business object，在一個事務處理系統中的一個事務程序
else
一個Java語言的關鍵字，如果if語句的條件不滿足就會執行該語句。
encapsulation 封裝
一個模塊中的內部屬性，因為對象會封裝數據和實現，使用者可以把對象看作一個能提供服務的黑匣子。實例變量可以被添加，刪除，或改變。只要這個對象所提供的服務是不變的，使用這個對象的代碼就可以繼續使用而不需要修改，參見instance variable, instance method.
enterprise bean
實現商業任務和商業實體的組件；或者是一個entity bean，或者是一個session bean
Enterprise Information System (EIS)
一個包含企業已經存在的獲取企業級信息的系統的應用程序，這些應用程序為企業提供了一個信息結構。一個EIS系統提供很好定義的服務的集合給它的客戶。這些服務在客戶看來是本地的和/或者遠程的接口。EIS的例子有：一個ERP系統，一個事務處理系統的主框架，一個遺留的數據庫系統。
Enterprise Bean Provider Enterprise Bean提供商
生產enterprise bean，remote和home接口，配置描述符文件，并把這些打包入JAR文件的應用程序開發人員
Enterprise JavaBeans(TM) (EJB)
一個用于開發和使用面向對象的，分布式的，企業級應用程序的組件體系結構。使用Enterprise JavaBeans體系結構編寫的軟件是可擴展的，面向事務的，多用戶的，安全的。
entity bean
一個代表由數據庫維護的持久數據的enterprise bean。一個entity bean可以管理它自己的持久性，或者把這個功能授權給它的容器。一個 entity bean由一個主鍵來標識。如果存放entity bean的容器崩潰了，那么這個entity bean，它的主鍵，以及任何遠程的引用都能從崩潰中幸存下來。
ebXML
ebXML建立在XML(Extensive Markup Language)之上，目的是提供一系列模塊化的規范，使任何地方的任何規模的企業都能夠通過Internet指導商業活動。它提供了公司和組織一個標準的方法來交換數據，指導商業關系，交流數據通過公共的形式，定義并注冊商業過程
exception 異常
一個在程序執行過程中阻止程序正常執行的事件，通常是一個錯誤。Java語言通過try，catch和throw關鍵字支持異常的處理，參見exception
handler
exception handler
一段處理特定類型的異常的代碼。如果程序能夠從異常中恢復過來，那么在處理完異常之后程序可以繼續執行。
executable content
在HTML文件中執行的應用程序，參見applet。
extends 繼承
類X 通過extend 類Y來添加功能，或者添加變量，或者添加方法，或者覆蓋類Y的方法。一個接口extends另外一個接口來添加方法。類X稱為類Y的一個子類，參見derived from
field 域
一個類的數據成員。除非顯式指明，否則一個field不是static的
final
一個Java語言的關鍵字。你只能定義一個實體一次，以后不能改變它或繼承它。更嚴格的講：一個final修飾的類不能被子類化，一個final修飾的方法不能被重寫，一個final修飾的變量不能改變其初始值。
finally
一個Java語言的關鍵字，用來執行一段代碼不管在前面定義的try語句中是否有異?；蜻\行時錯誤發生。
float
一個Java語言的關鍵字，用來定義一個浮點數變量
for
一個Java語言的關鍵字，用來聲明一個循環。程序員可以指定要循環的語句，推出條件和初始化變量。
FTP
基本的Internet文件傳輸協議（File Transfer Protocol）。FTP是基于TCP/IP協議的，它允許在主機之間通過Internet傳送文件。參見TCP/IP
formal parameter list
在一個方法的定以中指定的參數。參見actual parameter list
handle
一個標識enterprise bean的對象。客戶可以串行化handle，以后從串行化中恢復handle來得到一個對enterprise bean的引用
hexadecimal 十六進制的
使用16作為基的計數系統。記號0-9和a-f（或者A-F）代表了數字0到15。在Java中16進制數必須帶有0x前綴。參見octal
hierarchy
關系的一種分類，除了最高層的對象（通常稱作root），每一個對象有一個專門的上層對象。每個對象可以由一個或多個下層對象在層次關系中。在Java中，root對象是Object
home interface
enterprise bean兩個接口中的一個。home接口定義了0個或多個方法來創建和刪除一個enterprise bean。對于session bean，home接口定義了創建和刪除方法，然而對于entity bean，home接口定義了創建，查找和刪除的方法。
home handle
一個對象，能夠用來得到對一個home接口的引用。一個home handle能夠被串行化寫入持久存儲器中，通過反串行化來得到這個引用。
HTML
HyperText Markup Language的縮寫。這是一個文件格式，基于SGML，為了超文本在Internet上的傳輸。它十分簡單，允許嵌入圖片，聲音，視頻流，表單域和簡單的文本格式。對其他對象的引用被嵌入到URLs中。
HTTP
HyperText Transfer Protocol的縮寫。Internet的協議，基于TCP/IP，用來獲得遠程主機上的超文本。參見TCP/IP。
HTTPS
建立在SSL協議之上的超文本傳輸協議（HTTP）
IDL
接口定義語言（Interface Definition Language）的縮寫，使用Java(TM)編寫的API提供基于標準的和CORBA的交互性和連接性。
identifier 標識符
在Java程序中一個對象的名稱
IIOP
Internet Inter-ORB Protocol的縮寫。一個用來在CORBA對象請求代理之間交流的協議。
if
Java編程語言的一個關鍵字，用來生成一個條件測試，如果條件為真，就執行if下的語句。
implements
Java(TM)編程語言的一個關鍵字，在類的聲明中是可選的，用來指明當前類實現的接口。
import
Java(TM)編程語言的一個關鍵字，在源文件的開始部分指明后面將要引用的一個類或整個包，這樣就不必在使用的時候加上包的名字。
inheritance 繼承
一個概念：一個類型會自動包含其父類型（supertypes）的變量和方法。參見superclass, subclass。
initialization parameter
初始化Servlet上下文的參數。
instance 實例
一個特定類型的對象。在Java(TM)語言中，一個對象是由new操作符創建的。
instance method 實例方法
任何跟一個類的實例相關的方法，也稱作method。參見class method。
instance variable 實例變量
任何和一個特定對象相關的數據項。每一個類的實例有一份類定義中聲明的實例變量的拷貝，也稱作field。參見class variable。
instanceof
一個二操作數的Java(TM)語言關鍵字，用來測試第一個參數的運行時類型是否和第二個參數兼容。
int
Java(TM)的一個關鍵字，用來定義一個整形變量
interface
Java(TM)的一個關鍵字，用來定義一系列的方法和常量。它可以被類實現，通過implements關鍵字。
Internet
一個由全球各個組織，各個國家的數百萬的主機組成的巨大的一個網絡。它是由很多小網絡物理的連接在一起而成的，數據通過公共的一組協議傳輸。
IP
Internet Protocol的縮寫，Internet的基本協議，它提供不可靠的主機間的數據包的傳送。它不保證是否數據包能夠正確傳送，需要多久的時間來傳送，或者當有多個包時是否按順序到達。建立在該協議之上的協議提供連接和可靠性的概念。參見 TCP/IP.
interpreter 解釋器
一個可選解碼并且執行代碼中的每一句語句的模塊。Java(TM)解釋器解碼并執行為符合Java虛擬機規范的字節碼。參見compiler, runtime system。
ISV
Independent Software Vendor的縮寫
本篇文章來自Java中文網：http://javaweb.cc/other/english/2212.shtml
教程由JAVA中文網整理校對發布(javaweb.cc)
J2EE application
任何可配置的J2EE功能單元?？赡苁怯梢粋€或多個軟件模塊與一個J2EE應用程序配置描述符打包成.ear文件。J2EE應用程序通常設計成在多機環境下運行的分布式應用。
J2EE product
一個遵循J2EE平臺規范的實現。
J2EE Product Provider
提供J2EE產品的生產商。
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是一種把許多文件聚合到一個文件的平臺無關一種文件格式。許多個用Java編寫的applet以及它們所需要的組件（.class文件，圖片，聲音和其他資源文件）能夠被打包到一個JAR文件中，以便以后在單獨一個HTTP請求中就能夠下載到客戶端。它同樣支持文件壓縮和數字簽名。
Java(TM)
是Sun公司的商標，標識了一系列在獨立的和網絡化的環境中創建并安全的運行程序的技術。
Java Application Environment (JAE)
Java Development Kit (JDK(TM))的源代碼。
Java(TM) 2 Platform, Standard Edition (J2SE platform)
核心的Java技術平臺
Java(TM) 2 Platform, Enterprise Edition (J2EE platform)
一個用來開發和配置企業應用程序的環境。J2EE平臺由一系列的服務，應用程序接口（APIs）和提供開發多級的，基于Web的功能的協議組成。
Java(TM) 2 SDK, Enterprise Edition
Sun公司的對J2EE平臺的一個實現。這個實現提供了一個可操作的J2EE平臺的定義。
JavaBeans(TM)
一個可移植的，平臺無關的，可重用的組件模型。
Java Blend(TM)
一個通過映射數據庫數據到Java編程環境中的對象（Object）和映射對象到數據庫使程序員能夠簡化數據庫應用開發的產品。
Java Card(TM) API
一個和ISO 7816-4兼容的應用開發環境，集中在smart card上。
JavaCheck(TM)
一個工具，用來檢查一個應用程序或一個applet是否符合某個規范。
Java(TM) Compatibility Kit (JCK)
一個測試包，一組工具，和其它的一些需求，用來檢查一個實現是否和Java平臺規范和軟件參考實現兼容。
Java Database Connectivity (JDBC(TM))
一個Java平臺和大量數據庫平臺之間互聯的平臺無關的工業標準。JDBC(TM)提供了調用級的API來操作支持SQL語言的數據庫。
Java Developer Connection(SM)
一個為個人開發者設計的服務，提供在線訓練，產品打折，專題文章，錯誤信息和一些早期的版本兼容性信息。
Java Development Kit (JDK(TM))
一個軟件開發平臺，支持使用Java語言編寫Applet或應用程序。
Java(TM) Enterprise API
這個API使編寫大型的，可能在一個組織中或Internet上與其它應用程序共享多媒體數據的商業或數據庫應用程序變得簡單。在Java(TM)
Enterprise API家族中已經有四個APIs被設計出來。
Java(TM) Foundation Classes (JFC)
一個擴展，把圖形用戶接口加入到抽象窗口工具集（AWT）中。
Java(TM) IDL
一個提供J2EE平臺與CORBA交互能力和互聯能力的技術。這些兼容性使J2EE應用程序能夠通過OMG IDL和IIOP調用遠程網絡上的操作。
Java(TM) Interface Definition Language (IDL)
用Java編寫的APIs，提供標準化的與CORBA（Common Object Request Broker Architecture）的交互能力和互聯能力。
Java(TM) Message Service (JMS)
使用企業級消息系統的API，比如IBM MQ Series，TIBCO Reanezvous等。
Java Naming and Directory Interface(TM) (JNDI)
一組用來提供多重命名和目錄服務的APIs的集合。
JavaOS(TM)
一個基于Java的操作系統，對各種計算和用戶平臺進行了優化。JavaOS(TM)操作環境提供了一個運行時規范，使Java程序能夠直接運行在硬件平臺之上而不需要宿主操作系統。
Java(TM) Platform
由Java編程語言，一組APIs，類庫，其它在開發，編譯，錯誤檢查中要用到的程序，和一個能夠裝載并執行class文件的Java虛擬機組成。
除此之外，Java平臺的目標是提供一組一致的兼容的實現。符合兼容性規范的實現能夠得到Sun公司的兼容性標志。
Java 2是當前的一代Java平臺。
Jini(TM) Technology
一組Java APIs，可能是任何一個Java 2平臺的可選包。Jini API使網絡設備和服務變得透明，不再需要用戶去管理系統或網絡使其正常工作。
Jini在目前是任何一個Java平臺版本的一個可選軟件包。
JNDI
Java Naming and Directory Interface(TM)的縮寫，一組用來提供重命名和目錄服務的APIs的集合。
JPEG
Joint Photographic Experts Group的縮寫。 由這個小組建立的一個圖象文件壓縮標準。它通過幾乎察覺不出的圖象質量的損失來實現了巨大的圖象壓縮比。
JRE
Java(TM) runtime environment的縮寫。一個Java Development Kit (JDK(TM))的子集，適合最終用戶和希望重新發布運行環境的開發人員。Java runtime environment由Java虛擬機，Java核心類和支持文件組成。
Just-in-time (JIT) Compiler
一個在Java運行時，把所有字節碼轉換為本地代碼的編譯器。這樣就會加速Java的執行，相對Java虛擬機的解釋執行。
JVM
參見: Java(TM) Virtual Machine (JVM)
本篇文章來自Java中文網：http://javaweb.cc/other/english/2213.shtml
教程由JAVA中文網整理校對發布(javaweb.cc)
lexical
關于如何把源代碼翻譯成各種編譯器能夠識別的記號
literal
整數，浮點數，字符的基本表示方法。比如，字面上3.0是一個雙精度浮點數，"a"是一個字符。
local variable
一個塊中可見的數據項，但是對塊外面的代碼是不可見的。比如，任何在一個方法中聲明的變量是一個局部變量，不能在方法外面被使用。
long
Java語言的一個關鍵字，用來定義一個long類型的變量。
member
類的一個域或者方法，除非顯式指明，否則一個member不是靜態的。
method
類中定義的一個方法，參見instance method, class method，除非顯式指明，否則一個method不是靜態的。
module
一個軟件單位，由一個或多個相同容器類型的J2EE組件和一個相同類型的配置描述符組成。有三種module類型：EJB，Web，和Application Client。模塊可以被配置成獨立的單元或嵌入到應用程序中。
Mosaic
一個提供簡單圖形界面，使用戶能夠方便的訪問Internet上的數據的程序。這些數據可能是簡單文件，或者超文本文檔。Mosaic是由NCSA的一個小組編寫的。
multithreaded
描述一個程序，它的代碼被設計成擁有多個同時被執行的部分。參見thread。
object
面向對象程序的主要的一個構造塊。每一個對象是一個編程單元，由數據（instance methods）和功能（instance methods）組成，參見class。
object-oriented design
一個軟件設計方法，通過類和對象為抽象和具體的對象的特點建模。
octal
使用8作為基的計數系統。使用數字0-7。在Java中8進制數必須帶有0前綴。參見hexadecimal。
One
Open Net Environment的縮寫，由Sun組織，主要工業參與商資助，描述了一個易于理解的體系結構，用來創建，編譯和配置Web服務。ONE是平臺無關的，基于完全開放的標準。Sun ONE指代一個特定的由Sun和iPlanet提供的對這個體系結構的實現。
Optional Packages
一個或多個APIs的集合，在Java平臺上，它們是可用的，并且可能在兼容平臺上也被支持。
隨著時間推移，Optional Packages可能因為市場需要而變成必需的。
ORB
Object Request Broker的縮寫。一個函數庫，使CORBA對象能夠定位另一個對象且和它通訊。
OTS
Object Transaction Service的縮寫，一組接口定義使CORBA對象能夠處理事務。
overloading
在同一個作用域里面使用一個標識符指代多個對象。在Java語言中，你可以overload方法，但不能是變量和操作符。
overriding
在子類中對在父類中定義的方法提供一個不同的實現。
re-entrant enterprise bean
一個enterprise bean，能夠被并發的，交叉的，或遞歸的調用，并且相互之間不干擾。
reference
一個內容是地址的數據元素。
remote interface
enterprise bean兩個接口中的一個。remote接口定義了能夠被客戶調用的商業方法。
remove method
在home接口中定義的方法，客戶端可以調用它來刪除一個enterprise bean。
resource adapter
一個系統級的軟件驅動，被EJB容器和應用程序客戶用來連接到一個EIS。通常一個resource adapter總是針對某一特定EIS的。它以函數庫的形式提供，運行在使用它的服務器或客戶地址空間中。一個resource adapter插入到一個容器中。應用程序組件配置容器，然后使用客戶端API（由adapter提供的）或者由高層抽象生成的工具來訪問下面的EIS。resource adapter和EJB容器配合提供與EIS連接的下層機制 - 事務，安全，和連接池。
resource manager
提供訪問一組共享對象的能力。一個recource manager參與一個被事務管理器外部控制和調整的事務。一個resource manager通常和訪問它的客戶運行在不同的主機上和不同的地址空間中。
resource manager connection
代表一個和資源管理器的會話的對象。
resource manager connection factory
一個用來創建資源管理器對象的對象。
本篇文章來自Java中文網：http://javaweb.cc/other/english/2214.shtml
教程由JAVA中文網整理校對發布(javaweb.cc)
role (development)
在開發和配置一個基于J2EE技術的應用程序的過程中某個對象起到的作用。role有：應用程序組件提供者，應用程序編譯者, 應用程序配置者
, J2EE平臺提供者, EJB容器提供者, EJB容器提供者, Web容器提供者, Web服務器提供者,工具提供者和系統管理員。
role (security)
一個抽象的邏輯的用戶組，由Application Assembler定義。當一個application被配置的時候，roles被映射到安全標識，比如負責人或者組，在操作和環境中。
role mapping
把由容器所識別的組和負責人和由配置描述符定義的安全角色聯系起來的一個過程。在組件被安裝到服務器之前，安全角色必須被配制器映射。
rollback
當一個事務中所有的對數據庫的更新被取消的一個點。
root
在對象層次中的一個對象，所有對象都是從它繼承而來的，root對象在層次圖中沒有上層對象，參見hierarchy, class, package。
RPC
Remote Procedure Call的縮寫。通過向遠程主機發送網絡數據包執行，看上去就跟普通的調用過程（或方法調用）是一樣的，
runtime system
一個軟件環境，其中能夠運行為Java虛擬機編譯的程序。runtime system包含了為了裝入用Java編寫的程序，動態連接本地方法，內存管理，異常處理和實現一個Java虛擬機（可能是Java一個解釋器）所必須的代碼。SAX
Simple API for XML的縮寫。一個為訪問XML文檔提供的事件驅動的，串行訪問的機制。
Sandbox
由許多的系統組件組成，從作為應用程序一部分運行的安全管理器，到Java虛擬機中的和語言本身的安全措施。SandBox保證一個不可信任的，可能惡意攻擊的應用程序不能訪問系統資源。
scope
一個特性標識，用來規定哪些地方標識符是可見的。Java環境中的大多數標識符擁有類或者局部的scope。實例變量和類變量有類的scope；它們在類的外部或者子類中使用時必須在它們前面加上一個類名前綴（對類變量和類方法）或者類實例名。所有其他的在方法內部定義的變量具有局部scope；它們只能在封閉的塊中使用。
Secure Socket Layer (SSL)
一個為了個人隱私在Web服務器和瀏覽器之間進行加密的協議。
security attributes
一組和負責人相關聯的屬性。Security attributes能夠和一個負責人相關聯，通過J2EE產品提供商制定的認證協議。
本篇文章來自Java中文網：http://javaweb.cc/other/english/2215.shtml
教程由JAVA中文網整理校對發布(javaweb.cc)
security constraint
一個明確的方法來注釋想要的對Web內容的保護。一個security constraint由一系列Web資源，一個認證限制和用戶數據限制組成。
security context
一個對象，封裝了跟安全有關的兩個實體之間的共享狀態信息。
security permission
由J2SE定義的J2EE平臺用來表述應用組件供應商必須遵循的編程限制的一個機制。
security permission set
J2EE產品提供商為每一個組件類型的執行所必須提供的安全允許的最小集合。
security policy domain
一個作用域，其中安全策略被定義并且由安全管理員強制執行。一個security policy domain有以下的幾個特征：
它有一組用戶（或者負責人）
它有一個很好定義的認證協議來認證用戶
它可能有組的概念來簡化安全策略的設置
security technology domain
一個作用域，其中同樣的安全機制被用來強制執行一個安全策略。在單個technology domain中可以存在多個security policy domain。
server principal
服務器在操作系統中執行的地位。
servlet
一種擴展Web服務器功能的Java程序，動態生成文檔，并且使用使用請求應答的方式和用戶交互。
stream
Stream是一個簡單的從發送著到接受者的數據字節流。有兩種基本的分類，所以java.io包包含兩個抽象類（InputStream和OutputStream）。
subarray
一個在另一個數組中的數組。
subclass
從某個類派生出來的類，可能是和一個或多個類之間的關系。參見superclass, supertype。
subtype
如果類型X繼承或者實現了類型Y，那么X是Y的一個subtype。參見supertype。
superclass
一個類，某個類是從它派生而來的，可能是和一個或多個類之間的關系。參見subclass, subtype。
super
Java語言的一個關鍵字，用來訪問父類的類成員。
supertype
一個類型的父類型是指它所實現的所有接口和繼承的類型，參見subtype, superclass。
switch
Java語言的關鍵字，用來計算一個變量，在后面用來匹配由case語句指定的值，以決定執行哪一組語句。
Swing Set
一系列圖形用戶接口GUI）組件的代碼名稱，能夠在任何支持Java虛擬機的本地平臺上一致的運行。因為它們是完全用Java語言編寫的，這些組件可能提供的功能比本地平臺提供的等價功能更為強大。（和AWT對比）
synchronized
Java語言的關鍵字，當它用來修飾一個方法或者一個代碼塊的時候，能夠保證在同一時刻最多只有一個線程執行該段代碼。（
TCP/IP
Transmission Control Protocol based on IP的縮寫。這是一個Internet協議，提供可靠的基于流的從一個主機到另一個的數據傳輸。參見IP。
Technology Compatibility Kit (TCK)
一個測試包，一組工具，和其它必需的東西，用來證明一個特定的Sun的技術的實現是否和應用程序規范兼容或者是否和Sun和Sun設計的參考實現兼容。
this
Java語言的關鍵字，用來代表它出現的類的一個實例。this可以用來訪問類變量和類方法。
UDDI
Universal Description Discovery and Integration的縮寫。UDDI提供了一個全局的，公共的，基于XML的，在線的商業注冊，商業用戶通過它可以注冊并宣傳它們的Web服務。UDDI定義Internet版的白頁和黃頁電話號碼本。
Unicode
ISO 10646定義的16位長的字符集。參見ASCII。Java環境中所有的源代碼都是用Unicode編寫的。
URI
Uniform Resource Identifier的縮寫。一個用來標識抽象或物理資源的簡潔字符串。一個URI或者是一個URL或者是一個URN。URLs和URNs是具體的確實存在的實體。URI是一個抽象的父類。
URL
Uniform Resource Locator的縮寫。一個使用文本指代WWW網站上任意數據的標準。一個URL通常是這樣的"protocol://host/localinfo"，protocol指明傳輸對象的時候使用的協議（比如HTTP或FTP），host指明在Internet上找到一臺主機的名字，localinfo是一個傳遞給遠程主機上協議處理器的字符串（常常是一個文件名）。
URL path
通過一個HTTP請求傳遞的URL，來使用一個servlet。URL由Context Path + Servlet Path + PathInfo組成，其中被請求的servlet是與Context Path相關聯的servlet上下文的一部分。如果這個上下文是默認的上下文，以Web服務器的URL名字空間的基目錄為根，那么這個路徑前綴將會是一個空字符串。否則這個路徑前綴以/開始，但是不是以/結束。Servlet Path部分直接和激活這個請求的映射對應。這個路徑以/字符開始。PathInfo是請求路徑的一部分，但不是Context Path或者Servlet Path的一部分。
URN
Uniform Resource Name的縮寫。唯一標識一個實體的標識符，但是不能給出實體的位置。系統可以先在本地尋找一個實體，在它試著在Web上找到該實體之前。它也允許Web位置改變，然而這個實體卻還是能夠被找到。
variable
由一個標識符命名的數據項。每一個variable有一種類型，比如一個整數或者一個對象，和一個作用域。參見class variable, instance variable, local variable。
virtual machine
一個抽象的計算設備規范，可以使用不同的方法實現，軟件的或者硬件的。你把程序編譯成virtual machine的指令集和你把程序編譯成微處理器指令集是十分相似的。Java(TM) virtual machine*由字節碼指令集合，一組寄存器，一個堆棧，一個垃圾收集堆和一個存放方法的區域
本篇文章來自Java中文網：http://javaweb.cc/other/english/2216.shtml
教程由JAVA中文網整理校對發布(javaweb.cc)
vocabulary
傳統上，軟件程序被編寫，然后編譯成直接和計算機中驅動微處理器工作的操作系統相關的機器碼。Java平臺通過提供一個程序編寫編譯，然后能夠通過網絡傳輸并且在任何由足夠兼容性的虛擬機的平臺上運行的模型減輕了這種依賴型。
這個模型提供了額外的好處，高安全性，即因為程序可以被虛擬機驗證一致性在通過網絡傳輸之后，也因為虛擬機運行在安全的"sandbox"的中，能夠阻止一些特定的破壞性的行為。
軟件開發人員已經投入Java語言的懷抱，因為它減少了編寫程序和支持軟件代碼的費用和時間。他們不再需要為不同的操作系統和不同的微處理器重新編寫功能相同的代碼。正在配置應用程序的公司和組織喜歡Java，因為它減少了購買和修改不同版本的應用程序使其適應各自網絡環境中各種類型的計算機和服務器的費用。
void
Java語言的關鍵字，用在Java語言的方法聲明中說明這個方法沒有任何返回值。"void"也可以用來表示一句沒有任何功能的語句。
volatile
Java語言的關鍵字，用在變量的聲明中表示這個變量是被同時運行的幾個線程異步修改的。
一個UNIX命令，使用它將會等待所有的后臺進程結束，并且報告他們的結束狀態。
Web application, distributable
用J2EE技術編寫的應用程序，所以它可以被配置到一個分布運行在一臺或多臺主機的多個Java虛擬機中的Web容器中。這種類型的應用程序的配置描述符使用可分布的元素。
Web component
一個通過相應為請求提供服務的組件，或者是一個Servlet或者是一個JSP頁面。
Web container
實現J2EE體系結構中Web組件協議的容器。這個協議規定了一個Web組件運行時的環境，包括安全，一致性，生命周期管理，事務，配置和其它的服務。一個提供和JSP和J2EE平臺APIs界面相同服務的容器。一個Web container 由Web服務器或者J2EE服務器提供。
Web container, distributed
一個Web容器，能夠運行一個標記為分布式的，在同一臺主機或不同主機上的多個Java虛擬機中運行的Web應用程序。
Web server
提供訪問Inetrnet，Intranet或者Extranet服務的軟件。一個Web server運行在Web站點上，提供對HTTP和其它協議的支持，并且運行服務器端的程序（比如CGI腳本或者servlets）來實現一定的功能。在J2EE體系結構中，Web Server為Web容器提供服務。比如，一個Web容器通常依靠Web Server來處理HTTP消息。J2EE平臺假設一個Web容器總是運行在同一個廠商提供的Web Server之上，所以沒有制定這兩個實體之間的協議。一個Web Server可以運行一個或多個Web容器。
posted @
2012-08-18 19:48 、小細 閱讀(133) |
評論 (0) |
編輯 收藏
Map集合
1.Map存儲了一系列鍵值的映射關系
2.Map集合需要保證鍵的唯一性
3.可以通過鍵獲取到值,反之則不能
4.Map集合存儲元素使用put(key,valus)方法.
5.遍歷Map集合的兩種遍歷方式
a)通過KeySet方法返回由鍵組成的集合,迭代集合里面的元素拿到所有的鍵再通過get方法根據鍵來獲取值
b)通過entrySet方法返回鍵所映射的關系組成的集合,迭代該集合就拿到一個鍵值映射的關系,再通過getKey獲取到鍵,再通過getValue()方法獲取到值
HashMap
線程不安全,存儲速度快,允許存放null鍵,null值
通過HashSet保持鍵的唯一性
Hashtable
線程安全,存儲速度慢,不允許存放null鍵與null值
TreeMap
通過二叉樹的原理保證了鍵的唯一性
對鍵進行了排序,排序原理與SetMap相同.
(如果想要使用這個方法,必須要沖構造方法里面重寫Comparator 或者從對象所屬的類繼承Comparator實現這個接口)
Properties
Hashtable的子類,所以是線程安全的.
用于讀寫配置文件,一般配置項等號兩邊都是String,所以集合中的兩個列保存的都是String類型的數據.
這個集合中只能存String,所以不能使用泛型.
/*JavaAPI總結:application programming interface應用程序編程接口 sun公司提供給我們用的程序
一、String、StringBuffer、StringBuilder
1、String類是字符串常量
2、String池：String s = "abc" 和String s = new String("abc")的區別
3、String類的常用方法：charAt、indexOf、toCharArray、substring、split、compareTo、equals
4、StringBuffer：字符串容器，長度可變，一般用于字符串的增減刪的操作。reverse方法反向
String s = "abc"; s = s + "xxx";//String長度不可變，因為是常量
5、StringBuilder線程不安全，StringBuffer線程安全
二、集合類
|-Iterable：實現增強for循環
|--Collection:單列，按照一種或多種規則來存儲一系列元素
|---List:有序，允許有重復元素
|----AbstractList：抽象類，實現了iterator方法。
|-----ArrayList：數組實現，查找塊，增刪慢
|-----Vector：和ArrayList一樣，只是線程安全
|-----LinkedList：鏈表實現，查找慢，增刪塊
|---Set：無序，不允許有重復元素
|----HashSet：通過哈希算法保證元素不重復，對象要正確重寫equals和hashCode方法
|----HashTable：同上，但是線程安全
|----TreeSet：通過樹狀結構保證元素不重復，兩種方式
1、按照元素的自然順序進行排序，前提是元素具備比較功能，實現了Comparable接口的compareTo方法
2、在構造TreeSet實例時，傳入一個比較器，實現Comparator接口的compare方法
|-Map：保存的是鍵值對應關系，其中鍵不允許有重復，可以通過keySet方法拿到一個包含所有鍵的Set
再調用get(key)方法通過鍵拿到value
|--HashMap:通過HashSet的原理保證鍵不重復。
|--TreeMap：通過TreeSet的原理保證鍵不重復
|--Properties：用于讀取配置文件，不需要聲明泛型，因為鍵和值都只能為String類型。
list方法將集合中的配置項輸出到一個打印流
load方法將一個輸入流中的配置項存到集合中
Jdk1.5新特性泛型，減少集合存元素時錯誤發生的幾率。
Jdk1.5出現Iterable，為了實現增強for循環 for(元素類型 變量：集合或數組)
工具類：
Collections：集合工具類，sort、binarySearch、reverse
Arrays：數組工具類，sort。。。。
三、包裝類
1、Integer x = 0;x = x + 1; 裝箱-拆箱-裝箱（jdk1.5）
2、Interger.parseInt(String)將字符串轉為int型
四、System類
1、System類的常用方法：gc()垃圾回收、exit(0)終止程序、currentTimeMillis()獲得自1970年1月1日零時
以來的毫秒數、getProperty方法獲得系統屬性。
2、兩個靜態成員變量：in和out
in：標準輸入流，InputStreamReader類型
out：標準打印流，PrintStream類型
五、Runtime類
表示運行時，exec方法，在后臺新開啟一個窗口運行命令，是當前窗口的子窗口，繼承所有窗口屬性
六、日期對象
1、Date：大部分方法已過時，用new Date()創建日期對象表示當前時間
2、DateFormat：將日期格式化，抽象類
DateFormat df = DateFormat.getInstance(); String dateStr = df.format(new Date);
3、Calendar對象：
Calendar c = Calendar.getInstance();
可以將類中定義的常量當做參數傳入get和set方法來獲得和設置時間。
add方法，增加時間值，具體增加哪一項，就看傳入的常量，調用完此方法，時間對象就被改變了。
*/
面試題目總結:
一、請說說ArrayList、Vector和LinkedList的區別
這三者都是單列集合Collection下List集合的實現類，所以他們的共同點，元素有序，允許重復元素
不同點：
ArrayList和Vector底層都是數組實現，這樣的實現注定查找快、增刪慢
ArrayList和Vector的區別在于線程安全問題，Vector支持線程同步，是線程訪問安全的，而ArrayList線程不安全
LinkedList底層是鏈表結構，查找元素慢、增刪元素速度快，線程不安全。
二、請說說HashSet原理，并寫程序證明
HashSet在存元素時，會調用對象的hashCode方法計算出存儲位置，然后和該位置上所有的元素進行equals比較，
如果該位置沒有其他元素或者比較的結果都為false就存進去，否則就不存。
這樣的原理注定了元素是按照哈希值來找存儲位置，所有無序，而且可以保證無重復元素
我們在往HashSet集合存儲元素時，對象應該正確重寫Object類的hashCode和equals方法
正因為這樣的原理，HashSet集合是非常高效的。
比如，要查找集合中是否包含某個對象，首先計算對象的hashCode，折算出位置號，到該位置上去找就可以了，而不用和所有的元素都比較一遍
三、Collection和Collections的區別
兩者沒有任何關系
Collection是單列集合的父接口，JDK1.5中定義了Iterable接口作為Collection父類，為了實現增強for循環
Collections是工具類，提供了關于集合的常用操作，例如，排序、二分法查找、反轉元素等
1 Collections 的應用:
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工具類:提供關于集合的常用操作.
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是一個接口 父類型的應用可以指向子類型的對象..
31 for(String s : al)
32 System.out.println(s+" ");*/
33 Collections.sort(al, new StringComparator());
34 /*
35 * 第一種方法 : 通過比較器來對比排序 可以在構造方法里面.
36 * 或者在對象里面實現這個比較器.當new 這個實現接口.它會自動調用比較器的方法進行比較
37 */
38 System.out.println("通過StringComparator()方法已經排序好-----");
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 //實現一個二分查找
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.必須要通過比較器比較才能實現二分查找:
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 //在通過二分查找之前我們要經過排序'
119 System.out.println("還沒有排序之前");
120 for(String s : al)
121 System.out.print(s+" ");
122
123
124 //第二部 : 當你調用二分查找之后.會調用比較器進行比較.是經過排序后的才可以進行二分查找
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 日期的應用:
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();//獲取當前的日歷
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+"天數");
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 設置日歷字段 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); //獲取到二月份的天數
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 的字段數字，指示一個星期中的某天。)
188 if(c.get(Calendar.DAY_OF_WEEK)==1||c.get(Calendar.DAY_OF_WEEK)==7)
189 i--;
190 //(get 和 set 的字段數字，指示一個月中的某天。)
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 、小細 閱讀(324) |
評論 (0) |
編輯 收藏
集合類：
為什么使用集合類?
在面向對象的編程思想中，都是以對象的形式對事物進行描述的,為了保證對象的生命周期，我們需要持有對象
（什么叫做持有對象呢?Person p = new Person()）
數組和集合類的區別?
1.數組和集合類都是容器，都能存儲對象
2.集合類優點就是長度可變,而數組一旦定義.長度是不能修改的.
集合的特點：
集合類可用于存儲對象.
集合類的長度可變
一個集合可以存儲多種類型的對象..
Collection 接口：
1.一個獨立的元素的序列，這些元素從一條或多條規則
2.collection接口下分為list集合和Set集合
3.list集合的特點是元素有序，可以允許有重復的元素
4.set集合的特點是元素無序，不允許有重復的元素
↓↓
List（子接口）
↓↓
ArrayList(實現類)
1.底層數組實現，查找快，增刪慢
2.線程不安全
----------------------------------
Vector（實現類）
1.與ArrayList基本一樣
2.線程安全
----------------------------------
LinkedList(實現類)
1.底層是鏈表的實現
2.增刪快，查找慢
{
List集合元素存取方法一致
使用add()方法增加元素
由于List集合有序，可以使用get()方法獲取元素
元素的迭代(Iterator)
通過集合對象的iterator()方法獲得迭代器Iterator
通過Iterator迭代器的hasNext()方法判斷是否存在下一個元素
通過Iterator迭代器的next()方法獲取下一個元素
元素的迭代(Enumeration)
迭代Vector集合中的元素可以使用Enumeration
通過Enumeration的hasNextElements()方法判斷是否還有元素
通過Enumeration的nextElement()方法返回下一個元素
}
↓↓
Set（子接口）
↓↓
Set集合無須，不允許有重復的元素
1.set集合通過存入對象的equals方法來保證集合中沒有重復的元素
HashSet（實現類）
HashSet是set的子類，因而沒有重復元素
底層使用了哈希算法保證沒有重復元素
存儲對象時，先調用對象的HashSet（）方法，找到存儲位置，再和當前的存儲位置上已經存在的元素通過equals()方法進行比較，如果返回false，才能進行存儲
往HashSet集合里存儲的對象必須是重寫HahCode 和equals()方法。
TreeSet（實現類）
TreeSet集合通過二叉樹算法保證無重復元素，并對元素進行排序
第一種方式: 如果對象實現了Comparable接口，就可以存入TreeSet集合 因為它會自動的去調用里面的一個比較方法.所以在Person里面重寫
第二種方式: 如果對象沒有實現Comparable接口，在創建TreeSet對象時，需要給構造函數扔進一個比較器，實現Comparator接口 .(必須要在匿名內部類重寫.或者繼承一個類來重寫)
----------------------------------
Map接口：
1.一組成對的“鍵值對”對象，允許根據鍵來查找值
2.Map集合的健值不允許有重復的，所以Map所有的鍵都構成了一個Set集合
Iterable接口：
1.JDK1.5新定義的接口作為Collection的父接口
2.主要就是實現了增強for循環
jdk1.5的新特征：
泛型:
由于集合可以存儲不同數據類型的對象，所以取元素(地址)時會導致類型轉換錯誤
jdk1.5新增加了泛型，為了減少操作集合的出錯里
例如： ArrayList<Person> arraylist = new ArrayList<Person>();
比喻： 我在每一個掛了一個牌子.只能是Person 使用.做了一個限制..
使用泛型的好處：
1.提高的代碼的安全性
2.講運行期間的問題轉到了編譯期間的問題（你懂的~~）
3.省起了類型轉換的麻煩
4.泛型類的出現優化了程序設計
增強for循環：
新接口Iterable中定義了增強for循環
可以通過增強for循環對數組和集合進行遍歷
在迭代集合元素時，需要定義了泛型才能使用for循環
可變參數：
有的時候在設計方法時無法確定將來別人會傳入的參數個數
JDK1.5增加了新特性可變參數，在函數中只聲明參數類型，不規定個數
方法接受的參數實際上是一個數組，可以在方法中遍歷數組
可變參數只能被定義為函數的最后一個形參
語法格式： 返回值 函數名(參數類型… 形參)
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"); //有什么區別?
* 2.String s = new String("abc"); 創建了幾個對象 2個(池里沒有)或1個(池里有了)，
* 3.String s = "a" + "b" + "c" + "d"; 創建了幾個對象？ 創建了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" 如果沒有的.那么把對象創建的引用返回給s1
* 當s2開始執行.會檢查緩沖池里面有沒有.如果有的.直接把對象的地址返回給s2 .所以是相等的.。
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2);
*/
/*
String s1 = "abc";
String s2 = new String(s1);
outcome ： false
s2在堆內存中創建了一個對象(把地址返回來~),并且在堆內存里面的緩沖池里面創建一個"abc"(這個是對象里面的一個拷貝副本)
做java的日常維護.所以那么這兩個地址一比較.就會不相等..
*/
/*
String s1 = "a"+"b"+"c";
String s2 ="abc";
outCome = "true";
因為java編譯器有個合并已知量的功能,在編譯階段"a"+"b"+"c" 合并為"abc"并且保存在緩沖池里面
所以s2在檢測緩沖池里面.檢測到已經有了.直接把對象的引用所返回來.那么證明了s1 s2 是同一個地址/所以比較出來為true
*/
/*
String s1 = new String("abc");
String s2 = new String("abc");
這兩個里面創建了多少個對象呢?
解答： 首先會在堆內存中創建一個對象.在檢測池里面有沒有,沒有也在了緩沖池里面創建了一個.做日常的維護
s2也會在堆內存中創建一個對象.這時候檢測到池里面已經有了.所以就不再創建/
說百了也就是3個..
一般面試簡單的就直接說：2個就可以.
*/
/*
* String 是一個常量,是不能改變的量
* 內部實現：
* StringBuilder sb = new StringBuilder(s1);
* sb.append(s2);
* s3 = sb.toString(); //轉換回字符串
* 返回調用方法的都是創建一個對象的
*
*/
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 序列，并將結果存儲到一個新的 byte 數組中。
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方法.那么直接復用父類的方法.打印出的是對象.
這顯然不是String想要得到的結果
*/
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);
/*
* 把有逗號的內容去掉。
*/
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 /* 查找子字符串在字符串中出現的位置 例：“ab”在"habjklabljhlabhjdjfla"出現的位置為：1 6 12
9 * 思路：
10 * 1.定義一個StringBuilder容器，用于存儲位置，定義一個pos變量記住出現的位置，初始值為0
11 * 2.定義一個while循環，查找子串出現的位置
12 * 3.調用indexOf方法，從起始位置開始查找出子串首次出現的位置
13 * 4.如果pos為-1，說明沒找到，應該結束循環
14 * 5.將位置存入StringBuilder容器，再加一個逗號分隔
15 * 6.從找到的位置加上子串的長度作為新的起始位置，
16 * 7.循環結束，將StringBuffer轉為String字符串，調用split方法以逗號進行分隔，獲得了String數組
17 * 8.準備一個新的int數組，長度和String數組一樣，遍歷String數組，將每個元素轉為int存入int數組
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假設找ab 找到1 + 2 等于三.剛好從第三個開始找~
30 }
31 if(sb.length() == 0) //容器什么都沒有！
32 return null; //一個都找不到
33 String s = sb.toString(); //轉換成字符串形式
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 * 設計一個方法，讀取鍵盤輸入的一行（只支持英文字母）
45 * 提示：System.in.read()讀取鍵盤上的一個字符
46 * 思路：
47 * 1.定義一個容器StringBuilder容器
48 * 2.定義一個while循環,循環讀取鍵盤.
49 * 3.如果讀到回車或者\n 就跳出循環
50 * 4.存入StringBuilfer容器中
51 * 5.循環結束,返回一個toString轉換為字符串
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') //等上面的執行完畢.再來
62 break;
63 sb.append((char)ch);
64 }
65 return sb.toString(); //轉換成字符串
66 }
67
68 /*
69 * *將給定的字節數組截取一部分，進行解碼，要求輸出完整的漢字，例如："abc中國人"截取6個 輸出的是abc中
70 * 思路：
71 * 1.遍歷數組被截取的部分,
72 * 2.判斷正負數，統計負數個數為count
73 * 3.判斷count的奇偶，奇數減去1，偶數不變
74 * 4.解碼
75 * 漢字是占了2個字節?我們怎么判斷它是漢字呢?
76 * 漢字的第一位字節保證是負數!第二個是正數
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++; //如果第一個字節是負數的.是代表漢字馬上來到.咱們+1
85 if(count % 2 == 1)
86 len--;
87 return new String(buf,0,len);
88 /*程序流程圖： 咱們輸入一個buf len = 5
89 * for 執行5次
90 * 因為一個漢字是占了2個字節.而第一個字節保證是負數
91 * 如果 buf[i]里面的是負數的 count +1 = 1
92 * 如果 % 2 等于1代表的是： 咱們len 傳遞進來的就減去一個字節.
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 * 查找一個字符串出現次數最多的字符 abvjdabahabballfja 出現次數最多的為:a 6
113 * 思路：
114 * 1.調用toCharArray字符串把字符串轉換成字符數組
115 * 2.定義max，用于記住出現最多字符的次數，定義一個maxChar記住出現最多的字符
116 * 3.定義一個循環，每次循環都統計一個字符出現最多的次數，每次讓次數和max比.誰最大就換,結束條件。當長度的數組
117 * 為零
118 * 4.定義一個count，記住本次統計字符的次數
119 * 5.循環遍歷數組，統計第一個字符出現的次數
120 * 6.讓次數和max比，如果max大，讓max記住它的次數，讓maxchar記住當前的字符
121 * 7.將當前的字符從數組中刪除
122 * ------
123 * 將此字符串轉換為一個新的字符數組。
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; //個數等于0
134 char firstChar = buf[0];
135 for(char c : buf)
136 if(c ==firstChar)
137 count++;
138 if(count>max) //max 已經是默認記住上一個的值！
139 {
140 max = count;
141 maxChar = firstChar; //如果你是最多的就讓給你~~
142 }
143 //把當前的字符刪除！
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.循環遍歷較短的字符串的所有子串，由長到短遍歷
164 * 定義一個循環，每次遍歷一種長度的子串，將i作為長度，i的取值: length~1
165 * 定義一個內層循環，具體遍歷某一種長度的子串，j做為子串的開始位置， j取值：0~length-i
166 * 截取子串，substring 起始位置:j 結束位置:j+i
167 * 3.每次變量，都判斷子串是否為較長的字符串的子串，如果是，直接返回
168 * 4.循環結束，依然沒有返回，說明沒有相同子串，返回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 //當且僅當此字符串包含指定的 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 出現的位置
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的時候就結束,不斷的去讀
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("程序結束");
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 、小細 閱讀(246) |
評論 (0) |
編輯 收藏