zoukankan      html  css  js  c++  java
  • 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提供了泛型来指定集合中放置数据的真实类型,以避免后期数据类型转换异常。
  • 相关阅读:
    转载:【Oracle 集群】RAC知识图文详细教程(三)--RAC工作原理和相关组件
    转载:【Oracle 集群】RAC知识图文详细教程(一)--集群概念介绍
    转载:【Oracle 集群】RAC知识图文详细教程(二)--Oracle 集群概念及原理
    题目总结
    面试题(包含答案)
    ElementUI动态表格数据转换formatter
    父组件搜索列表 给 子组件传值问题
    项目提取公共接口方法
    数组常用方法总结
    vue全局注册
  • 原文地址:https://www.cnblogs.com/zhangzimuzjq/p/11725608.html
Copyright © 2011-2022 走看看