java集合框架--List、Set、Map

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);

}

}

}