Java小专题之集合

集合

集合的定义

集合是用于存储，操作，传输和获取聚合的数据。

集合的特点

1. 集合的长度是可变的。
2. 集合存储的都是对象
3. 集合不能存储基本数据类型值。

集合的方法(增删改查)

C(create)
D(delete)
S(select)
R(read)
U(update)

public class CollectionDemo {

    public static void main(String[] args) {

        Collection coll=new ArrayList();
        //coll.add(1);//自动装箱
        //向集合中添加元素
        boolean bn=coll.add(new Integer(30));
        System.out.println(bn);
        coll.add(new Integer(10));
        coll.add(new Integer(40));
        coll.add(new Integer(100));
        coll.add(new Integer(23));

        System.out.println(coll);

        Collection c=new ArrayList();
        c.add(new Integer(12));
        //向集合中添加coll中包含的 所有元素
        c.addAll(coll);
        System.out.println(c);

        System.out.println(coll);
        //移除集合中的元素
        coll.remove(new Integer(30));
        System.out.println(coll);
        //获取集合中元素的个数
        int a=coll.size();
        System.out.println(a);
        //判断集合中是否包含指定的元素
        boolean bm=coll.contains(23);
        System.out.println(bm);
        //判断集合中是否包含元素
        boolean b=coll.isEmpty();
        System.out.println(b);

        //把集合转换为数组
        Object[] array=coll.toArray();
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

List接口

List的定义

List集合是以列表的形式存储信息

List的特点

1. 有序的，指的是添加元素和取出元素的顺序是一致的。即先进先出，后进后出。
2. 允许元素重复的。
3. 允许多个null元素。

List的方法

public class ListDemo {

    public static void main(String[] args) {
        //向上转型
        List list=new ArrayList();
        //向集合中添加元素
        list.add("一");
        list.add("二");
        list.add("三");
        list.add("四");
        list.add("五");
        list.add("一");
        list.add("二");
        list.add("一");

        System.out.println(list);
        //根据索引添加插入指定的元素
        list.add(1, "六");
        System.out.println(list);
        //根据索引移除列表中指定的元素
        Object obj=list.remove(1);
        System.out.println(obj);
        System.out.println(list);
        //移除列表中第一次出现的元素
        list.remove("一");
        System.out.println(list);
        //根据索引修改元素
        Object a=list.set(1, "七");
        System.out.println(a);
        System.out.println(list);
        //获取列表中元素的个数
        int b=list.size();
        System.out.println(b);
        //根据索引 获取元素
        Object ob=list.get(1);
        System.out.println(ob);
        //获取列表中第一次出现元素的索引 
        int c=list.indexOf("一");
        System.out.println(c);
        //获取列表中最后一次出现元素的索引
        int d=list.lastIndexOf("一");
        System.out.println(d);
        //判断列表中是否包含元素
        boolean bn=list.isEmpty();
        System.out.println(bn);
    }
}

List接口实现类: ArrayList & LinkedList

ArrayList是用数组列表的形式存储信息。是不同步的，不支持多线程技术的。

LinkedList是用链表形式存储信息。是不同步的，不支持多线程技术的。

这两个都是List的实现类。

package cn.com.oneqinglong.ArrayListDemo;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * 
 * @author oneqinglong
 *
 *ArrayList是数组列表的形式存储信息
 *
 *ArrayList是不同步的(不支持多线程技术)
 */
public class ArrayListDemo {

    public static void main(String[] args) {

        ArrayList list=new ArrayList();
        list.add(new Integer(20));
        list.add(new Integer(30));
        list.add(new Integer(40));
        list.add(new Integer(50));
        list.add(new Integer(12));
        list.add(new Integer(54));
        //第一种方式:通过迭代器
        Iterator it=list.iterator();
        while(it.hasNext()){//hashNext()判断有没有下一个元素可以迭代

            Object obj=it.next();
            System.out.println(obj);
        }

        System.out.println("***************");
        //第二种方式:使用索引获取元素 仅限于在此使用
        for(int a=0;a<list.size();a++){

            Object ob=list.get(a);
            System.out.println(ob);
        }

        System.out.println("***************");
        //第三种方式:使用增强for循环    for(返回值类型  变量名:容器名){}
        for(Object c:list){

            System.out.println(c);
        }

    }
}

---

Set接口

Set特点

1. 无序的。
2. 不允许重复的。
   3.只允许一个NULL值

HashSet实现类

package cn.com.oneqinglong.HashSetDemo;

import java.util.HashSet;
import java.util.Iterator;

/**
 * 
 * @author lingyao
 *
 *Set是以哈希表支持 存储信息
 *
 *Set集合的特点:
 *
 *  1.无序的.指的是添加元素和取出元素的顺序是不一致的
 *
 *  2.不允许元素重复的
 *
 *  3.最多只允许一个null元素
 *
 *HashSet是不同步的
 */
public class HashSetDemo {

    public static void main(String[] args) {

        HashSet set=new HashSet();
        set.add(new Integer(10));
        set.add(new Integer(40));
        set.add(new Integer(12));
        set.add(new Integer(15));
        set.add(new Integer(17));
        int[] array={21,22,33,44,55};
        set.add(array);

        //使用迭代器
        Iterator it=set.iterator();
        while(it.hasNext()){

            Object ob=it.next();

            //判断是否是int类型的数组
            if(ob instanceof int[]){
                //向下转型
                int[] arr=(int[])ob;
                for (int i = 0; i < arr.length; i++) {
                    System.out.println(arr[i]);
                }

            }else{
            System.out.println(ob);
            }
        }
        System.out.println("*************");
        //增强for循环
        for(Object a:set){
            System.out.println(a);
        }
    }
}

TreeSet实现类

package cn.com.oneqinglong.TreeSetDemo;

public class Student implements Comparable{

    private String stuNo;//学号

    private String name;//姓名

    private int age;//年龄

    public Student(){}


    public Student(String stuNo, String name, int age) {

        this.stuNo = stuNo;
        this.name = name;
        this.age = age;
    }


    public String getStuNo() {
        return stuNo;
    }

    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    @Override
    public int compareTo(Object o) {

        Student stu=(Student)o;
        /*
         //升序排列
        if(this.age>stu.getAge()){

            return 2;
        }

        if(this.age<stu.getAge()){

            return -2;
        }
        */

        if(this.age>stu.getAge()){

            return -2;
        }

        if(this.age<stu.getAge()){

            return 2;
        }
        //降序排列
        /*
        if(stu.getAge()>this.age){

            return 2;
        }

        if(stu.getAge()<this.age){

            return -2;
        }
        */
        return this.name.compareTo(stu.getName());
    }


}

package cn.com.oneqinglong.TreeSetDemo;

import java.util.Iterator;
import java.util.TreeSet;
/**
 * 
 * @author oneqinglong
 *
 *TreeSet是以二叉树的形式存储信息 (有自然排序的功能) 注意，此实现不是同步的
 *
 *用TreeSet存储自定义对象 需要实现Comparable重写comparTo方法
 *
 *
 */
public class TreeSetDemo {

    public static void main(String[] args) {

        TreeSet set=new TreeSet();
        set.add(new Student("201701", "张三", 25));
        set.add(new Student("201702", "李四", 29));
        set.add(new Student("201703", "王五", 23));
        set.add(new Student("201704", "赵六", 21));
        set.add(new Student("201705", "田七", 22));
        set.add(new Student("201706", "孙八", 27));
        set.add(new Student("201707", "白酒", 24));
        set.add(new Student("201708", "小明", 28));
        set.add(new Student("201709", "小强", 30));
        set.add(new Student("2017010", "小花", 22));

        Iterator it=set.iterator();
        while(it.hasNext()){

            Object obj=it.next();
            //判断一下对象是否是Student
            if(obj instanceof Student){

                Student stu=(Student)obj;
                System.out.println("学号:"+stu.getStuNo()+"--->姓名:"+stu.getName()+"--->年龄:"+stu.getAge());
            }
        }

    }
}

---

Map接口

package cn.com.oneqinglong.MapDemo;

import java.util.HashMap;
import java.util.Map;

/**
 * 
 * @author oneqinglong
 *
 *Map集合特点:
 *
 *  1.Map集合是以键值对的形式存储信息
 *
 *  2.Map集合必须保证键的唯一性
 *
 *  3.Map集合一个键最多只能映射一个值
 *
 *  4.Map集合键一般情况下建议使用String类型
 *
 *  5.Map集合键重复 值覆盖
 *
 *  6.Map允许null键和null值
 *
 *  7.Map集合也称为双列集合
 *
 *
 *
 *
 *Map集合方法:
 *
 *  1.添加:
 *
 *      V put(K key,V value);功能:向集合中添加键值对
 *
 *      void putAll(Map m);功能:向集合中添加m中包括所有的键值对
 *
 *  2.删除:
 *
 *      V remove(K key);功能:根据键删除键值对
 *
 *      void clear();功能:移除集合中所有的键值对
 *
 *  3.修改:就是根据Map集合键重复 值覆盖的原理
 *
 *
 *  4.获取:
 *
 *      int size();功能:获取集合中键值对的个数
 *
 *
 *      V get(K key);功能:根据键获取值
 *
 *  5.其他:
 *
 *      boolean containsKey(K key);功能:判断集合中是否包含指定的键
 *
 *      boolean containsValue(V value);功能:判断集合中是否包含指定的值
 *
 *      boolean isEmpty();功能:判断集合中是否包含键值对
 *
 *
 *
 */
public class MapDemo {

    public static void main(String[] args) {
        Map map=new HashMap();
        //返回的是被添加之前的内容
        Object o=map.put("1", new Integer(10));
        System.out.println(o);
        map.put("2", new Integer(30));
        map.put("3", new Integer(40));
        map.put("4", new Integer(50));
        map.put("5", new Integer(50));

        Object obj=map.put("1", new Integer(12));
        System.out.println("obj="+obj);
        System.out.println(map);
        //根据键删除键值对   要根据键去找值  不要根据值去找键
        Object ob=map.remove("3");
        System.out.println(ob);
        System.out.println(map);
        //获取集合中键值对的个数
        int i=map.size();
        System.out.println(i);
        //根据键获取值
        Object a=map.get("1");
        System.out.println(a);
        //判断集合中是否包含指定的键
        boolean bn=map.containsKey("2");
        System.out.println(bn);
        //判断是否包含指定的值
        boolean bm=map.containsValue(30);
        System.out.println(bm);
    }
}

HaspMap实现类

package cn.com.lingyao.HashMapDemo;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * 
 * @author lingyao
 *
 *HashMap也是不同步的.
 *
 */
public class HashMapDemo {

    public static void main(String[] args) {

        HashMap m=new HashMap();
        m.put("一", new Integer(30));
        m.put("二", new Integer(10));
        m.put("三", new Integer(40));
        m.put("四", new Integer(12));
        //第一种方式:根据键获取值

        Set set=m.keySet();//获取集合中所有的键 返回的是Set集合
        //遍历set集合
        Iterator it=set.iterator();
        while(it.hasNext()){
            //获取键
            Object key=it.next();
            //根据键获取值
            Object value=m.get(key);
            System.out.println(key+"---->"+value);
        }

        System.out.println("********************");
        //第二种方式:根据Map集合的内部类接口Entry

        Set st=m.entrySet();//获取所有的Entry对象 Map集合中每个键值对都对应一个Entry对象
        for(Object obj:st){
            //向下转型
            Map.Entry en=(Map.Entry)obj;

            //获取键
            Object k=en.getKey();
            //获取值
            Object v=en.getValue();

            System.out.println(k+"--->"+v);
        }
    }
}