Ⅰ java中的Set,List,Map的區別
對JAVA的集合的理解是想對於數組
數組是大小固定的 並且同一個數組只能存放類型一樣的數據(基本類型/引用類型)
JAVA集合可以存儲和操作數目不固定的一組數據
所有的JAVA集合都位於 java util包中!
JAVA集合只能存放引用類型的的數據 不能存放基本數據類型
JAVA集合主要分為三種類型
Set(集)
List(列表)
Map(映射)
Collection 介面
Collection是最基本的集合介面 聲明了適用於JAVA集合(只包括Set和List)的通用方法
Set 和List 都繼承了Conllection Map沒有
Collection介面的方法
boolean add(Object o) :向集合中加入一個對象的引用
void clear() :刪除集合中所有的對象 即不再持有這些對象的引用
boolean isEmpty() :判斷集合是否為空
boolean contains(Object o): 判斷集合中是否持有特定對象的引用
Iterartor iterator() : 返回一個Iterator對象 可以用來遍歷集合中的元素
boolean remove(Object o):從集合中刪除一個對象的引用
int size() :返回集合中元素的數目
Object[] toArray() :返回一個數組 該數組中包括集合中的所有元素
關於 Iterator() 和toArray() 方法都用於集合的所有的元素 前者返回一個Iterator對象 後者返回一個
包含集合中所有元素的數組
Iterator介面聲明了如下方法
hasNext(): 判斷集合中元素是否遍歷完畢 如果沒有 就返回true
next() :返回下一個元素
remove():從集合中刪除上一個有next()方法返回的元素
Set(集合)
Set是最簡單的一種集合 集合中的對象不按特定的方式排序 並且沒有重復對象
Set介面主要實現了兩個實現類
HashSet : HashSet類按照哈希演算法來存取集合中的對象 存取速度比較快
TreeSet : TreeSet類實現了SortedSet介面 能夠對集合中的對象進行排序
Set 的用法
存放的是對象的引用 沒有重復對象
Set set=new HashSet();
String s =new String( hello );
String s =s ;
String s =new String( world );
set add(s );
set add(s );
set add(s );
System out println(set size());//列印集合中對象的數目 為
Set 的 add()方法是如何判斷對象是否已經存放在集合中?
boolean isExists=false;
Iterator iterator=erator();
while(it hasNext()) {
String oldStr=it next();
if(newStr equals(oldStr)){
isExists=true;
}
}
List(列表)
List的特徵是其元素以線性方式存儲 集合中可以存放重復對象
List介面主要實現類包括
ArrayList() : 代表長度可以改變得數組 可以對元素進行隨機的訪問 向ArrayList()中插入與
與刪除元素的速度慢
LinkedList(): 在實現中採用鏈表數據結構 插入和刪除速度快 訪問速度慢
對於List的隨機訪問來說 就是只隨機來檢索位於特定位置的元素
List 的 get(int index) 方法放回集合中由參數index指定的索引位置的對象 下標從 開始
最基本的兩種檢索集合中的所有對象的方法
: 用for循環和get()方法
for(int i= ; i<list size();i++){
System out println(list get(i));
}
: 使用 迭代器(Iterator):
Iterator it=erator();
while(it hashNext){
System out println(it next);
}
Map(映射):
Map 是一種把鍵對象和值對象映射的集合 它的每一個元素都包含一對鍵對象和值對象
Map沒有繼承於Collection介面
從Map集合中檢索元素時 只要給出鍵對象 就會返回對應的值對象
Map 的常用方法
添加 刪除操作
Object put(Object key Object value): 向集合中加入元素
Object remove(Object key): 刪除與KEY相關的元素
void putAll(Map t): 將來自特定映像的所有元素添加給該映像
void clear(): 從映像中刪除所有映射
查詢操作
Object get(Object key): 獲得與關鍵字key相關的值
Map集合中的鍵對象不允許重復 也就說 任意兩個鍵對象通過equals()方法比較的結果都是false
但是可以將任意多個鍵獨享映射到同一個值對象上
Conllections : 集合實用類
Conllections提供了供JAVA集合實用的靜態方法
總結
JAVA集合的基本用法 都歸納了 上面這些是平常最常用的JAVA集合 具體的其他的 還要參考JDK幫助文檔了 呵呵 關於 Map的應用 還有很多 具體就是這個 Conllections提供了很多 List /Map 實用的方法 對平常開發非常有用
對次會會不斷修改!
boolean containsKey(Object key): 判斷映像中是否存在關鍵字key
boolean containsValue(Object value): 判斷映像中是否存在值value
int size(): 返回當前映像中映射的數量
boolean isEmpty() 判斷映像中是否有任何映射
List按對象進入的順序保存對象 不做排序或編輯操作 Set對每個對象只接受一次 並使用自己內部的排序方法(通常 你只關心某個元素是否屬於Set 而不關心它的順序 否則應該使用List) Map同樣對每個元素保存一份 但這是基於 鍵 的 Map也有內置的排序 因而不關心元素添加的順序 如果添加元素的順序對你很重要 應該使用 LinkedHashSet或者LinkedHashMap
List的功能方法
實際上有兩種List: 一種是基本的ArrayList 其優點在於隨機訪問元素 另一種是更強大的LinkedList 它並不是為快速隨機訪問設計的 而是具有一套更通用的方法
List : 次序是List最重要的特點 它保證維護元素特定的順序 List為Collection添加了許多方法 使得能夠向List中間插入與移除元素(這只推薦LinkedList使用 )一個List可以生成ListIterator 使用它可以從兩個方向遍歷List 也可以從List中間插入和移除元素
ArrayList : 由數組實現的List 允許對元素進行快速隨機訪問 但是向List中間插入與移除元素的速度很慢 ListIterator只應該用來由後向前遍歷ArrayList 而不是用來插入和移除元素 因為那比LinkedList開銷要大很多
LinkedList : 對順序訪問進行了優化 向List中間插入與刪除的開銷並不大 隨機訪問則相對較慢 (使用ArrayList代替 )還具有下列方法 addFirst() addLast() getFirst() getLast() removeFirst() 和 removeLast() 這些方法 (沒有在任何介面或基類中定義過)使得LinkedList可以當作堆棧 隊列和雙向隊列使用
Set的功能方法
Set具有與Collection完全一樣的介面 因此沒有任何額外的功能 不像前面有兩個不同的List 實際上Set就是Collection 只是行為不同 (這是繼承與多態思想的典型應用 表現不同的行為 )Set不保存重復的元素(至於如何判斷元素相同則較為負責)
Set : 存入Set的每個元素都必須是唯一的 因為Set不保存重復元素 加入Set的元素必須定義equals()方法以確保對象的唯一性 Set與Collection有完全一樣的介面 Set介面不保證維護元素的次序
HashSet : 為快速查找設計的Set 存入HashSet的對象必須定義hashCode()
TreeSet : 保存次序的Set 底層為樹結構 使用它可以從Set中提取有序的序列
LinkedHashSet : 具有HashSet的查詢速度 且內部使用鏈表維護元素的順序(插入的次序) 於是在使用迭代器遍歷Set時 結果會按元素插入的次序顯示
Map的功能方法
方法put(Object key Object value)添加一個 值 (想要得東西)和與 值 相關聯的 鍵 (key)(使用它來查找) 方法get(Object key)返回與給定 鍵 相關聯的 值 可以用containsKey()和containsValue()測試Map中是否包含某個 鍵 或 值 標準的Java類庫中包含了幾種不同的Map HashMap TreeMap LinkedHashMap WeakHashMap IdentityHashMap 它們都有同樣的基本介面Map 但是行為 效率 排序策略 保存對象的生命周期和判定 鍵 等價的策略等各不相同
執行效率是Map的一個大問題 看看get()要做哪些事 就會明白為什麼在ArrayList中搜索 鍵 是相當慢的 而這正是HashMap提高速度的地方 HashMap使用了特殊的值 稱為 散列碼 (hash code) 來取代對鍵的緩慢搜索 散列碼 是 相對唯一 用以代表對象的int值 它是通過將該對象的某些信息進行轉換而生成的 所有Java對象都能產生散列碼 因為hashCode()是定義在基類Object中的方法
HashMap就是使用對象的hashCode()進行快速查詢的 此方法能夠顯著提高性能
Map : 維護 鍵值對 的關聯性 使你可以通過 鍵 查找 值
HashMap : Map基於散列表的實現 插入和查詢 鍵值對 的開銷是固定的 可以通過構造器設置容量capacity和負載因子load factor 以調整容器的性能
LinkedHashMap : 類似於HashMap 但是迭代遍歷它時 取得 鍵值對 的順序是其插入次序 或者是最近最少使用(LRU)的次序 只比HashMap慢一點 而在迭代訪問時發而更快 因為它使用鏈表維護內部次序
TreeMap : 基於紅黑樹數據結構的實現 查看 鍵 或 鍵值對 時 它們會被排序(次序由Comparabel或Comparator決定) TreeMap的特點在於 你得到的結果是經過排序的 TreeMap是唯一的帶有subMap()方法的Map 它可以返回一個子樹
WeakHashMao : 弱鍵(weak key)Map Map中使用的對象也被允許釋放: 這是為解決特殊問題設計的 如果沒有map之外的引用指向某個 鍵 則此 鍵 可以被垃圾收集器回收
lishixin/Article/program/Java/ky/201311/27866
Ⅱ 怎樣從java集合類set中取出數據
創建set的iterator方法:
Set<Object> set = new HashSet<Object>();
Iterator<Object> it = set.iterator();
while(it.hasNext())//判斷是否有下一個
it.next()取出元素。
以上方法便是從Set集合中取出數據。
(2)java里的set擴展閱讀:
Java中使用Set介面描述一個集合(集合不允許有「重復值」,注意重復的概念),集合Set是Collection的子介面,Set不允許其數據元素重復出現,也就是說在Set中每一個數據元素都是唯一的。Set介面定義的常用方法如下:
1、size() 獲取Set尺寸(即Set包含數據元素的總數)。
2、 add(Object obj) 向Set中添加數據元素obj。
3、remove(Object obj) 從Set中移除數據元素obj。
4 、contains(Object obj) 判斷當前Set中是否包含數據元素obj,如果包含返回true,否則返回false。
5、iterator() 將Set裝入迭代器。
Ⅲ java中「get」和「set」方法怎麼寫
java bean就是把自己的數據成員封裝起來, 讓外界不能直接操作數據成員; 而只能通過bean提供的get 和 set方法進行操作,保證了數據安全性。可以理解為:get就是把對象中的值拿出來, set就是把某個值放到對象中去。
比如:
public class LoginInfoBean {
private String time; //時間
private String ip; //IP
private String account; // 賬號
public String getTime() {
return time;
}
public void setTime(String time) {
this.time = time;
}
public String getIp() {
return ip;
}
public void setIp(String ip) {
this.ip = ip;
}
public String getAccount() {
return account;
}
public void setAccount(String account) {
this.account = account;
}
}
---------------------------------------------------------------
關於如何在servlet中取得數據:
首先要明白,我們提交到servlet的數據,需要走servlet的doGet或者doPost方法。
如果你不用框架,只用純粹的servlet,在servlet的doGet和doPost方法中因為只有兩個參數,也就是HttpRequest和HttpResponse,比如:
doPost(HttpServletRequest req,
HttpServletResponse resp){
........
}
按照以上的寫法,只能通過req.getParamter("xxx")取得;
比如下面這個例子:
file: login.jsp
<form id="loginform" name="loginform" method="post" action="LoginServlet" >
<input name="userName" type="text" id="userName" />
ps: 通過 action="LoginServlet" 可以知道,提交的路徑為LoginServlet, 然後會到web.xml中尋找關於LoginServlet 的具體配置,以確定是哪個servlet處理這個請求。
file: web.xml
<servlet>
<servlet-name>LoginServlet</servlet-name>
<servlet-class>com.test.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>LoginServlet</servlet-name>
<url-pattern>/LoginServlet</url-pattern>
</servlet-mapping>
ps: 通過以上配置可以確定,處理這個請求的servlet為com.test.LoginServlet
file: com.test.LoginServlet.java
public void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
String name = request.getParameter("userName");
}
ps: 通過 request.getParameter("userName"); 就可以取得頁面上輸入的值。
如果用框架,每個框架的機制不一樣,需要分別對待, 但底層也都是servlet。我接觸過的struts1, struts2, 和spring MVC, 其中 struts1 給我們提供了一個formbean, 用於收集頁面的數據(就是上面那個javabean的問題); struts2和spring MVC 省去了formbean, 後台處理的action就是一個bean, 數據在action中直接可以取到。
推薦一個簡單的方法:寫get/set方法,OC有一個自動化的方法,即使用@proterty和@synthesize關鍵字
Person.h
Ⅳ java中的get 和set 是什麼意思
get成員方法和set成員方法分別用於讀取和設置私有變數的值
一般建議將有特殊限制的成員域的訪問控制方式設置為私有模式。這時,可以添加兩個成員方法分別讀取和設置這個具有特殊限制的成員域的值。在這兩個成員方法中,由於讀取該成員域的值的成員方法的名稱通常含有字元序列「get」,因此該成員方法通常簡稱為「get」成員方法;而設置該成員域的值的成員方法的名稱通常含有字元序列「set」,因此該成員方法通常簡稱為「set」成員方法。
這樣可以加強程序的封裝性和安全性,外部程序不能直接訪問私有變數,只能通過get成員方法和set成員方法讀取和設置私有變數的值。
如:
Ⅳ java set 順序
在java語言中,提供多種不同的結構來組織對象,Set(集合)是其中的一種,本身是一個介面,其迭代時的順序取決於其具體實現。典型的實現包括:
HashSet:哈希表是通過使用稱為散列法的機制來存儲信息的,元素並沒有以某種特定順序來存放;
LinkedHashSet:以元素插入的順序來維護集合的鏈接表,允許以插入的順序在集合中迭代;
TreeSet:提供一個使用樹結構存儲Set介面的實現,對象以升序順序存儲,訪問和遍歷的時間很快。
(5)java里的set擴展閱讀
Set<String> set = new TreeSet<String>();
set.add("f");
set.add("a");
set.add("b");
set.add("c");
set.add("d");
set.add("e");
System.out.println(set);
Ⅵ java中怎麼往集合類set里添加數據
java中往集合添加數據調用add();方法就行
//第一步先創建一個set集合的子類
HashSet has=new HashSet<>();
//給set集合添加的方法是add();
has.add(args);
Collection介面可以存放重復元素,也可以存放不重復元素。List可以存放重復元素,Set就是不重復的元素。
通過元素的equals方法,來判斷是否為重復元素。
Set集合取出元素的方式可以採用:迭代器,增強 for
Ⅶ Java中set什麼意思
setLayout 設置此容器的布局管理器,也就是給界面布局
Jdk 就是這樣定義的,這個沒有什麼喜歡不喜歡,而且用set具有易讀性
Ⅷ java中 List 與Set 有什麼區別
Java的集合類都位於java.util包中,Java集合中存放的是對象的引用,而非對象本身。
Java集合主要分為三種類型:
a.Set(集):集合中的對象不按特定方式排序,並且沒有重復對象。它的有些實現類能對集合中的對象按特定方式排序。
b.List(列表):集合中的對象按索引位置排序,可以有重復對象,允許按照對象在集合中的索引位置檢索對象。
c.Map(映射):集合中的每一個元素包含一對鍵對象和值對象,集合中沒有重復的鍵對象,值對象可以重復。它的有些實現類能對集合中的鍵對象進行排序。
Set、List和Map統稱為Java集合。
1.Set(集)
Set集合中的對象不按特定方式排序,並且沒有重復對象。Set介面主要有兩個實現類HashSet和TreeSet。HashSet類按照哈希演算法來存取集合中的對象,存取速度比較快。HashSet類還有一個子類LinkedHashSet類,它不僅實現了哈希演算法,而且實現了鏈表數據結構。TreeSet類實現了SortedSet介面,具有排序功能。
Set的add()方法判斷對象是否已經存在於集合中的判斷流程:
boolean isExists = false;
Iterator it = set.iterator();
while(it.hasNext()){
Object object = it.next();
if(newObject.equals(oldObject)){
isExists = true;
break;
}
}
2.HashSet類
當HashSet向集合中加入一個對象時,會調用對象的hashCode()方法獲得哈希碼,然後根據這個哈希碼進一步計算出對象在集合中的存放位置。
當Object1變數和object2變數實際上引用了同一個對象,那麼object1和object2的哈希碼肯定相同。
為了保證HashSet能正常工作,要求當兩個對象用equals()方法比較的結果為相等時,它們的哈希碼也相等。即:
customer1.hashCode() == customer2.hashCode();
如:對應於Customer類的以下重寫後的equals()方法:
public boolean equals(Object o){
if(this==o) return true;
if(!o instanceof Customer) return false;
final Customer other = (Customer)o;
if(this.name.equals(other.getName())&&this.age==other.getAge())
return true;
else
return false;
}
為了保證HashSet正常工作,如果Customer類覆蓋了equals()方法,也應該覆蓋hashCode()方法,並且保證兩個相等的Customer對象的哈希碼也一樣。
public int hashCode(){
int result;
result = (name==null?0:name.hashCode());
result = 29*result+(age==null?0:age.hashCode());
return result;
}
3.TreeSet類
TreeSet類實現了SortedSet介面,能夠對集合中的對象進行排序。TreeSet支持兩種排序方式:自然排序和客戶化排序,在默認情況下TreeSet採用自然排序方式。
a.自然排序
在JDK中,有一部分類實現了Comparable介面,如Integer、Double和String等。Comparable介面有一個compareTo(Object o)方法,它返回整數類型。對於表達式x.compareTo(y),如果返回值為0,表示x和y相等,如果返回值大於0,表示x大於y,如果返回值小於0,表示x小於y。
TreeSet調用對象的compareTo()方法比較集合中對象的大小,然後進行升序排列,這種排序方式稱為自然排序。
以下列出了JDK中實現了Comparable介面的一些類的排序方式
類 排序
BigDecimal\BigInteger\Byte\Double\Float\Integer\Long\Short 按數字大小排序
Character 按字元的Unicode值的數字大小排序
String 按字元串中字元的Unicode值排序
使用自然排序時,只能向TreeSet集合中加入同類型的對象,並且這些對象的類必須實現了Comparable介面,否則會在第二次調用TreeSet的add()方法時,會拋出ClassCastException異常。
例如:
以下是Customer類的compareTo()方法的一種實現方式:
public int compareTo(Object o){
Customer other = (Customer)o;
//先按照name屬性排序
if(this.name.compareTo(other.getName())>0) return 1;
if(this.name.compareTo(other.getName())<0) return -1;
//再按照age屬性排序
if(this.age>other.getAge()) return 1;
if(this.age<other.getAge()) return -1;
return 0;
}
為了保證TreeSet能正確地排序,要求Customer類的compareTo()方法與equals()方法按相同的規則比較兩個Customer對象是否相等。
因此在Customer類的equals()方法中應該採用相同的比較規則:
public boolean equals(Object o){
if(this==o) return true;
if(!(o instanceof Customer)) return false;
final Customer other = (Customer)o;
if(this.name.equals(other.getName())&&this.age==other.getAge()){
return true;
}else{
return false;
}
}
值得注意的是,對於TreeSet中已經存在的Customer對象,如果修改了它們的屬性,TreeSet不會對集合進行重新排序。在實際域模型中,實體類的屬性可以被更新,因此不適合通過TreeSet來排序。最適合於排序的是不可變類。
b.客戶化排序
除了自然排序,TreeSet還支持客戶化排序。java.util.Comparator介面用於指定具體的排序方式,它有個compare(Object object1,Object object2)方法,用於比較兩個對象的大小。當表達式compare(x,y)的值大於0,表示x大於y;當compare(x,y)的值小於0,表示x小於y;當compare(x,y)的值等於0,表示x等於y。
例如:如果希望TreeSet僅按照Customer對象的name屬性進行降序排列,可以創建一個實現Comparator介面的類CustomerComparator:
public class CustomerComparator implements Comparator{
public int compare(Object o1,Object o2){
Customer c1= (Customer)o1;
Customer c2 = (Customer)o2;
if(c1.getName().compareTo(c2.getName())>0) return -1;
if(c2.getName().compareTo(c2.getName())<0) return 1;
return 0;
}
}
接下來在構造TreeSet的實例時,調用它的TreeSet(Comparator comparator)構造方法:
Set set = new TreeSet(new CustomerComparator());
4.向Set中加入持久化類的對象
例如兩個Session實例從資料庫載入相同的Order對象,然後往HashSet集合里存放,在默認情況下,Order類的equals()方法比較兩個Orer對象的內存地址是否相同,因此order1.equals(order2)==false,所以order1和order2游離對象都加入到HashSet集合中,但實際上order1和order2對應的是ORDERS表中的同一條記錄。對於這一問題,有兩種解決方案:
(1)在應用程序中,謹慎地把來自於不同Session緩存的游離對象加入到Set集合中,如:
Set orders = new HashSet();
orders.add(order1);
if(!order2.getOrderNumber().equals(order1.getOrderNumber()))
order.add(order2);
(2)在Order類中重新實現equals()和hashCode()方法,按照業務主鍵比較兩個Order對象是否相等。
提示:為了保證HashSet正常工作,要求當一個對象加入到HashSet集合中後,它的哈希碼不會發生變化。
5.List(列表)
List的主要特徵是其對象以線性方式存儲,集合中允許存放重復對象。List介面主要的實現類有LinkedList和ArrayList。LinkedList採用鏈表數據結構,而ArrayList代表大小可變的數組。List介面還有一個實現類Vector,它的功能和ArrayList比較相似,兩者的區別在於Vector類的實現採用了同步機制,而ArrayList沒有使用同步機制。
List只能對集合中的對象按索引位置排序,如果希望對List中的對象按其他特定方式排序,可以藉助Comparator和Collections類。Collections類是集合API中的輔助類,它提供了操縱集合的各種靜態方法,其中sort()方法用於對List中的對象進行排序:
a.sort(List list):對List中的對象進行自然排序。
b.sort(List list,Comparator comparator):對List中的對象進行客戶化排序,comparator參數指定排序方式。
如Collections.sort(list);
6.Map(映射)
Map(映射)是一種把鍵對象和值對象進行映射的集合,它的每一個元素都包含一對鍵對象和值對象,而值對象仍可以是Map類型,依次類推,這樣就形成了多級映射。
Map有兩種比較常用的實現:HashMap和TreeMap。HashMap按照哈希演算法來存取鍵對象,有很好的存取性能,為了保證HashMap能正常工作,和HashSet一樣,要求當兩個鍵對象通過equals()方法比較為true時,這兩個對象的hashCode()方法返回的哈希碼也一樣。
TreeMap實現了SortedMap介面,能對鍵對象進行排序。和TreeSet一樣,TreeMap也支持自然排序和客戶化排序兩種方式。
例:創建一個緩存類EntityCache,它能粗略地模仿Session的緩存功能,保證緩存中不會出現兩個OID相同的Customer對象或兩個OID相同的Order對象,這種惟一性是由鍵對象的惟一性來保證的。
Key.java:
package mypack;
public class Key{
private Class classType;
private Long id;
public Key(Class classType,Long id){
this.classType = classType;
this.id = id;
}
public Class getClassType(){
return this.classType;
}
public Long getId(){
return this.id;
}
public boolean equals(Object o){
if(this==o) return true;
if(!(o instanceof Key)) return false;
final Key other = (Key)o;
if(classType.equals(other.getClassType())&&id.equals(other.getId()))
return true;
return false;
}
public int hashCode(){
int result;
result = classType.hashCode();
result = 29 * result + id.hashCode();
return result;
}
}
EntityCache.java:
package mypack;
import java.util.*;
public class EntityCache {
private Map entitiesByKey;
public EntityCache() {
entitiesByKey=new HashMap();
}
public void put(BusinessObject entity){
Key key=new Key(entity.getClass(),entity.getId());
entitiesByKey.put(key,entity);
}
public Object get(Class classType,Long id){
Key key=new Key(classType,id);
return entitiesByKey.get(key);
}
public Collection getAllEntities(){
return entitiesByKey.values();
}
public boolean contains(Class classType,Long id){
Key key=new Key(classType,id);
return entitiesByKey.containsKey(key);
}
}