mhashseth
❶ 給定兩個集合A和B,判定A是否是B集合的子集，用C語言怎麼寫
代碼如下：程序思路：
（1）輸入A的元素個數，並輸入各個元素；
（2）輸入B的元素個數，並輸入各個元素；
（3）看A重元素是否全部在B中，在就輸出「A是B子集」；否則輸出「A不是B子集」
#include <stdio.h>
int main()
{
int a[20] = { 0 }, b[30] = { 0 }, n, m, i, j,cnt = 0;
//輸入集合a的元素個數（小於20）
scanf_s("%d", &n);
//輸入集合a的元素
for (i = 0; i < n; i++)
scanf_s("%d", &a[i]);
//輸入集合b的元素個數（小於30）
scanf_s("%d", &m);
//輸入集合b的元素
for (j = 0; j < m; j++)
scanf_s("%d", &b[j]);
for (i = 0; i < n; i++)
{
cnt=0;
for (j = 0; j < m; j++)
if (a[i] == b[j])
cnt++;
if (cnt == 0)
{
printf("A不是B的子集");
return 0;
}
}
printf("A是B的子集");
return 0;
}
結果：
❷ Java中HashMap，HashSet是線程安全的嗎，ArrayList是線程不安全的那如何避免其出異常
HashMap，HashSet,ArrayList都不具備線程安全。
可以用
Sets=Collections.synchronizedSet(newHashset<...>());
Mapm=Collections.synchronizedMap(newHashMap<...>());
Listl=Collections.synchronizedList(newArrayList<...>());
獲得被同步後的版本。
也可以用ConcurrentHashMap等同步工具代替
❸ 在java中集合的遍歷是怎樣遍歷的
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
方法一：
for(String attribute : list) {
System.out.println(attribute);
}
方法二：
for(int i = 0 ; i < list.size() ; i++) {
system.out.println(list.get(i));
}
方法三：
Iterator it = list.iterator();
while(it.hasNext()) {
System.ou.println(it.next);
}
❹ java中hashset和hashmap有什麼區別
HASHSET：
此類實現 Set 介面，由哈希表（實際上是一個 HashMap 實例）支持。它不保證集合的迭代順序；特別是它不保證該順序恆久不變。此類允許使用 null 元素。
此類為基本操作提供了穩定性能，這些基本操作包括 add、remove、contains 和 size，假定哈希函數將這些元素正確地分布在桶中。對此集合進行迭代所需的時間與 HashSet 實例的大小（元素的數量）和底層 HashMap 實例（桶的數量）的「容量」的和成比例。因此，如果迭代性能很重要，則不要將初始容量設置得太高（或將載入因子設置得太低）。
注意，此實現不是同步的。 如果多個線程同時訪問一個集合，而其中至少一個線程修改了該集合，那麼它必須 保持外部同步。這通常是通過對自然封裝該集合的對象執行同步操作來完成的。如果不存在這樣的對象，則應該使用 Collections.synchronizedSet 方法來「包裝」集合。最好在創建時完成這一操作，以防止對 HashSet 實例進行意外的不同步訪問：
Set s = Collections.synchronizedSet(new HashSet(...));
此類的 iterator 方法返回的迭代器是快速失敗 的：在創建迭代器之後，如果對集合進行修改，除非通過迭代器自身的 remove 方法，否則在任何時間以任何方式對其進行修改，Iterator 都將拋出 。因此，面對並發的修改，迭代器很快就會完全失敗，而不冒將來在某個不確定時間發生任意不確定行為的風險。
注意，迭代器的快速失敗行為無法得到保證，因為一般來說，不可能對是否出現不同步並發修改做出任何硬性保證。快速失敗迭代器在盡最大努力拋出 。因此，為提高這類迭代器的正確性而編寫一個依賴於此異常的程序是錯誤做法：迭代器的快速失敗行為應該僅用於檢測程序錯誤。
HASHMAP：
基於哈希表的 Map 介面的實現。此實現提供所有可選的映射操作，並允許使用 null 值和 null 鍵。（除了不同步和允許使用 null 之外，HashMap 類與 Hashtable 大致相同。）此類不保證映射的順序，特別是它不保證該順序恆久不變。
此實現假定哈希函數將元素正確分布在各桶之間，可為基本操作（get 和 put）提供穩定的性能。迭代集合視圖所需的時間與 HashMap 實例的「容量」（桶的數量）及其大小（鍵-值映射關系數）的和成比例。所以，如果迭代性能很重要，則不要將初始容量設置得太高（或將載入因子設置得太低）。
HashMap 的實例有兩個參數影響其性能：初始容量 和載入因子。容量 是哈希表中桶的數量，初始容量只是哈希表在創建時的容量。載入因子 是哈希表在其容量自動增加之前可以達到多滿的一種尺度。當哈希表中的條目數超出了載入因子與當前容量的乘積時，通過調用 rehash 方法將容量翻倍。
通常，默認載入因子 (.75) 在時間和空間成本上尋求一種折衷。載入因子過高雖然減少了空間開銷，但同時也增加了查詢成本（在大多數 HashMap 類的操作中，包括 get 和 put 操作，都反映了這一點）。在設置初始容量時應該考慮到映射中所需的條目數及其載入因子，以便最大限度地降低 rehash 操作次數。如果初始容量大於最大條目數除以載入因子，則不會發生 rehash 操作。
如果很多映射關系要存儲在 HashMap 實例中，則相對於按需執行自動的 rehash 操作以增大表的容量來說，使用足夠大的初始容量創建它將使得映射關系能更有效地存儲。
注意，此實現不是同步的。如果多個線程同時訪問此映射，而其中至少一個線程從結構上修改了該映射，則它必須 保持外部同步。（結構上的修改是指添加或刪除一個或多個映射關系的操作；僅改變與實例已經包含的鍵關聯的值不是結構上的修改。）這一般通過對自然封裝該映射的對象進行同步操作來完成。如果不存在這樣的對象，則應該使用 Collections.synchronizedMap 方法來「包裝」該映射。最好在創建時完成這一操作，以防止對映射進行意外的不同步訪問，如下所示：
Map m = Collections.synchronizedMap(new HashMap(...));
由所有此類的「集合視圖方法」所返回的迭代器都是快速失敗 的：在迭代器創建之後，如果從結構上對映射進行修改，除非通過迭代器自身的 remove 或 add 方法，其他任何時間任何方式的修改，迭代器都將拋出 。因此，面對並發的修改，迭代器很快就會完全失敗，而不冒在將來不確定的時間任意發生不確定行為的風險。
注意，迭代器的快速失敗行為不能得到保證，一般來說，存在不同步的並發修改時，不可能作出任何堅決的保證。快速失敗迭代器盡最大努力拋出 。因此，編寫依賴於此異常程序的方式是錯誤的，正確做法是：迭代器的快速失敗行為應該僅用於檢測程序錯誤。
(以上內容全部COPY自JDK5.0 DOC)
❺ java中HashSet的哈希表和ASCII碼還有2進制之間是什麼關系
首先電腦只有0,1就是所謂的二進制；HashSet的哈希表是通過哈希演算法來的(後面一個數是前面兩個數之和)，HashSet裡面是通過哈希演算法計算出值然後形成的一條哈希單向鏈；而ASCII碼是位元組數，就像你傳輸IO流底層都是通過byte實現的,所以無論什麼都可以變成byte位元組，比如某個東西變成byte位元組這個位元組數就是ASCII碼了。
第二個問題Iterator遍例器，一個循環中只能有一個next(）方法，不然你while判斷幹嘛，如果值是單數會拋異常，然後你的sop方法傳的是Object類型的，這個就是多態了；Object obj = (A.getName（）+...+A.getAge());然後你列印Object類型的值，記住除了String類型重寫了toString方法外，別的引用類型都繼承了Object的toString方法輸出的引用地址，你的代碼直接在Person中重寫toString方法就可以了。
❻ HashSet和TreeSet的用法
==========================他們的區別===========================
1. HashSet是通過HashMap實現的,TreeSet是通過TreeMap實現的,只不過Set用的只是Map的key
2. Map的key和Set都有一個共同的特性就是集合的唯一性.TreeMap更是多了一個排序的功能.
3. hashCode和equal()是HashMap用的, 因為無需排序所以只需要關註定位和唯一性即可.
a. hashCode是用來計算hash值的,hash值是用來確定hash表索引的.
b. hash表中的一個索引處存放的是一張鏈表, 所以還要通過equal方法循環比較鏈上的每一個對象
才可以真正定位到鍵值對應的Entry.
c. put時,如果hash表中沒定位到,就在鏈表前加一個Entry,如果定位到了,則更換Entry中的value,並返回舊value
4. 由於TreeMap需要排序,所以需要一個Comparator為鍵值進行大小比較.當然也是用Comparator定位的.
a. Comparator可以在創建TreeMap時指定
b. 如果創建時沒有確定,那麼就會使用key.compareTo()方法,這就要求key必須實現Comparable介面.
c. TreeMap是使用Tree數據結構實現的,所以使用compare介面就可以完成定位了.
=====================================他們的用法======================
HashSet的使用
import java.util.HashSet;
import java.util.Iterator;
public class WpsklHashSet
{
//java 中Set的使用(不允許有重復的對象):
public static void main(String[] args)
{
HashSet hashSet=new HashSet();
String a=new String("A");
String b=new String("B");
String c=new String("B");
hashSet.add(a);
hashSet.add(b);
System.out.println(hashSet.size());
String cz=hashSet.add(c)?"此對象不存在":"已經存在";
System.out.println("測試是否可以添加對象 "+cz);
System.out.println(hashSet.isEmpty());
//測試其中是否已經包含某個對象
System.out.println(hashSet.contains("A"));
Iterator ir=hashSet.iterator();
while(ir.hasNext())
{
System.out.println(ir.next());
}
//測試某個對象是否可以刪除
System.out.println(hashSet.remove("a"));
System.out.println(hashSet.remove("A"));
//經過測試,如果你想再次使用ir變數,必須重新更新以下
ir=hashSet.iterator();
while(ir.hasNext())
{
System.out.println(ir.next());
}
}
}
/**
* 通過這個程序，還可以測試樹集的添加元素的無序性與輸出的有序性
*/
import java.util.TreeSet;
import java.util.Iterator;
public class TreeSetTest
{
public static void main(String[] args)
{
TreeSet tree = new TreeSet();
tree.add("China");
tree.add("America");
tree.add("Japan");
tree.add("Chinese");
Iterator iter = tree.iterator();
while(iter.hasNext())
{
System.out.println(iter.next());
}
}
}
以上就是他們的區別和用法，重在理解，多用，祝你成功
打字不易，如滿意，望採納。
❼ HashSet輸出到底是不是按照哈希值來輸出的
換成jdk1.8就是abc了.HashSet底層是復用的HashMap,在進行元素存放的時候有一個hash方法來計算元素的hashCode,這個方法1.8跟之前是不同的.
staticfinalinthash(Objectkey){
inth;
return(key==null)?0:(h=key.hashCode())^(h>>>16);
}
這是1.8版本的hash方法
finalinthash(Objectk){
inth=hashSeed;
if(0!=h&&kinstanceofString){
returnsun.misc.Hashing.stringHash32((String)k);
}
h^=k.hashCode();
//
//
//numberofcollisions().
h^=(h>>>20)^(h>>>12);
returnh^(h>>>7)^(h>>>4);
}
然而這是1.7版本的hash方法
兩個版本所計算出一個元素的hashCode實際上是不同的,實際上還是為了盡可能減少重碼的可能.所以你所得到的結果就是因為實際存入集合的時候計算的hash碼跟元素本身通過hashCode方法得到的hash碼不一樣導致的.
❽ HashSet set=map.entrySet();//將map類型數據轉換成集合set類型的。
HashSet集合按hash方式存儲數據，內部數據無序不可重復可為空，存取效率很高，通過對set的迭代遍歷將
（Entry）it.next()強制轉化為Entry用Map.Entry接收，完整表達是：Map.Entry m=（Entry）it.next();利用
m.getKey()和m.getValue()方法很清楚方便的得到map中鍵值對。希望對你有幫助
❾ HashMap和Hashtable及HashSet的區別
hastTable和hashMap的區別:
(1)Hashtable是基於陳舊的Dictionary類的，HashMap是Java 1.2引進的Map介面的一個實現。
(2)這個不同即是最重要的一點:Hashtable中的方法是同步的，而HashMap方法(在預設情況下)是非同步的。即是說，在多線程應用程序中，不用專門的操作就安全地可以使用Hashtable了；而對於HashMap，則需要額外的同步機制。但HashMap的同步問題可通過Collections的一個靜態方法得到解決：
Map Collections.synchronizedMap(Map m)
這個方法返回一個同步的Map，這個Map封裝了底層的HashMap的所有方法，使得底層的HashMap即使是在多線程的環境中也是安全的。
(3)只有HashMap可以讓你將空值作為一個表的條目的key或value。HashMap中只有一條記錄可以是一個空的key，但任意數量的條目可以是空的value。這就是說，如果在表中沒有發現搜索鍵，或者如果發現了搜索鍵，但它是一個空的值，那麼get()將返回null。如果有必要，用containKey()方法來區別這兩種情況。
其它的一些資料:
1.HashTable的方法是同步的，HashMap未經同步，所以在多線程場合要手動同步HashMap這個區別就像Vector和ArrayList一樣。（最主要的區別）
2.HashTable不允許null值(key和value都不可以),HashMap允許null值(key和value都可以，只容許有一個null值的key，可以有多個null值的value)。
3.HashTable有一個contains(Object value)，功能和containsValue(Object value)功能一樣。
4.HashTable使用Enumeration，HashMap使用Iterator。
以上只是表面的不同，它們的實現也有很大的不同。
5.HashTable中hash數組默認大小是11，增加的方式是 old*2+1。HashMap中hash數組的默認大小是16，而且一定是2的指數。
6.哈希值的使用不同，HashTable直接使用對象的hashCode，代碼是這樣的：
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
而HashMap重新計算hash值，而且用與代替求模：
int hash = hash(k);
int i = indexFor(hash, table.length);
static int hash(Object x) {
int h = x.hashCode();
h += ~(h << 9);
h ^= (h >>> 14);
h += (h << 4);
h ^= (h >>> 10);
return h;
}
static int indexFor(int h, int length) {
return h & (length-1);
}
以上只是一些比較突出的區別，當然他們的實現上還是有很多不同的，比如
HashMap對null的操作。