美文网首页
Java基础知识点（九）

Java基础知识点（九）

作者: 羋学僧 | 来源:发表于2021-09-20 23:10 被阅读0次

一、Java 中的集合框架（上）

1、Java 中的集合框架概述


JAVA集合框架体系结构：Collection与Map是两个根接口。

Collection接口：内部存储的是一个个独立的对象。包含：
  • 1、List接口：序列，存储元素排列有序且可重复。实现类:ArrayList，数组序列。实现类：LinkedList，链表。
  • 2、Queue接口：队列，存储元素排列有序且可重复。实现类：LinkedList，链表。
  • 3、Set接口：集，存储元素无序且不可重复。实现类：HashSet，哈希集。
Map接口：

  • 内部以<Key,Value>两个对象（任意类型）为一个映射去存储数据，这一个映射就是Entry类（Map的内部类）的实例。包括：实现类：HashMap，哈希表。


2、Collection 接口 & List 接口简介


3 、学生选课--创建学生类和课程类

package com.imooc.collection;

/**
 * 课程类
 * @author Administrator
 *
 */
public class Course {

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


package com.imooc.collection;

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

/**
 * 学生类
 * @author Administrator
 *
 */
public class Student {

    public String id;
    
    public String name;
    
    public Set<Course> courses;

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

4、学生选课

  • 添加课程

  • 课程查询

  • 课程修改

  • 课程删除

package com.imooc.collection;

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

/**
 * 备选课程类
 * @author Administrator
 *
 */
public class ListTest {

    /**
     * 用于存放备选课程的List
     */
    public List coursesToSelect;
    
    public ListTest() {
        this.coursesToSelect = new ArrayList();
    }
    
    /**
     * 用于往coursesToSelect中添加备选课程
     */
    public void testAdd() {
        //创建一个课程对象，并通过调用add方法，添加到备选课程List中
        Course cr1 = new Course("1" , "数据结构");
        coursesToSelect.add(cr1);
        Course temp = (Course) coursesToSelect.get(0);
        System.out.println("添加了课程：" + temp.id + ":" + temp.name); 
        
        Course cr2 = new Course("2", "C语言");
        coursesToSelect.add(0, cr2);
        Course temp2 = (Course) coursesToSelect.get(0);
        System.out.println("添加了课程：" + temp2.id + ":" + temp2.name);
        
        coursesToSelect.add(cr1);
        Course temp0 = (Course) coursesToSelect.get(2);
        System.out.println("添加了课程：" + temp.id + ":" + temp.name); 
        
        
        //以下方法会抛出数组下标越界异常
//      Course cr3 = new Course("3", "test");
//      coursesToSelect.add(4, cr3);
        
        Course[] course = {new Course("3", "离散数学"), new Course("4", "汇编语言")};
        coursesToSelect.addAll(Arrays.asList(course));
        Course temp3 = (Course) coursesToSelect.get(2);
        Course temp4 = (Course) coursesToSelect.get(3);
        
        System.out.println("添加了两门课程：" + temp3.id + ":" + 
                temp3.name + ";" + temp4.id + ":" + temp4.name);
        
        Course[] course2 = {new Course("5", "高等数学"), new Course("6", "大学英语")};
        coursesToSelect.addAll(2, Arrays.asList(course2));
        Course temp5 = (Course) coursesToSelect.get(2);
        Course temp6 = (Course) coursesToSelect.get(3);
        System.out.println("添加了两门课程：" + temp5.id + ":" + 
                temp5.name + ";" + temp6.id + ":" + temp6.name);
        
    }
    
    /**
     * 取得List中的元素的方法
     * @param args
     */
    public void testGet() {
        int size = coursesToSelect.size();
        System.out.println("有如下课程待选：");
        for(int i= 0 ; i < size; i++) {
            Course cr = (Course) coursesToSelect.get(i);
            System.out.println("课程：" + cr.id + ":" + cr.name);
        }
    }
    
    /**
     * 通过迭代器来遍历List
     * @param args
     */
    public void testIterator() {
        //通过集合的iterator方法，取得迭代器的实例
        Iterator<Course> it = coursesToSelect.iterator();
        System.out.println("有如下课程待选(通过迭代器访问)：");
        while(it.hasNext()) {
            Course cr = it.next();
            System.out.println("课程：" + cr.id + ":" + cr.name);
        }
    }
    
    /**
     * 通过for each方法访问集合元素
     * @param args
     */
    public void testForEach() {
        System.out.println("有如下课程待选(通过for each访问)：");
        for (Object obj : coursesToSelect) {
            Course cr = (Course) obj;
            System.out.println("课程：" + cr.id + ":" + cr.name);
        }
    }
    
    /**
     * 修改List中的元素
     * @param args
     */
    public void testModify() {
        coursesToSelect.set(4, new Course("7", "毛概"));
    }
    
    /**
     * 删除List中的元素
     * @param args
     */
    public void testRemove() {
//      Course cr = (Course) coursesToSelect.get(4);
        System.out.println("即将删除4位置和5位置上的课程！");
        Course[] courses = {(Course) coursesToSelect.get(4), (Course) coursesToSelect.get(5)};
        coursesToSelect.removeAll(Arrays.asList(courses));
        //      coursesToSelect.remove(4);
        System.out.println("成功删除课程！");
        testForEach();
    }
    
    /**
     * 往List中添加一些奇怪的东西
     * @param args
     */
    public void testType() {
        System.out.println("能否往List中添加一些奇怪的东西呢！？");
        coursesToSelect.add("我不是课程，我只是一个无辜的字符串！！");
    }
    
    public static void main( String[] args) {
        ListTest lt = new ListTest();
        lt.testAdd();
        lt.testType();
        lt.testForEach();
//      lt.testGet();
//      lt.testIterator();
//      lt.testForEach();
//      lt.testModify();
//      lt.testForEach();
//      lt.testRemove();
    }
}

5、学生选课----应用泛型管理课程

package com.imooc.collection;

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

public class TestGeneric {

    /**
     * 带有泛型——Course，的List类型属性
     */
    public List<Course> courses;
    
    public TestGeneric() {
        this.courses = new ArrayList<Course>();
    }
    
    /**
     * 测试添加
     */
    public void testAdd() {
        Course cr1 = new Course("1","大学语文");
        courses.add(cr1);
        //泛型集合中，不能添加泛型规定的类型及其子类型以外的对象，否则会报错！
//      courses.add("能否添加一些奇怪的东西呢？？");
        Course cr2 = new Course("2","Java基础");
        courses.add(cr2);
    }
    
    /**
     * 测试循环遍历
     */
    public void testForEach() {
        for (Course cr : courses) {
            System.out.println(cr.id + ":" + cr.name);
        }
    }
    
    /**
     * 泛型集合可以添加泛型的子类型的对象实例
     */
    public void testChild() {
        ChildCourse ccr = new ChildCourse();
        ccr.id = "3";
        ccr.name = "我是子类型的课程对象实例~~";
        courses.add(ccr);
    }
    
    /**
     * 泛型不能使用基本类型
     */
    public void testBasicType() {
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        System.out.println("基本类型必须使用包装类作为泛型！" + list.get(0));
    }
    
    /**
     * @param args
     */
    public static void main(String[] args) {
        TestGeneric tg = new TestGeneric();
        tg.testAdd();
        tg.testForEach();
        tg.testChild();
        tg.testForEach();
        tg.testBasicType();
    }

}


package com.imooc.collection;

public class ChildCourse extends Course {

}

1.泛型集合中不能使用基本数据类型List<int>course。必须为引用类型List<Course> course
2.可以通过使用包装类限定允许存入的基本数据类型。

6、学生选课----通过 Set 集合管理课程


Set接口及其实现类——HashSet
  • Set是元素无序并且不可以重复的集合，被称为集；

HashSet——哈希集，是Set的一个重要实现类

  • 1、Set没有像List中set()方法一样就修改，因为List是有序的，可以指定位置，而Set是无序的。

  • 2、查询遍历时，Set不能用get()方法去获取，因为无序没有指定索引ID，但可以使用foreach和iterator来遍历，但是每次遍历出来可能顺序都不一样，还是因为无序造成的。

  • 3、Set中的size(),add(),addAll(),remove(),removeAll()与List类似。

  • 4、Set还可以添加null；无序演示

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() {
        coursesToSelect = new ArrayList<Course>();
    }

    /**
     * 用于往coursesToSelect中添加备选课程
     */
    public void testAdd() {
        // 创建一个课程对象，并通过调用add方法，添加到备选课程List中
        Course cr1 = new Course("1", "数据结构");
        coursesToSelect.add(cr1);
        Course temp = (Course) coursesToSelect.get(0);
        // System.out.println("添加了课程：" + temp.id + ":" + temp.name);

        Course cr2 = new Course("2", "C语言");
        coursesToSelect.add(0, cr2);
        Course temp2 = (Course) coursesToSelect.get(0);
        // System.out.println("添加了课程：" + temp2.id + ":" + temp2.name);

        // coursesToSelect.add(cr1);
        // Course temp0 = (Course) coursesToSelect.get(2);
        // System.out.println("添加了课程：" + temp.id + ":" + temp.name);

        // 以下方法会抛出数组下标越界异常
        // Course cr3 = new Course("3", "test");
        // coursesToSelect.add(4, cr3);

        Course[] course = { new Course("3", "离散数学"), new Course("4", "汇编语言") };
        coursesToSelect.addAll(Arrays.asList(course));
        Course temp3 = (Course) coursesToSelect.get(2);
        Course temp4 = (Course) coursesToSelect.get(3);

        // System.out.println("添加了两门课程：" + temp3.id + ":" +
        // temp3.name + ";" + temp4.id + ":" + temp4.name);

        Course[] course2 = { new Course("5", "高等数学"), new Course("6", "大学英语") };
        coursesToSelect.addAll(2, Arrays.asList(course2));
        Course temp5 = (Course) coursesToSelect.get(2);
        Course temp6 = (Course) coursesToSelect.get(3);
        // System.out.println("添加了两门课程：" + temp5.id + ":" +
        // temp5.name + ";" + temp6.id + ":" + temp6.name);

    }

    /**
     * 通过for each方法访问集合元素
     * 
     * @param args
     */
    public void testForEach() {
        System.out.println("有如下课程待选(通过for each访问)：");
        for (Object obj : coursesToSelect) {
            Course cr = (Course) obj;
            System.out.println("课程：" + cr.id + ":" + cr.name);
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        SetTest st = new SetTest();
        st.testAdd();
        st.testForEach();
        // 创建一个学生对象
        Student student = new Student("1", "小明");
        System.out.println("欢迎学生：" + student.name + "选课！");
        // 创建一个Scanner对象，用来接收从键盘输入的课程ID
        Scanner console = new Scanner(System.in);

        for (int i = 0; i < 3; i++) {
            System.out.println("请输入课程ID");
            String courseId = console.next();
            for (Course cr : st.coursesToSelect) {
                if (cr.id.equals(courseId)) {
                    student.courses.add(cr);
                    /**
                     * Set中，添加某个对象，无论添加多少次， 最终只会保留一个该对象（的引用）， 并且，保留的是第一次添加的那一个
                     */
                    // student.courses.add(null);
                    student.courses.add(cr);
                }
            }
        }
        st.testForEachForSet(student);
    }

    public void testForEachForSet(Student student) {
        // 打印输出，学生所选的课程！
        System.out.println("共选择了：" + student.courses.size() + "门课程！");
        for (Course cr : student.courses) {
            System.out.println("选择了课程：" + cr.id + ":" + cr.name);
        }
    }

}

二、Java 中的集合框架（中）

1、Map & HashMap 简介




2、学生选课

  • 使用 Map 添加学生

  • 删除 Map 中的学生

  • 修改 Map 中的学生

  • 判断 List 中课程是否存在

  • 判断 Set 中课程是否存在

  • 获取 List 中课程的位置

  • 判断 Map


package com.imooc.collection;

/**
 * 课程类
 * @author Administrator
 *
 */
public class Course {

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


package com.imooc.collection;

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

/**
 * 学生类
 * @author Administrator
 *
 */
public class Student {

    public String id;
    
    public String name;
    
    public Set<Course> courses;

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


package com.imooc.collection;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;

public class MapTest {

    /**
     * 用来承装学生类型对象
     */
    public Map<String, Student> students;

    /**
     * 在构造器中初始化students属性
     */
    public MapTest() {
        this.students = new HashMap<String, Student>();
    }

    /**
     * 测试添加：输入学生ID，判断是否被占用 若未被占用，则输入姓名，创建新学生对象，并且 添加到students中
     */
    public void testPut() {
        // 创建一个Scanner对象，用来获取输入的学生ID和姓名
        Scanner console = new Scanner(System.in);
        int i = 0;
        while (i < 3) {
            System.out.println("请输入学生ID：");
            String ID = console.next();
            // 判断该ID是否被占用
            Student st = students.get(ID);
            if (st == null) {
                // 提示输入学生姓名
                System.out.println("请输入学生姓名：");
                String name = console.next();
                // 创建新的学生对象
                Student newStudent = new Student(ID, name);
                // 通过调用students的put方法，添加ID-学生映射
                students.put(ID, newStudent);
                System.out.println("成功添加学生：" + students.get(ID).name);
                i++;
            } else {
                System.out.println("该学生ID已被占用！");
                continue;
            }
        }
    }

    /**
     * 测试Map的keySet方法
     */
    public void testKeySet() {
        // 通过keySet方法，返回Map中的所有“键”的Set集合
        Set<String> keySet = students.keySet();
        // 取得students的容量
        System.out.println("总共有：" + students.size() + "个学生！");
        // 遍历keySet，取得每一个键，再调用get方法取得每个键对应的value
        for (String stuId : keySet) {
            Student st = students.get(stuId);
            if (st != null)
                System.out.println("学生：" + st.name);
        }
    }

    /**
     * 测试删除Map中的映射
     */
    public void testRemove() {
        // 获取从键盘输入的待删除学生ID字符串
        Scanner console = new Scanner(System.in);
        while (true) {
            // 提示输入待删除的学生的ID
            System.out.println("请输入要删除的学生ID！");
            String ID = console.next();
            // 判断该ID是否有对应的学生对象
            Student st = students.get(ID);
            if (st == null) {
                // 提示输入的ID并不存在
                System.out.println("该ID不存在！");
                continue;
            }
            students.remove(ID);
            System.out.println("成功删除学生：" + st.name);
            break;
        }
    }

    /**
     * 通过entrySet方法来遍历Map
     */
    public void testEntrySet() {
        // 通过entrySet方法，返回Map中的所有键值对
        Set<Entry<String, Student>> entrySet = students.entrySet();
        for (Entry<String, Student> entry : entrySet) {
            System.out.println("取得键：" + entry.getKey());
            System.out.println("对应的值为：" + entry.getValue().name);
        }
    }

    /**
     * 利用put方法修改Map中的已有映射
     */
    public void testModify() {
        // 提示输入要修改的学生ID
        System.out.println("请输入要修改的学生ID：");
        // 创建一个Scanner对象，去获取从键盘上输入的学生ID字符串
        Scanner console = new Scanner(System.in);
        while (true) {
            // 取得从键盘输入的学生ID
            String stuID = console.next();
            // 从students中查找该学生ID对应的学生对象
            Student student = students.get(stuID);
            if (student == null) {
                System.out.println("该ID不存在！请重新输入！");
                continue;
            }
            // 提示当前对应的学生对象的姓名
            System.out.println("当前该学生ID，所对应的学生为：" + student.name);
            // 提示输入新的学生姓名，来修改已有的映射
            System.out.println("请输入新的学生姓名：");
            String name = console.next();
            Student newStudent = new Student(stuID, name);
            students.put(stuID, newStudent);
            System.out.println("修改成功！");
            break;
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        MapTest mt = new MapTest();
        mt.testPut();
        mt.testKeySet();
        // mt.testRemove();
        // mt.testEntrySet();
        // mt.testModify();
        // mt.testEntrySet();

    }

}
  • 应用 Collections.sort()

-尝试对学生序列排序

package com.imooc.collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

/**
 * 将要完成：
 * 1.通过Collections.sort()方法，对Integer泛型的List进行排序；
 * 2.对String泛型的List进行排序；
 * 3.对其他类型泛型的List进行排序，以Student为例。
 */
public class CollectionsTest {

    /**
     * 1.通过Collections.sort()方法，对Integer泛型的List进行排序；
     * 创建一个Integer泛型的List，插入十个100以内的不重复随机整数，
     * 调用Collections.sort()方法对其进行排序
     */
    public void testSort1() {
        List<Integer> integerList = new ArrayList<Integer>();
        // 插入十个100以内的不重复随机整数
        Random random = new Random();
        Integer k;
        for (int i = 0; i < 10; i++) {
            do {
                k = random.nextInt(100);
            } while (integerList.contains(k));
            integerList.add(k);
            System.out.println("成功添加整数：" + k);
        }
        System.out.println("-------------排序前--------------");
        for (Integer integer : integerList) {
            System.out.println("元素：" + integer);
        }
        Collections.sort(integerList);
        System.out.println("----------------排序后-------------------");
        for (Integer integer : integerList) {
            System.out.println("元素：" + integer);
        }
    }
    
    /**
     * 2.对String泛型的List进行排序；
     * 创建String泛型的List，添加三个乱序的String元素，
     * 调用sort方法，再次输出排序后的顺序
     */
    public void testSort2() {
        List<String> stringList = new ArrayList<String>();
        stringList.add("microsoft");
        stringList.add("google");
        stringList.add("lenovo");
        System.out.println("------------排序前-------------");
        for (String string : stringList) {
            System.out.println("元素：" + string);
        }
        Collections.sort(stringList);
        System.out.println("--------------排序后---------------");
        for (String string : stringList) {
            System.out.println("元素：" + string);
        }
    }
    
    /**
     * 3.对其他类型泛型的List进行排序，以Student为例。
     */
    public void testSort3() {
        List<Student> studentList = new ArrayList<Student>();
        Random random = new Random();
        studentList.add(new Student(random.nextInt(1000) + "", "Mike"));
        studentList.add(new Student(random.nextInt(1000) + "", "Angela"));
        studentList.add(new Student(random.nextInt(1000) + "", "Lucy"));
        studentList.add(new Student(10000 + "", "Beyonce"));
        System.out.println("--------------排序前---------------");
        for (Student student : studentList) {
            System.out.println("学生：" + student.id + ":" + student.name);
        }
        Collections.sort(studentList);
        System.out.println("----------------排序后------------------");
        for (Student student : studentList) {
            System.out.println("学生：" + student.id + ":" + student.name);
        }
        Collections.sort(studentList, new StudentComparator());
        System.out.println("----------------按照姓名排序后-----------------");
        for (Student student : studentList) {
            System.out.println("学生：" + student.id + ":" + student.name);
        }
    }
    
    /**
     * @param args
     */
    public static void main(String[] args) {
        CollectionsTest ct = new CollectionsTest();
//      ct.testSort1();
//      ct.testSort2();
        ct.testSort3();
    }

}

  • Comparable & Comparator



  • 实现学生序列排序


相关文章

网友评论

      本文标题：Java基础知识点（九）

      本文链接：https://www.haomeiwen.com/subject/lfdpgltx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|Java基础知识点（九）|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！