集合类编程

① 什么是C#中的集合类

集合类是指实现集合功能的类。集合与数组很相似，都能存储多个数据，但集合的优点是：能够动态地扩大或收缩大小。在下面的情况下，使用集合比数组更容易：
1.如果你要添加一个元素，必须新建一个数组，再将元素复制进来。
2.如果你要删除指定索引的元素，也要新建一个数组，再把没有删除的元素复制进来。
3.如果你要删除指定值的元素，不仅要新建一个数组，还得循环判断要删除哪一个。
4.如果要从中间插入一个元素，不仅要新建数组，而且判断也很麻烦。
5.如果要判断里面是否有一个元素，需要通过循环语句遍历数组。
通过集合，上面的问题都能轻松解决。
1.使用集合的Add方法，可以自动在集合末尾加入一个元素。
2.使用集合的RemoveAt方法，可以自动从集合删除指定索引的元素。
3.使用集合的Remove方法，可以自动从集合中找到指定值的元素并移除。
4.使用集合的Insert方法，可以自动从指定索引处插入一个元素。
5.使用集合的Contains方法，可以判断是否拥有一个元素。
最普通的集合类是List，它能完成上面的所有任务。例如数组：
int[] intArray = new int[4];
intArray[0] = 10;
intArray[1] = 3;
intArray[2] = 16;
intArray[3] = 7;
可以转换为集合：
List<int> intList = new List<int>(); //注意，List后面的<>中间是一个类型，表示集合的元素类型
intList.Add(10);
intList.Add(3);
intList.Add(16);
intList.Add(7);
使用集合类很简单，只有声明要注意一下。如果要初始化一个集合，写法与数组相似：
List<string> names = new List<string>{ "Me", "Computer", "Math" };
此外，还有一些集合类，它们不使用List集合类是因为它们有别的功能。不同的集合类有不同的用处，也可以试一试：Dictionary、System.Collections.ObjectModel.ReadOnlyCollection。

② java中集合类是什么意思

java.util中共有13个类可用于管理集合对象，它们支持集、列表或映射等集合，以下是这些类的简单介绍
集：
HashSet： 使用HashMap的一个集的实现。虽然集定义成无序，但必须存在某种方法能相当高效地找到一个对象。使用一个HashMap对象实现集的存储和检索操作是在固定时间内实现的.
TreeSet： 在集中以升序对对象排序的集的实现。这意味着从一个TreeSet对象获得第一个迭代器将按升序提供对象。TreeSet类使用了一个TreeMap.
列表：
Vector： 实现一个类似数组一样的表，自动增加容量来容纳你所需的元素。使用下标存储和检索对象就象在一个标准的数组中一样。你也可以用一个迭代器从一个Vector中检索对象。Vector是唯一的同步容器类??当两个或多个线程同时访问时也是性能良好的。
Stsck: 这个类从Vector派生而来，并且增加了方法实现栈??一种后进先出的存储结构。
LinkedList: 实现一个链表。由这个类定义的链表也可以像栈或队列一样被使用。
ArrayList: 实现一个数组，它的规模可变并且能像链表一样被访问。它提供的功能类似Vector类但不同步。
映射：
HashTable： 实现一个映象，所有的键必须非空。为了能高效的工作，定义键的类必须实现hashcode()方法和equal()方法。这个类是前面java实现的一个继承，并且通常能在实现映象的其他类中更好的使用。
HashMap： 实现一个映象，允许存储空对象，而且允许键是空（由于键必须是唯一的，当然只能有一个）。
WeakHashMap： 实现这样一个映象：通常如果一个键对一个对象而言不再被引用，键/对象对将被舍弃。这与HashMap形成对照，映象中的键维持键/对象对的生命周期，尽管使用映象的程序不再有对键的引用，并且因此不能检索对象。
TreeMap： 实现这样一个映象，对象是按键升序排列的。
Set 和List都是由公共接口Collection扩展而来，所以它们都可以使用一个类型为Collection的变量来引用。这就意味着任何列表或集构成的 集合都可以用这种方式引用，只有映射类除外（但也不是完全排除在外，因为可以从映射获得一个列表。）所以说，把一个列表或集传递给方法的标准途径是使用 Collection类型的参数。

③ c语言编程，集合

动态规划.

#include<stdio.h>
/*#include<stdlib.h>*/
#include<memory.h>

#defineN5050

intmain(intargc,char*argv)
{
intd[N];
intn,s;
while(scanf("%d",&n)!=EOF){
s=n*(n+1)>>1;
if(s&1){
printf("0
");
}
else{
s=s>>1;
inti,j;
memset(d,0,N*sizeof(d[0]));
d[0]=1;
for(i=1;i<=n;i++){
for(j=s;j>=i;j--){
d[j]=d[j]+d[j-i];
}
}
printf("%d
",d[s]>>1);
}
}
return0;
}

④ 用C++编程集合运算及实现

详细c代码：

#include <stdio.h>
#include <conio.h>
#define MAX_SET_NUM 5
#define YES 1
#define NO 0
typedef struct data_set
{
int arr_A[MAX_SET_NUM];
int arr_B[MAX_SET_NUM];
int Intersection[MAX_SET_NUM];
int Union[MAX_SET_NUM * 2];
}DataSet;
void GetInterSection(DataSet * ds, int *InterSecSetNum)
{
int i,j,k = 0;
for (i = 0; i < MAX_SET_NUM; i++)
{
for (j = 0; j < MAX_SET_NUM; j++)
{
if (ds->arr_A[i] == ds->arr_B[j])
{
ds->Intersection[k] = ds->arr_A[i];
k++;
}
}
}
*InterSecSetNum = k;
}
int IsCurSetHaveX(int *set, int SetNum, int X)
{
int i;
if (SetNum > 0)
{
for (i = 0; i < SetNum; i++)
{
if ( *(set+i) == X )
return YES;
}
}
else
return NO;
return NO;
}
void GetUnion(DataSet * ds, int *UnionSetNum)
{
int i,j,k = 0;
for (i = 0; i < MAX_SET_NUM; i++)
{
if (IsCurSetHaveX(ds->Union, k, ds->arr_A[i]) == NO)
{
ds->Union[k] = ds->arr_A[i];
k++;
}
}
for (j = 0; j < MAX_SET_NUM; j++)
{
if (IsCurSetHaveX(ds->Union, k, ds->arr_B[j]) == NO)
{
ds->Union[k] = ds->arr_B[j];
k++;
}
}
*UnionSetNum = k;
}
void BubbleSort(int *set, int SetNum)
{
int i,j;
int tmp;
for (i = SetNum-1; i >= 0; i--)
{
for (j = 0; j < i; j++)
{
if ( *(set+j) > *(set+j+1) )
{
tmp = *(set+j);
*(set+j) = *(set+j+1);
*(set+j+1) = tmp;
}
}
}
}
int main(void)
{
int i,j;
DataSet ds;
int UnionSetNum = 0, InterSecSetNum = 0;
printf("input set A: \n");
for (i = 0; i < MAX_SET_NUM; i++)
{
scanf("%d", &ds.arr_A[i]);
}
printf("input set B: \n");
for (j = 0; j < MAX_SET_NUM; j++)
{
scanf("%d", &ds.arr_B[j]);
}
GetInterSection(&ds, &InterSecSetNum);
BubbleSort(ds.Intersection, InterSecSetNum);
GetUnion(&ds, &UnionSetNum);
BubbleSort(ds.Union, UnionSetNum);
printf("-----------------------------\n");
printf("Intersection: \n");
for (i = 0; i < InterSecSetNum; i++)
{
printf("%d ", ds.Intersection[i]);
}
printf("\nUnion: \n");
for (j = 0; j < UnionSetNum; j++)
{
printf("%d ", ds.Union[j]);
}
getch();
return 0;
}

⑤ Java集合类框架的最佳实践有哪些

1、根据应用的需要正确选择要使用的集合的类型对性能非常重要，比如：假如元素的大小是固定的，而且能事先知道，就应该用Array而不是ArrayList。
2、有些集合类允许指定初始容量。因此，如果能估计出存储的元素的数目，可以设置初始容量来避免重新计算hash值或者是扩容。
为了类型安全，可读性和健壮性的原因总是要使用泛型。同时，使用泛型还可以避免运行时的ClassCastException。
3、使用JDK提供的不变类(immutableclass)作为Map的键可以避免为自己的类实现hashCode()和equals()方法。
4、编程的时候接口优于实现。
5、底层的集合实际上是空的情况下，返回长度是0的集合或者是数组，不要返回null。

⑥ Java编程：你所知道的集合类都有哪些主要方法

最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按数值索引访问元素的情形。
Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。
Set接口也是集合。

⑦ Java编程实现创建一个集合类对象

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;

public class Demo_02 {
public static <V> void main(String[] args) {

/*
1.
数组:数组的长度固定。

集合 :长度可变。
*
*/
/*
*
* 2. 几种集合的介绍（接口）
*
* 2.1、List（有序、可重复）
* 2.2、Set（无序、不能重复）
* 2.3、Map（键值对、键唯一、值不唯一）
*
*/
//创建一个list集合 ArrayList<String>是这个list集合的实现类
List<String> list=new ArrayList<String>();
list.add("1");
list.add("2");
list.add("4");
list.add("3");
//判断集合是否为空
boolean empty = list.isEmpty();

System.out.println(empty);
System.out.println(list);
//移除集合索引上的值
list.remove(0);
System.out.println(list);

list.add("1");
/* 遍历

四种的常见输出方式：

1.Iterator：迭代输出，是使用最多的输出方式。

2.ListIterator：是Iterator的子接口，专门用于输出List中的内容。

3.foreach输出：JDK1.5之后提供的新功能，可以输出数组或集合。

4.for循环
*/
System.out.println("for遍历：");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));

}
System.out.println("foreach遍历:");
for (String s : list) {
System.out.println(s);

}
System.out.println("iterator的形式：");
Iterator it = list.iterator();
while(it.hasNext())
{
Object a = it.next();
System.out.println(a);

}
//ListIterator是Iterator的子接口，专门用于输出List中的内容。
System.out.println("ListIterator:");
ListIterator<String> it2 = list.listIterator();
while(it2.hasNext())
{
Object a = it2.next();
System.out.println(a);

}

//创建一个Map集合
Map map=new HashMap<String,String>();
map.put("1", "a1");
map.put("2", "a2");
map.put("4", "a4");
map.put("3", "a3");
System.out.println(map);
//创建一个Set
Set set=new HashSet<String>();
set.add("1");
set.add("2");
set.add("4");
set.add("3");
System.out.println(set);

}

}

⑧ Java并发编程常用的类和集合

AtomicInteger

可以用原子方式更新int值。类AtomicBoolean、AtomicInteger、AtomicLong和AtomicReference的实例各自提供对相应类型单个变量的访问和更新。java课程培训机构http://www.kmbdqn.cn/认为基本的原理都是使用CAS操作：

booleancompareAndSet(expectedValue,updateValue);

如果此方法（在不同的类间参数类型也不同）当前保持expectedValue，则以原子方式将变量设置为updateValue，并在成功时报告true。

循环CAS，参考AtomicInteger中的实现：

publicfinalintgetAndIncrement(){for(;;){intcurrent=get();intnext=current+1;if(compareAndSet(current,next))returncurrent;

}

}(intexpect,intupdate){returnunsafe.compareAndSwapInt(this,valueOffset,expect,update);

}

ABA问题

因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A－B－A就会变成1A-2B－3A。

从Java1.5开始JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

ArrayBlockingQueue

一个由数组支持的有界阻塞队列。此队列按FIFO（先进先出）原则对元素进行排序。队列的头部是在队列中存在时间最长的元素。队列的尾部是在队列中存在时间最短的元素。新元素插入到队列的尾部，队列获取操作则是从队列头部开始获得元素。这是一个典型的“有界缓存区”，固定大小的数组在其中保持生产者插入的元素和使用者提取的元素。一旦创建了这样的缓存区，就不能再增加其容量。试图向已满队列中放入元素会导致操作受阻塞；试图从空队列中提取元素将导致类似阻塞。

此类支持对等待的生产者线程和使用者线程进行排序的可选公平策略。默认情况下，不保证是这种排序。然而，通过将公平性(fairness)设置为true而构造的队列允许按照FIFO顺序访问线程。公平性通常会降低吞吐量，但也减少了可变性和避免了“不平衡性”。

LinkedBlockingQueue

一个基于已链接节点的、范围任意的blockingqueue。此队列按FIFO（先进先出）排序元素。队列的头部是在队列中时间最长的元素。队列的尾部是在队列中时间最短的元素。新元素插入到队列的尾部，并且队列获取操作会获得位于队列头部的元素。链接队列的吞吐量通常要高于基于数组的队列，但是在大多数并发应用程序中，其可预知的性能要低。

可选的容量范围构造方法参数作为防止队列过度扩展的一种方法。如果未指定容量，则它等于Integer.MAX_VALUE。除非插入节点会使队列超出容量，否则每次插入后会动态地创建链接节点。

如果构造一个LinkedBlockingQueue对象，而没有指定其容量大小，LinkedBlockingQueue会默认一个类似无限大小的容量（Integer.MAX_VALUE），这样的话，如果生产者的速度一旦大于消费者的速度，也许还没有等到队列满阻塞产生，系统内存就有可能已被消耗殆尽了。

⑨ 多线程环境下如何正确使用Java集合类

一般不要多个线程同时处理一个集合，如果非要这么做的话。

1. 使用synchronized。对处理集合的代码部分使用synchronized。

2. 使用线程安全的集合类，Vector、HashTable、ConcurrentLinkedQueue、ConcurrentHashMap、CopyOnWriteArrayList、 CopyOnWriteArraySet 等。

3. 也可以调用Collections.synchronizedMap、Collections.synchronizedList、Collections.synchronizedSet等方法使集合线程安全。