JAVA常用集合框架

Java中集合类定义主要是在java.util.*包下面，常用的集合在系统中定义了三大接口，这三类的区别是：
java.util.Set接口及其子类，set提供的是一个无序集；
java.util.List接口及其子类，List提供的是一个有序集；
java.util.Map接口及其子类,Map提供了一个映射关系的集合数据结构；
每种集合都可以理解为用来在内存中存放一组对象的某种“容器”。
java.util.List接口的实现类的特点和用法：
List接口提供了多个实现的子类，常用的实现类是java.util.Vector和java.util.ArrayList,现在以java.util.ArrayList为例来说明List的特点及用法，具体代码示例如下：
public class ArrayListTest {
//主函数
public static void main(String args[]){
//创建队列对象
java.util.ArrayList<String> list = new java.util.ArrayList<String>();
//向队列中添加元素
for (int i=0;i<10;i++){
String str = "学生"+i;
list.add(str);
}
//遍历1
for (int i=0;i<list.size();i++){
//根据下标取出队列的元素
String str = list.get(i);
System.out.print(str+"\t");
}
System.out.println();
//遍历2
//得到队列的迭代器对象
java.util.Iterator<String> itr = list.iterator();
//判断是否有数据可以迭代
while(itr.hasNext()){
//取出一个元素
String str = itr.next();
System.out.print(str+"\t");
}
System.out.println();
//遍历3
for (String str:list){
System.out.print(str+"\t");
}
}
}
运行结果：
学生0 学生1 学生2 学生3 学生4 学生5 学生6 学生7 学生8 学生9
学生0 学生1 学生2 学生3 学生4 学生5 学生6 学生7 学生8 学生9
学生0 学生1 学生2 学生3 学生4 学生5 学生6 学生7 学生8 学生9
以上程序是先创建一个队列对象list，然后以有序的元素添加到该队列中，接下来是通过三种不同的方式遍历该队列的，第一种是通过下标值来遍历队列的，打印出来的队列也是有序的，但是仅凭这一种方式不能说明队列是有序的，所以再通过第二种遍历方式，打印出该队列，第二种遍历是先得到队列的迭代器对象，在判断是否有数据可以迭代，最后取出队列的元素。通过第二种遍历方式就可以说明队列是有序的，这两种遍历方式也都说明了队列是线性的。第三种遍历方式是在java中特有的遍历方式。
下面再把上面的代码做稍微的修改，如下所示：
public class ArrayListTest {
//主函数
public static void main(String args[]){
//创建队列对象
java.util.ArrayList<String> list = new java.util.ArrayList<String>();
//向队列中添加元素
for (int i=0;i<15;i++){
String str = "学生"+i;
list.add(str);
}
list.add("新同学");
list.add("新同学");
list.add("新来的");
//遍历1
for (int i=0;i<list.size();i++){
//根据下标取出队列的元素
String str = list.get(i);
System.out.print(str+"\t");
}
System.out.println();
//遍历2
//得到队列的迭代器对象
java.util.Iterator<String> itr = list.iterator();
//判断是否有数据可以迭代
while(itr.hasNext()){
//取出一个元素
String str = itr.next();
System.out.print(str+"\t");
}
System.out.println();

//遍历3
for (String str:list){
System.out.print(str+"\t");
}

}

}
运行结果：
学生0 学生1 学生2 学生3 学生4 学生5 学生6 学生7 学生8 学生9 学生10 学生11 学生12 学生13 学生14 新同学 新同学 新来的
学生0 学生1 学生2 学生3 学生4 学生5 学生6 学生7 学生8 学生9 学生10 学生11 学生12 学生13 学生14 新同学 新同学 新来的
学生0 学生1 学生2 学生3 学生4 学生5 学生6 学生7 学生8 学生9 学生10 学生11 学生12 学生13 学生14 新同学 新同学 新来的
以上程序添加是在队列中添加了新的元素，并且有添加相同的元素，从运行结果可知，队列是长度可变的，可以有相同重复的元素。
根据以上两段代码的运行结果可知，队列的特点是线性的，有序的，长度可变的，有下标值的，元素可重复的。
Java.util.Set接口的实现类的特点及用法：
Set是一个接口定义，所以只能使用它的实现子类，Set接口常用的子类有java.util.HashSet、java.util.TreeSet;这里以java.util.HashSet为例说明它的特点及用法，请看下面代码示例：
public class HashSetTest {

//主函数
public static void main(String args[]){

//创建集合对象
java.util.HashSet<String> set = new java.util.HashSet<String>();

//向集合中添加元素
for (int i=0;i<10;i++){
String str = "学生"+i;
set.add(str);
}
//遍历1
//得到迭代器的对象
java.util.Iterator<String> iter = set.iterator();
while(iter.hasNext()){
String str = iter.next();
System.out.print(str+"\t");
}
System.out.println();
//遍历2
for (String str:set){
System.out.print(str+"\t");
}
}

}
运行结果：
学生0 学生9 学生7 学生8 学生5 学生6 学生3 学生4 学生1 学生2
学生0 学生9 学生7 学生8 学生5 学生6 学生3 学生4 学生1 学生2
以上程序是将有序的元素放入的集合中，通过第一种遍历方式打印出来的元素是无序的，说明集合的特点是无序的。下面再在上面的代码的基础上添加新的元素，代码如下：
public class HashSetTest {

//主函数
public static void main(String args[]){

//创建集合对象
java.util.HashSet<String> set = new java.util.HashSet<String>();

//向集合中添加元素
for (int i=0;i<10;i++){
String str = "学生"+i;
set.add(str);
}
set.add("新来的");
set.add("新同学");
//遍历1
//得到迭代器的对象
java.util.Iterator<String> iter = set.iterator();
while(iter.hasNext()){
String str = iter.next();
System.out.print(str+"\t");
}
System.out.println();

//遍历2
for (String str:set){
System.out.print(str+"\t");
}
}

}

运行结果：
学生0 新同学 学生9 学生7 学生8 新来的 学生5 学生6 学生3 学生4 学生1 学生2
学生0 新同学 学生9 学生7 学生8 新来的 学生5 学生6 学生3 学生4 学生1 学生2
从运行结果中可知集合和队列一样，长度也是可以变的。
下面在修改以上代码，向集合中添加相同的元素，如下所示：
public class HashSetTest {

//主函数
public static void main(String args[]){

//创建集合对象
java.util.HashSet<String> set = new java.util.HashSet<String>();

//向集合中添加元素
for (int i=0;i<10;i++){
String str = "学生"+i;
set.add(str);
}
set.add("新来的");
set.add("新同学");
set.add("新同学");
//遍历1
//得到迭代器的对象
java.util.Iterator<String> iter = set.iterator();
while(iter.hasNext()){
String str = iter.next();
System.out.print(str+"\t");
}
System.out.println();

//遍历2
for (String str:set){
System.out.print(str+"\t");
}
}

}
运行结果：
学生0 新同学 学生9 学生7 学生8 新来的 学生5 学生6 学生3 学生4 学生1 学生2
学生0 新同学 学生9 学生7 学生8 新来的 学生5 学生6 学生3 学生4 学生1 学生2
运行结果是和上面一样的，说明重复的元素只能够添加一个，到底添加了哪一个呢？可以通过打印来看添加的是哪一个，代码如下：
public class HashSetTest {

//主函数
public static void main(String args[]){

//创建集合对象
java.util.HashSet<String> set = new java.util.HashSet<String>();

//向集合中添加元素
for (int i=0;i<10;i++){
String str = "学生"+i;
set.add(str);
}
set.add("新来的");
boolean st1 = set.add("新同学");
boolean st2 = set.add("新同学");
System.out.println(st1+"<>"+st2);
//遍历1
//得到迭代器的对象
java.util.Iterator<String> iter = set.iterator();
while(iter.hasNext()){
String str = iter.next();
System.out.print(str+"\t");
}
System.out.println();

//遍历2
for (String str:set){
System.out.print(str+"\t");
}
}

}
运行结果：
true<>false
学生0 新同学 学生9 学生7 学生8 新来的 学生5 学生6 学生3 学生4 学生1 学生2
学生0 新同学 学生9 学生7 学生8 新来的 学生5 学生6 学生3 学生4 学生1 学生2
从运行结果来看，添加的是第一个相同的元素。从以上的代码运行的结果中可知道，集合的特点是长度可变的，无序的，元素是不重复的。

Java.util.Map接口的特点及用法：
Java提供了专门的集合类用来存放映射对象的，即Java.util.Map接口，Map是一个接口，有多种具体的实现类，常用的有HashMap和Hashtable类实现。Map中存入的对象是一对一对的，即每个对象和它的一个键关联在一起。从API文档中可知，Map中存放的是两种对象，一种称为key（键），一种称为value（值），他们在Map中是一一对应关系。Map中的键是不能重复的，但值是可以重复的。下面以java.util.HashMap为例说明它的特点及用法，请看下面的示例代码：
public class HashMapTest {

//主函数
public static void main(String args[]){

//创建一个映射对象
java.util.HashMap<Integer,String> map = new java.util.HashMap<Integer,String>();

//装入键值对
for (int i=0;i<10;i++){
int key = i*1000;
String value = "学生"+i;
map.put(key, value);
}

//遍历
//得到K的set集合
java.util.Set<Integer> set = map.keySet();
//遍历K的集合，得到K的迭代器对象
java.util.Iterator<Integer> iter = set.iterator();
while(iter.hasNext()){
int num = iter.next();
String str = map.get(num);
System.out.println(num+"\t"+str);
}

}
}
运行结果：
0 学生0
1000 学生1
2000 学生2
3000 学生3
4000 学生4
5000 学生5
6000 学生6
7000 学生7
8000 学生8
9000 学生9
上面的程序是向映射中添加入有序的元素，打印出的也是有序的元素，从运行的结果看，认为映射是有序的，但是稍微改一下程序，元素顺序结果就不一样了，代码如下：
public class HashMapTest {

//主函数
public static void main(String args[]){

//创建一个映射对象
java.util.HashMap<Integer,String> map = new java.util.HashMap<Integer,String>();

//装入键值对
for (int i=0;i<15;i++){
int key = i*1000;
String value = "学生"+i;
map.put(key, value);
}

//遍历
//得到K的set集合
java.util.Set<Integer> set = map.keySet();
//遍历K的集合，得到K的迭代器对象
java.util.Iterator<Integer> iter = set.iterator();
while(iter.hasNext()){
int num = iter.next();
String str = map.get(num);
System.out.println(num+"\t"+str);
}

}
}
运行结果：
0 学生0
11000 学生11
13000 学生13
2000 学生2
4000 学生4
6000 学生6
8000 学生8
10000 学生10
1000 学生1
12000 学生12
3000 学生3
14000 学生14
5000 学生5
7000 学生7
9000 学生9
从上面的运行结果可知，映射也是种无序的集合。
像上面的集合一样向映射中添加重复相同的元素，代码如下：
public class HashMapTest {

//主函数
public static void main(String args[]){

//创建一个映射对象
java.util.HashMap<Integer,String> map = new java.util.HashMap<Integer,String>();

//装入键值对
for (int i=0;i<10;i++){
int key = i*1000;
String value = "学生"+i;
map.put(key, value);
}
map.put(1234,"新同学");
map.put(1234,"新来的");
map.put(4321,"新来的");
map.put(4321,"新同学");


//遍历
//得到K的set集合
java.util.Set<Integer> set = map.keySet();
//遍历K的集合，得到K的迭代器对象
java.util.Iterator<Integer> iter = set.iterator();
while(iter.hasNext()){
int num = iter.next();
String str = map.get(num);
System.out.println(num+"\t"+str);
}

}
}
运行结果：
0 学生0
1000 学生1
2000 学生2
3000 学生3
4000 学生4
1234 新来的
5000 学生5
6000 学生6
7000 学生7
8000 学生8
9000 学生9
4321 新同学
从运行结果来看，映射的元素也是不可重复的如果加入相同的键值对时，则会替换掉原来的键值对。总结来说，映射的特点是：一个K对应一个V，K是一个set集合，是不可重复的，无序的，如果加入相同K的键值对时，则会替换原来的键值对。
以上三种集合框架的应用是很广的，比如对一个整型数组进行去重复排序，就可以用Set对数组去重复，然后在用其他排序方法对去重复的数组进行排序。要统计一个数组中的相同元素的个数，就可以用Map对数组进行操作，返回数组元素及其出现的次数。具体代码如下：
public class Test {

public static void main(String args[]){
//初始化一个数组
int[] array = {2,3,5,3,7,4,9,3,2,1,8,6,3,8,7,3,2,1,9,};

//创建Test类对象
Test ft = new Test();
int[] ar = ft.reSet(array);

for (int i=0;i<ar.length;i++){
System.out.print(ar[i]+"\t");
}

java.util.HashMap<Integer,Integer> map = ft.reput(array);
ft.print(map);

}

/*
* 去掉数组中重复的元素并排序的方法
*/
public int[] reSet(int[] arr) {

// 创建HashSet的对象
java.util.HashSet<Integer> set = new java.util.HashSet<Integer>();

// 遍历数组，将数组中的元素加到HashSet中
for (int i = 0; i < arr.length; i++) {
// 将数组的元素添加到集合中
set.add(arr[i]);

}

// 再将集合中的元素保存回数组中
// 实例化一个数组
int[] temps = new int[set.size()];

// 得到迭代器对象
java.util.Iterator<Integer> ter = set.iterator();
int k=0;
while (ter.hasNext()) {
temps[k] = ter.next();
k++;
}

// 冒泡排序
for (int i = 0; i < temps.length; i++) {
for (int j = i + 1; j < temps.length; j++) {
if (temps[i] > temps[j]) {
int temp = temps[i];
temps[i] = temps[j];
temps[j] = temp;
}

}
}

return temps;

}

/*
* 返回数组中相同元素的个数的方法
*/
public java.util.HashMap<Integer,Integer> reput(int[] arr){

//创建映射对象
java.util.HashMap<Integer,Integer> map = new java.util.HashMap<Integer,Integer>();

int[] key = reSet(arr);

//实例化一个数组
int[] value = new int[key.length];

for (int i=0;i<key.length;i++){
for (int j=0;j<arr.length;j++){
if (key[i]==arr[j]){
value[i]++;
}
}
}

for (int i=0;i<key.length;i++){
map.put(key[i], value[i]);
}

return map;
}

//打印映射的方法
public void print(java.util.HashMap<Integer,Integer> map){
//遍历
//得到K的set集合
java.util.Set<Integer> set = map.keySet();
//遍历K的集合，得到K的迭代器对象
java.util.Iterator<Integer> iter = set.iterator();
while(iter.hasNext()){
int num = iter.next();
int str = map.get(num);
System.out.println(num+"\t"+str);

}


}
}
运行结果：
1 2 3 4 5 6 7 8
9
1 2
2 3
3 5
4 1
5 1
6 1
7 2
8 2
9 2