Java集合框架(上)

Java中集合类的概念:

是一种工具类,就像是容器,储存任意数量的具有共同属性的对象。


集合的作用:

  1. 在类的内部,对数据进行组织。
  2. 简单而快速地搜索大数量的条目。
  3. 有的集合接口,提供了一系列排列有序的元素,并且可以在序列中间快速快速的插入或删除有关元素。
  4. 有的集合接口,提供了映射的关系,可以通过关键字(key)快速查找到对应的唯一对象,而这个关键字可以是任意类型。

为什么选择集合,而不是数组?

  1. 数组的长度是固定的,而集合的长度是可变的
  2. 数组只能通过数组下标去访问,且下标数据类型固定,只能是整型,很多情况下我们不知道数组元素的具体位置,因此只能一个个遍历去查找,这种情况当数组很庞大的时候程序非常耗时。而有的集合可以通过任意类型的关键字查找所映射的具体对象。

Java集合框架体系结构

这里写图片描述

  1. 对于Collection,最上层是父接口,二层是父接口下的子接口,三层是子接口对应的实现类。
  2. 对于Map,其最常用的实现类的HashMap;Map中有内部类Entry,翻译成键值对;一个Key(任意类型)对应一个Value(任意类型)正是Entry类的一个实例。
  3. List集合中的元素是有序并且可以重复的。
  4. Set集合中的元素是无序的,不可重复的。

实例演练:

学生选课功能实现:

  1. 选择课程(往集合中添加元素)
  2. 删除所选的某门课程(删除集合中的元素)
  3. 查看所选课程
  4. 修改所选课程

课程类(Course.java):

package com.imooc.collection;

public class Course {

    public String id;
    public String name;

    public Course(String id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
}

学生类(Student.java):

package com.imooc.collection;

import java.util.HashSet;
import java.util.Set;

public class Student {

    public String id;
    public String name;

    public Set<Course> courses;

    public Student(String id, String name) {
        super();
        this.id = id;
        this.name = name;
        this.courses = new HashSet<Course>();
    }
}

ArrayList增删改查(ListTest.java):

package com.imooc.collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
public class ListTest {

    /*List中的元素是有序并且可以重复的*/
    public List CoursesToSelect;

    public ListTest(){
        //注意List是个接口,不能直接将其实例化
        this.CoursesToSelect = new ArrayList();
    }

    public void TestAdd(){

        /*---普通add测试---*/
        Course cr1 = new Course("1","数据结构");
        CoursesToSelect.add(cr1);


        /*---指定位置add测试,下挤---*/
        Course cr2 = new Course("2","常用算法");
        CoursesToSelect.add(0, cr2);//添加到第一个位置,会将原有的挤下去。


        /*---越界add测试---*/
        //Course cr3 = new Course("3","JAVA");
        //CoursesToSelect.add(3, cr3);
        /*
         * 注意!!
         * 0,1,2均不报错
         * 3报错:java.lang.IndexOutOfBoundsException  下标越界
         * */


        /*---普通组合add添加---*/ 
        Course[] courseList = {new Course("3","Javaweb"),new Course("4","数据库")};
        CoursesToSelect.addAll(Arrays.asList(courseList));


        /*---指定位置组合add添加---*/
        Course[] courseList2 = {new Course("5","高等数学"),new Course("6","计算机网络")};
        CoursesToSelect.addAll(2,Arrays.asList(courseList2));
    }

    public void testQueryAll(){  //查看全部元素
        System.out.println("普通遍历List");
        for(int i=0;i<CoursesToSelect.size();i++){
            /*对象存入集合都变成Object类型,取出时需要类型转换*/
            Course tempCourse = (Course) CoursesToSelect.get(i);
            System.out.println("课程"+(i+1)+":"+tempCourse.name+" 课程id:"+tempCourse.id);
        }
    }

    public void testIterator(){  //通过迭代器遍历List

        System.out.println("通过迭代器遍历List");
        //迭代器是用来遍历集合中的元素的,本身不具备任何存储元素的功能;依赖于某个集合存在,本身不能独立存在
        //迭代器本身是个接口,通过集合的iterator()方法,取得迭代器的实例
        Iterator it = CoursesToSelect.iterator();
        while(it.hasNext()){
            Course cr = (Course) it.next();
            System.out.println("课程:"+cr.name+" 课程id:"+cr.id);
        }
    }

    public void testForEach(){  //通过foreach遍历List

        System.out.println("通过foreach遍历List");
        for(Object obj:CoursesToSelect){
            Course cr = (Course)obj;
            System.out.println("课程:"+cr.name+" 课程id:"+cr.id);
        }
    }

    public void testModify(){  //修改
        CoursesToSelect.set(0, new Course("100","Spring"));
    }

    public void testRemove(){  //删除,记住每删除一次,元素都会上移

        CoursesToSelect.remove(1);//删除的第一种方式

        /*在上面删除位置1的元素后,后面的元素会整体上移,位置1又有了新元素,所以下面的语句是删除现在位置2的新元素*/
        Course cr = (Course) CoursesToSelect.get(2);   //删除的第二种方式
        CoursesToSelect.remove(cr);

        Course[] courseList = 
                {(Course) CoursesToSelect.get(1),
                (Course) CoursesToSelect.get(2),
                (Course) CoursesToSelect.get(3)};
        CoursesToSelect.removeAll(Arrays.asList(courseList));   //删除的第三种方式,removeAll

    }

    public static void main(String[] args){

        ListTest lt = new ListTest();
        lt.TestAdd();
        lt.testQueryAll();
        lt.testIterator();
        lt.testModify();  //修改课程
        lt.testRemove();  //删除课程
        lt.testForEach();
    }
}

运行结果:
普通遍历List
课程1:常用算法 课程id:2
课程2:数据结构 课程id:1
课程3:高等数学 课程id:5
课程4:计算机网络 课程id:6
课程5:Javaweb 课程id:3
课程6:数据库 课程id:4
通过迭代器遍历List
课程:常用算法 课程id:2
课程:数据结构 课程id:1
课程:高等数学 课程id:5
课程:计算机网络 课程id:6
课程:Javaweb 课程id:3
课程:数据库 课程id:4
通过foreach遍历List
课程:Spring 课程id:100


ArrayList泛型管理集合元素(TestGeneric.java):

package com.imooc.collection;

import java.util.ArrayList;
import java.util.List;

public class TestGeneric {
    //规定当前List只能存放Course类型的元素,否则编译器会报错
    //若无泛型,添加了其他奇怪的元素编译器不会报错,但是运行时就会报错
    public List<Course> courses;
    public TestGeneric(){
        this.courses = new ArrayList<Course>();
    }


    public void testAdd(){
        Course cr1 = new Course("1","数据结构");
        courses.add(cr1);
    }

    public void testForEach(){
        for(Course course:courses){  //不需要再强制类型转换,直接取元素出来使用
            System.out.println("课程:"+course.name);
        }
    }
    public static void main(String[] args){
        TestGeneric tg = new TestGeneric();
        tg.testAdd();
        tg.testForEach();
    }

    //指定泛型的List还可以存放指定泛型元素实例的子类元素实例
    //泛型不能是基本类型数据,例如int,char等
    //泛型必须是引用类型的数据,可以使用包装类对基本数据类型进行装箱然后再使用泛型
}

运行结果:
课程:数据结构


Set集合的基本用法(SetTest.java):

package com.imooc.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class SetTest {

    public List<Course> CoursesToSelect;
    public SetTest(){
        this.CoursesToSelect = new ArrayList<Course>();
    }

    public void TestAdd(){

        Course cr1 = new Course("1","数据结构");
        CoursesToSelect.add(cr1);


        Course cr2 = new Course("2","常用算法");
        CoursesToSelect.add(0, cr2);


        Course[] courseList = {new Course("3","Javaweb"),new Course("4","数据库")};
        CoursesToSelect.addAll(Arrays.asList(courseList));


        Course[] courseList2 = {new Course("5","高等数学"),new Course("6","计算机网络")};
        CoursesToSelect.addAll(2,Arrays.asList(courseList2));
    }

    public void testForEach(){  
        for(Course course:CoursesToSelect){
            System.out.println("课程:"+course.name+" 课程id:"+course.id);
        }
    }

    public static void main(String[] args){
        SetTest st = new SetTest();
        st.TestAdd();
        st.testForEach();

        //创建一个学生对象
        Student stu1= new Student("1","小明");
        System.out.println("欢迎"+stu1.name+"选课!");

        Scanner sc = new Scanner(System.in);
        for(int i=0;i<3;i++){

            System.out.println("请输入课程ID");
            String courseId = sc.next();

            for(Course course:st.CoursesToSelect){
                if(course.id.equals(courseId)){  //字符串是对象,其equals()方法比较的是实际内容!
                    stu1.courses.add(course);
                }
            }
        }

        st.testForEachForSet(stu1);
    }

    public void testForEachForSet(Student stu){

        //打印输出学生所选的课程
        //遍历Set中的元素只能用foreach或是iterator,不能想List那样用get(index),因为Set是无序的。
        //Set中的元素是不可重复的,重复的添加Set只会保存一个该对象(的引用)
        //Set是可以添加空对象的,null
        //Set没有提供像List那样的set()方法,因为Set集合是无序的
        System.out.println("共选择了"+stu.courses.size()+"门课程");
        for(Course course:stu.courses){
            System.out.println(stu.name+"选择了"+course.name+" 课程id:"+course.id);
        }
        //没有介绍的关于Set的remove(),size()等方法,大致跟List一样
    }
}

运行结果:
课程:常用算法 课程id:2
课程:数据结构 课程id:1
课程:高等数学 课程id:5
课程:计算机网络 课程id:6
课程:Javaweb 课程id:3
课程:数据库 课程id:4
欢迎小明选课!
请输入课程ID
4
请输入课程ID
4
请输入课程ID
6
共选择了2门课程
小明选择了计算机网络 课程id:6
小明选择了数据库 课程id:4


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值