java oop第07章_集合框架

时间：2023-12-21 12:53:32
一、    什么是集合：

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

二、    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提供了泛型来指定集合中放置数据的真实类型，以避免后期数据类型转换异常。


相关文章