java oop第07章_集合框架

一、    什么是集合：
　　在Java中提供了一些可以保存同一数据类型的数据集称为集合，就是规定了一些集合的规范（接口、抽象类、实现类）及方法，
　　方便我们程序在保存数据时进行增、删、改、查操作，编程更加高效。
 

二、    List集合：
　　List集合特性：List集合（ArrayList、LinkedList）是可重复的、有序的（是原始顺序）
　　1、ArrayList实现类：底层采用数组实现，查询可以通过下标快速点位，查询速度快，针对添、删、改速度慢
　　2、LinkedList实现类：底层采用双向链表实现，添加、删除时通过修改操作元素的前后索引值即可，效率高；
　　　　针对查询就需要从第一个查询到最后一个，查询效率低

package com.oop.ch07.test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import org.junit.Test;
import com.oop.ch07.Dept;

/**
 *练习List集合的使用：ArrayList、LinkedList
 *
 */
public class ListTest {

    //测试arraylist的基本用法
    @Test
    public void testArrayList1() {
        List arrayList1 = new ArrayList();
        //将元素值追加到集合中
        arrayList1.add("aa");
        arrayList1.add("gg");
        arrayList1.add("bb");
        arrayList1.add("cc");
        //将元素值插入到index（从0开始）指定的位置，其他的元素往后挪
        arrayList1.add(1, "mm");
        for (Object a : arrayList1) {
            System.out.println(a);
        }
        System.out.println("----------------------");
        Integer element0 = (Integer) arrayList1.get(0);
        System.out.println(element0);

    }

    //泛型
    @Test
    public void testArrayList2() {
        //在创建实现类ArrayList的对象时，Java7.0及以上的版本泛型会参考左边
        List<String> arrayList1 = new ArrayList<String>();
        //将元素值追加到集合中
        arrayList1.add("aa");
        arrayList1.add("gg");
        arrayList1.add("bb");
        arrayList1.add("cc");
        //将元素值插入到index（从0开始）指定的位置，其他的元素往后挪
        arrayList1.add(1, "mm");
        for (Object a : arrayList1) {
            System.out.println(a);
        }
        System.out.println("----------------------");
        //添加泛型以后可以将运行时异常提前为检查性异常，更容易被发现此异常，并及时处理
        //Integer element0 = (Integer) arrayList1.get(0);
        String element0 = arrayList1.get(0);
        System.out.println(element0);

    }

    //基本数据类型和包装数据类型
    @Test
    public void arrayList3() {
        List<Float> studentNos = new ArrayList<Float>();
        //自动装箱：能将基本数据类型（float）自动转换为包装数据类型（Float）
        studentNos.add(1.0F);
        studentNos.add(2.0F);
        //自动拆箱：能将包装数据类型自动转换为基本数据类型
        float no1 = studentNos.get(1);
        System.out.println(no1);
    }

    /**
     * 练习List（ArrayList、LinkedList）集合中提供的常用方法
     */
    @Test
    public void arrayList4() {
        List<String> list = new ArrayList<String>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("aaa");

        //在集合中从前向后查找指定的元素值对应的索引位置
        int index1 = list.indexOf("aaa"); //从前往后
        System.out.println(index1);

        //在集合中从后向前查找指定的元素值对应的索引位置
        int index2 = list.lastIndexOf("aaa"); //从后往前
        System.out.println(index2);

        //判断集合中是否包含指定的元素,包含为true
        //list.contains("ccc");
        System.out.println(list.contains("ccc"));

        //通过索引删除指定位置的元素，返回删除的元素值
        list.remove(3);
        System.out.println(list.remove(3));

        //通过元素删除对应的元素，返回是否删除成功
        //list.remove("bbb");
        System.out.println(list.remove("bbb"));

        //返回集合元素个数
        System.out.println(list.size());

        //Iterator迭代器，循环遍历元素
        /*
         * 返回该集合的所有元素，并把他们放置到一个iterator迭代器中，
         * it.hasNext():返回迭代器中是否还有下一个元素
         * it.net():返回正在迭代的元素值，将指针向下移动一个单位
         */
        Iterator<String> it =  list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }

    /**
     * 练习LinkedList集合中提供的常用方法
     */
    @Test
    public void testLinledList() {
        List<String> list = new LinkedList<String>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("aaa");

        for (String element : list) {
            System.out.println(element);
        }

        //在集合中从前向后查找指定的元素值对应的索引位置
        int index1 = list.indexOf("aaa"); //从前往后
        System.out.println(index1);

        //在集合中从后向前查找指定的元素值对应的索引位置
        int index2 = list.lastIndexOf("aaa"); //从后往前
        System.out.println(index2);

        //判断集合中是否包含指定的元素,包含为true
        //list.contains("ccc");
        System.out.println(list.contains("ccc"));

        //通过索引删除指定位置的元素，返回删除的元素值
        list.remove(3);
        System.out.println(list.remove(3));

        //通过元素删除对应的元素，返回是否删除成功
        //list.remove("bbb");
        System.out.println(list.remove("bbb"));

        //返回集合元素个数
        System.out.println(list.size());

        //Iterator迭代器，循环遍历元素
        /*
         * 返回该集合的所有元素，并把他们放置到一个iterator迭代器中，
         * it.hasNext():返回迭代器中是否还有下一个元素
         * it.net():返回正在迭代的元素值，将指针向下移动一个单位
         */
        Iterator<String> it =  list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }

    /*
     * 在List中放实体,实体类代码放在最后
     */
    @Test
    public void testArrayListEntity() {
        List<Dept> deptList = new ArrayList<Dept>();
        deptList.add(new Dept("人事部","北京"));
        deptList.add(new Dept("财务部","上海"));
        deptList.add(new Dept("公关部","昆明"));
        deptList.add(new Dept("综合部","山东"));

        for (Dept dept : deptList) {
            System.out.println(dept);
        }
    }
}

三、    Set集合：
　　1、HashSet实现类：不可重复的、是无序的，Hash算法就是随机算法。

package com.oop.ch07.test;

import java.util.*;

/*
 * 练习HashSet集合的使用
 */
public class HashSetTest {

    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();

        System.out.println("set集合是否为空：" + set.isEmpty());

        set.add("aaa");
        set.add("bbb");
        set.add("ccc");
        set.add("ddd");
        set.add("eee");
        set.add("aaa");

        for (String element : set) {
            System.out.println(element);
        }
        System.out.println("---------");

        //只能通过值删除
        set.remove("eee");
        for (String element : set) {
            System.out.println(element);
        }

        //集合的长度
        System.out.println("Set集合的长度：" + set.size());

        //Iterator迭代器，遍历set
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());

        }
    }

}

　　2、TreeSet实现类：不可重复的、是有序的（自然顺序，a-z、0-9）

package com.oop.ch07.test;

import java.util.*;

/*
 * 练习TreeSet集合的使用：自然顺序
　　TreeSet集合的大多数方法都和HashSet一样的
 */
public class TreeSetTest {
    public static void main(String[] args) {
        Set<String> set = new TreeSet<String>();
        set.add("aaa");
        set.add("ccc");
        set.add("bbb");
        set.add("ddd");
        set.add("eee");
        set.add("aaa");

        for (String element : set) {
            System.out.println(element);
        }
    }
}

四、    Map集合：
　　Map集合采用“键值对”的entry结构，每一个元素由key（键）和value(值)构成，可以通过指定key方便的获取value。
　　1、    HashMap实现类：是无序的（Hash是一种随机算法），针对Key是不可重复的，若放相同的Key，
　　　　　　新的entry会替换老的entry；针对value没有限制（可重复）。
　　2、    TreeMap实现类：针对key是自然排序，不可重复，若key重复，新的entey会替换老的entry。针对value没有限制（可重复）。

package com.oop.ch07.test;

import java.util.Map.*;
import java.util.*;
import org.junit.Test;
import com.oop.ch07.Dept;

/*
 * 练习map集合的使用：HashMap、TreeMap
 */
public class MapTest {
    /**
     * 练习HashMap
     */
    @Test
    public void testHashMap() {
        Map<Object, Object> map = new HashMap<Object, Object>();
        map.put("k1","k1的值");
        map.put("k2","k2的值");
        map.put("k3","k3的值");
        map.put("k4","k4的值");
        map.put("k3","k3的新值");
        map.put("k5","k3的值");

        //通过key获取该entry中的value
        System.out.println(map.get("k3"));

        //entry的个数
        System.out.println("entry的个数:" + map.size());

        //map.keySet()：将Map集合中所有entry的key都获取并放置到Set集合中
        Set<Object> keySets = map.keySet();
        for (Object key : keySets) {
            //针对放置了Map集合中所有Key的Set集合进行遍历，可以取到Key值，再通过get(Object Key)方法获取到对应的value
            System.out.println("键：" + key + "，值：" + map.get(key));
        }

        //entrySet()：将Map集合中的所有entry（key和Value）一次性取出来放到一个Set集合中，
        //再通过entry的getKey和getValue方法，获取到Map集合中放置的Key和value
        //Entry<Object, Object>：相当于一个object
        System.out.println();
        Set<Entry<Object, Object>> entrySet =  map.entrySet();
        for (Entry<Object, Object> entry : entrySet) {
            System.out.println("键：" + entry.getKey() + "，值：" + entry.getValue());
        }

        //containsKey(Object key):Map集合的Key中是否包含key,包含为true
        System.out.println(map.containsKey("k2"));
        //containsValue(Object value):Map集合的Value中是否包含value
        System.out.println(map.containsValue("K2"));

    }

    /**
     * 练习TreeMap
     */
    @Test
    public void testTreeMap() {
        Map<Object, Object> map = new TreeMap<Object, Object>();
        map.put("k1","k1的值");
        map.put("k2","k2的值");
        map.put("k3","k3的值");
        map.put("k4","k4的值");
        map.put("k3","k3的新值");
        map.put("k5","k3的值");

        //通过key获取该entry中的value
        System.out.println(map.get("k3"));

        //entry的个数
        System.out.println("entry的个数:" + map.size());

        //map.keySet()：将Map集合中所有entry的key都获取并放置到Set集合中
        Set<Object> keySets = map.keySet();
        for (Object key : keySets) {
            //针对放置了Map集合中所有Key的Set集合进行遍历，可以取到Key值，再通过get(Object Key)方法获取到对应的value
            System.out.println("键：" + key + "，值：" + map.get(key));
        }

        //entrySet()：将Map集合中的所有entry（key和Value）一次性取出来放到一个Set集合中，
        //再通过entry的getKey和getValue方法，获取到Map集合中放置的Key和value
        //Entry<Object, Object>：相当于一个object
        System.out.println();
        Set<Entry<Object, Object>> entrySet =  map.entrySet();
        for (Entry<Object, Object> entry : entrySet) {
            System.out.println("键：" + entry.getKey() + "，值：" + entry.getValue());
        }

        //containsKey(Object key):Map集合的Key中是否包含key,包含为true
        System.out.println(map.containsKey("k2"));
        //containsValue(Object value):Map集合的Value中是否包含value
        System.out.println(map.containsValue("K2"));

    }

    @Test
    /*
     * 在HashMap中放实体
     */
    public void testHashMapEntity() {
        Map<String,Dept> deptMap = new HashMap<String, Dept>();
        deptMap.put("dept1", new Dept("人事部","北京"));
        deptMap.put("dept2", new Dept("财务部","上海"));
        deptMap.put("dept3", new Dept("公关部","昆明"));
        deptMap.put("dept4", new Dept("综合部","山东"));

        //打印一个value
        System.out.println(deptMap.get("dept1"));

        //使用entrySet遍历Map集合
        System.out.println("使用entrySet遍历Map集合");
        for (Entry<String, Dept> map : deptMap.entrySet()) {
            System.out.println(map);
        }

        //使用keySet遍历集合
        System.out.println("使用keySet遍历集合");
        //Set<String> key = deptMap.keySet();
        for (String map : deptMap.keySet()) {
            System.out.println(map + "=" + deptMap.get(map));
        }
    }
}

---

实体类：

package com.oop.ch07;

/**
 * 练习封装tb_dept表对应的实体类Dept 八种基本数据类型对应的有八种引用数据类型（包装数据类型）,
 * byte short int 　　 long  loat  double 　　char  　　　　boolean
 * Byte Short Integer Long  Float Double 　　Character   Boolean
 *
 */
public class Dept {
    private Integer deptNo; // 部门编号
    private String dName;     // 部门名称
    private String loc;     // 部门所在地
    //setter、getter方法的区域：
    public void setDeptNo(Integer deptNo) {
        this.deptNo = deptNo;
    }
    public Integer getDeptNo() {
        return deptNo;
    }

    public void setDName(String dName) {
        this.dName = dName;
    }
    public String getDName() {
        return dName;
    }

    public void setLoc(String loc) {
        this.loc = loc;
    }
    public String getloc() {
        return loc;
    }

    //构造方法的区域：
    //默认的构造方法，当手动写了一个带参的构造方法，默认的就会失效
    public Dept() {

    }
    //有参的构造方法
    public Dept(Integer deptNo) {
        this.deptNo = deptNo;
    }
    public Dept(String dName,String loc) {
        this.dName = dName;
        this.loc = loc;
    }
    public String method1() {
        return null;
    }

    /*
     * 重写toString()方法，在Object类中就定义过该方法，一个类若重写了toString()方法
     * 当输出该类的对象信息时，就会以toString方法的格式输出该类中“属性名 = 属性值”的格式，更方便我们观察对象的属性信息
     * 此方法不需要手动调用，而是在输出对象时，JVM会自动调用
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "Dept [deptNo=" + deptNo + ", dName=" + dName + ", loc=" + loc + "]";
    }
}

---

五、    泛型：
　　在集合框架中默认放置的数据都是Object类型（让集合可以存放任何类型的数据），但实际运用过程中通常需要将类型具体化，
　　更利于代码的编写，因此Java提供了泛型来指定集合中放置数据的真实类型，以避免后期数据类型转换异常。