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

 

1.List：有序的 collection（也称为序列）。此接口可以对列表中每个元素的插入位置进行精确地控制。可以根据元素的在列表中的位置访问元素，并搜索列表中的元素。列表允许重复的元素。

   ArrayList: 

   特点：有序的、线性的、无固定大小的、有下标的、先进先出

   简单操作应用：

public static void main(String args[]) {

// 创建一个队列对象
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+"	");
}

System.out.println();

//遍历2
//得到队列的迭代器对象
java.util.Iterator<String> iter = list.iterator();
//判断是否有数据可以迭代
while(iter.hasNext()){
    //取出一个元素
    String str = iter.next();
    System.out.print(str+"	");

}

System.out.println();

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

   

 

2.Set:是简单的集合，它的对象不按特定方式排序，只是简单的把对象加入集合中。不能有重复对象。

 

   HashSet:

 

   特点：无序的，长度可变的，不可重复的

 

   简单的操作应用：

public static void main(String args[]) {

// 创建一个容器对象
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 + "	");
}

System.out.println();

//遍历2
for(String str:sets){

    System.out.print(str+"	");
}

 

 

3.Map:Map中存入的对象是一对一对的，即每个对象和它的一个名字（键：key）关联在一起，一个键（key）只能对应一个值（value）,反则不然。

 

   HashMap:

 

   特点：无序的、不可重复的

 

   简单的操作应用：

public static void main(String args[]) {

// 创建一个映射对象
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+"	"+name);
}

 

 

 

两个应用：

1.package hpw.collection;

/**
 * 任意的一个数组，重复排序
 *
 * @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] + "	");
        }

        System.out.println();

        int[] newarray = sort(temp);
        // 排序后，打印数组
        for (int i = 0; i < newarray.length; i++) {
            System.out.print(newarray[i] + "	");
        }

    }

    /**
     * 去除数组中重复的元素
     *
     * @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;

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+"	"+value);
        }


    }
}