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的操作。