1.List：有序的 collection（也称为序列）。此接口可以对列表中每个元素的插入位置进行精确地控制。可以根据元素的在列表中的位置访问元素，并搜索列表中的元素。列表允许重复的元素。
ArrayList:
特点：有序的、线性的、无固定大小的、有下标的、先进先出
简单操作应用：
public static void main(String args[]) {
Java代码
// 创建一个队列对象
java.util.ArrayList<String> list = new java.util.ArrayList<String>();
// 装入10个数据
for (int i = 0; i < 10; i++) {
String s = "元素" + i;
//加元素
list.add(s);
}
// 遍历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> iter = list.iterator();
//判断是否有数据可以迭代
while(iter.hasNext()){
//取出一个元素
String str = iter.next();
System.out.print(str+"\t");
}
System.out.println();
//遍历3
for(String str:list){
System.out.print(str+"\t");
}
2.Set:是简单的集合，它的对象不按特定方式排序，只是简单的把对象加入集合中。不能有重复对象。
HashSet:
特点：无序的，长度可变的，不可重复的
简单的操作应用：
public static void main(String args[]) {
Java代码
// 创建一个容器对象
java.util.HashSet<String> sets = new java.util.HashSet<String>();
// 装入10个元素
for (int i = 0; i < 10; i++) {
String s = "元素a" + i;
sets.add(s);
}
//检验若输入加入重复的元素，在集合中的是原来的还是新加入的（结果表明是原来的）
boolean b = sets.add("新来的");
boolean b1 = sets.add("新来的");
System.out.println(b + "<>" + b1);
// 遍历1
// 得到迭代器对象
java.util.Iterator<String> iter = sets.iterator();
while (iter.hasNext()) {
String str = iter.next();
System.out.print(str + "\t");
}
System.out.println();
//遍历2
for(String str:sets){
System.out.print(str+"\t");
}
3.Map:Map中存入的对象是一对一对的，即每个对象和它的一个名字（键：key）关联在一起，一个键（key）只能对应一个值（value）,反则不然。
HashMap:
特点：无序的、不可重复的
简单的操作应用：
public static void main(String args[]) {
Java代码
// 创建一个映射对象
java.util.HashMap<Integer, String> maps = new java.util.HashMap<Integer, String>();
// 装入键值对
for (int i = 0; i < 20; i++) {
int num = i * 1000;
String name = "学生" + i;
// 装入一个键值对
maps.put(num, name);
}
//增加一个键值对，加入K相同的键值对，则会替换已经存在的键值对
maps.put(30000, "新学生");
maps.put(40000, "新学生");
maps.put(40000, "又来一个");
//遍历
//得到K的Set集合
java.util.Set<Integer> set = maps.keySet();
//遍历K的集合，得到set的迭代器
java.util.Iterator<Integer> iter = set.iterator();
while(iter.hasNext()){
//取出一个key
int num = iter.next();
//根据key得到对应的Value
String name = maps.get(num);
System.out.println(num+"\t"+name);
}
两个应用：
1.package hpw.collection;
Java代码
/**
* 任意的一个数组，重复排序
*
* @author
*
*/
public class Task1 {
public static void main(String args[]) {
// 创建一个数组
int[] array = new int[] { 133, 345, 467, 45, 786, 133, 456, 89, 45,
299, 786, 467, 123, 456 };
int[] temp = RemoveRepeat(array);
// 出去重复后，打印数组
for (int i = 0; i < temp.length; i++) {
System.out.print(temp[i] + "\t");
}
System.out.println();
int[] newarray = sort(temp);
// 排序后，打印数组
for (int i = 0; i < newarray.length; i++) {
System.out.print(newarray[i] + "\t");
}
}
/**
* 去除数组中重复的元素
*
* @param base
* ：要去除的数组
* @return：去除重复后的数组
*/
public static int[] RemoveRepeat(int[] base) {
// 创建一个集合
java.util.HashSet<Integer> sets = new java.util.HashSet<Integer>();
// 遍历数组，将元素装入集合
for (int i = 0; i < base.length; i++) {
int temp = base[i];
// 将元素装入集合
sets.add(temp);
}
//创建一个新的数组
int[] newarry=new int[sets.size()];
// 得到迭代器
java.util.Iterator<Integer> ite = sets.iterator();
// 遍历集合，将元素装入队列
for (int i = 0; ite.hasNext(); i++) {
newarry[i] = ite.next();
}
return newarry;
}
/**
* 将数组排序
*
* @param base
* ：原数组
* @return:排序后的数组
*/
//冒泡排序
public static int[] sort(int[] base){
for(int i=0;i<base.length;i++){
for(int j=i+1;j<base.length;j++){
if(base[i]>base[j]){
int temp=base[i];
base[i]=base[j];
base[j]=temp;
}
}
}
return base;
}
}
2.package hpw.collection;
Java代码
import java.util.HashMap;
/**
* 统计重复
* @author lenovo
*
*/
public class Task2 {
public static void main(String args[]){
// 创建一个数组
int[] array = new int[] { 133, 345, 467, 45, 786, 133, 456, 89, 45,
299, 786, 467, 123, 456,45 };
//创建一个映射
java.util.HashMap<Integer, Integer> map=new java.util.HashMap<Integer, Integer>();
//统计
map=count(array);
//打印
print(map);
}
/**
* 统计出现的次数
* @param base：原数组
* @return：java.util.HashMap<Integer：数组元素, Integer：出现的次数>
*/
public static java.util.HashMap<Integer, Integer> count(int[] base){
//创建一个映射
java.util.HashMap<Integer, Integer> maps=new java.util.HashMap<Integer, Integer>();
//遍历数组，出现重复，value+1
for(int i=0;i<base.length;i++){
//判断是否出现重复
if(maps.containsKey(base[i])){
int value=maps.get(base[i])+1;
maps.put(base[i], value);
}else{
maps.put(base[i], 1);
}
}
return maps;
}
/**
* 打印队列
* @param map
*/
public static void print(HashMap<Integer, Integer> map){
//创建一个集合，得到K的元素
java.util.Set<Integer> set=map.keySet();
//遍历集合，获得迭代器
java.util.Iterator<Integer> ite=set.iterator();
while(ite.hasNext()){
//去除key
int key=ite.next();
//得到相应的value
int value=map.get(key);
System.out.println(key+"\t"+value);
}
}
}