集合類編程

① 什麼是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等方法使集合線程安全。