3.6 Java 中的集合框架（下）（常用工具类）

作者: 夏沫xx | 来源:发表于2016-10-15 14:34 被阅读46次

1、学生选课-判断List中课程是否存在

思考：
1、在课程序列中，如何判断是否包含某门课或者某几门课程？
2、如果课程序列包含某门课程，如何判断该课程的索引位置？
3、在学生映射表中，如何判断是否包含某个学生ID?
4、又该如何判断是否包含某个学生对象？
5、如果想把课程或者学生对象，按照课程名称或者学生姓名排序又该怎么办？按照ID排序呢？

在某序列中，如何判断是否包含某元素，list、set都是从collection接口中继承来的contains方法(还有判断多个元素的containsAll)

/**
     * 测试List的contains方法
     */
    public void testListContains() {
        // 取得备选课程序列的第0个元素
        Course course = coursesToSelect.get(0);
        // 打印输出coursesToSelected是否包含course对象
        System.out.println("取得课程：" + course.name);
        System.out.println("备选课程中是否包含课程：" + course.name + ", " + 
                coursesToSelect.contains(course));
        // 提示输入课程名称
        System.out.println("请输入课程名称：");
        String name = console.next();
        // 创建一个新的课程对象，ID和名称，与course对象完全一样
        Course course2 = new Course();
        course2.name = name;
        System.out.println("新创建课程：" + course2.name);
        System.out.println("备选课程中是否包含课程：" + course2.name + ", " +
                coursesToSelect.contains(course2));
        // 通过indexOf方法来取得某元素的索引位置
        if (coursesToSelect.contains(course2))
            System.out.println("课程：" + course2.name + "的索引位置为：" + 
                    coursesToSelect.indexOf(course2));
    }

public static void main(String[] args) {
        SetTest st = new SetTest();
        st.testAdd();
        st.testListContains();
}

Course.java
/*
     * 重写某个类的equals方法的模板
     * 
     */
    @Override
    public boolean equals(Object obj) {  //equals返回类型boolean
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (!(obj instanceof Course))
            return false;
        Course other = (Course) obj; //
        if (name == null) {
            if (other.name == null)
                return true;
            else 
                return false;
        }else{
            if (name.equals(other.name))
                return true;
            else
                return false;
        }
    }

2、学生选课-判断Set中课程是否存在

java中所有类都继承于object类，它定义了一个equals（Object obj)方法，这个方法需要一个参数,还定义了一个HashCode()方法，它返回的是哈希码

package student;

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

public class SetTest {
    
    public List<Course> coursesToSelect;
    private Scanner console;
    public Student student; 
    public SetTest() {
        coursesToSelect = new ArrayList<Course>();
        console = new Scanner(System.in);
    }
    
    /**
     * 用于往coursesToSelect中添加备选课程
     */
    public void testAdd() {
        //创建一个课程对象，并通过调用add方法，添加到备选课程List中
        Course cr1 = new Course("1" , "数据结构");
        coursesToSelect.add(cr1);
        Course temp = (Course) coursesToSelect.get(0);
        
        Course cr2 = new Course("2", "C语言");
        coursesToSelect.add(0, cr2);
        Course temp2 = (Course) coursesToSelect.get(0);
        
        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);
        
        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);
    
    }
/**
     * 通过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);
        }
    }
// 创建学生对象并选课
        public void createStudentAndSelectCours() {
            //创建一个学生对象
            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 : coursesToSelect) {
                    if(cr.id.equals(courseId)) {
                        student.courses.add(cr);
                        /**
                         * Set中，添加某个对象，无论添加多少次，
                         * 最终只会保留一个该对象（的引用），
                         * 并且，保留的是第一次添加的那一个
                         */
//                      student.courses.add(null);
//                      student.courses.add(cr);
                    }
                }
            }
    }
        /**
         * 测试Set的contains方法
         */
        public void testSetContains() {
            // 提示输入课程名称
            System.out.println("请输入学生已选的课程名称：");
            String name = console.next();
            // 创建一个新的课程对象，ID和名称，与course对象完全一样
            Course course2 = new Course();
            course2.name = name;
            System.out.println("新创建课程：" + course2.name);
            System.out.println("备选课程中是否包含课程：" + course2.name + ", " +
                    student.courses.contains(course2));
        }
    
    public static void main(String[] args) {
        SetTest st = new SetTest();
        st.testAdd();
        st.testForEach();
        st.createStudentAndSelectCours();
        st.testSetContains();
}

package student;

/*
 * 课程类
 */
public class Course {
    public String id;
    public String name;
    public Course(String id, String name) {
        this.id = id ;
        this.name = name;
    }
    
    public Course(){
        //否则ChildCourse会报错
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
}

3、学生选课-获取List中课程的位置

如果课程序列包含某门课程，如何判断该课程的索引位置

// 通过indexOf方法来取得某元素的索引位置
            if (coursesToSelect.contains(course2))
                System.out.println("课程：" + course2.name + "的索引位置为：" + 
                        coursesToSelect.indexOf(course2));

4、学生选课-判断Map中是否包含指定的key和value

在学生映射列表中，如何判断是否包含某个学生的ID
又该如何判断是否包含某个学生对象

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中，是否包含某个Key值或者某个Value值
     */
    public void testContainsKeyOrValue() {
        // 提示输入学生id
        System.out.println("请输入要查询的学生ID：");
        Scanner console = new Scanner(System.in);
        String id = console.next();
        // 在Map中，用containsKey()方法，来判断是否包含某个Key值
        System.out.println("您输入的学生ID为：" + id + "，在学生映射表中是否存在："
                + students.containsKey(id));
        if (students.containsKey(id))
            System.out.println("对应的学生为：" + students.get(id).name);
        // 提示输入学生姓名
        System.out.println("请输入要查询的学生姓名：");
        String name = console.next();
        // 用containsValue()方法，来判断是否包含某个Value值
        //这里需要重写student类的equals方法,否则映射表中不存在。。。
        if (students.containsValue(new Student(null,name)))
            System.out.println("在学生映射表中，确实包含学生：" + name);
        else
            System.out.println("在学生映射表中不存在该学生！");
    }
    


public static void main(String[] args) {
        MapTest mt = new MapTest();
        mt.testPut();
        mt.testKeySet();
        mt.testContainsKeyOrValue();
    }

5、应用Collections.sort()实现List排序

Arrays类--java.util.Arrays包含操作数组的各种静态方法
Collections工具类--java.util.Collections用来操作集合对象的工具类，也是Java集合框架的成员
Collections中定义了sort（）排序方法

package student;

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

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

    /*
     *  1、通过Collections.sort()方法，对Interger泛型的List进行排序
     *  创建一个Iteger类型的List,插入是个100以内的不重复的随机整数
     *  调用Collections.sort()方法排序
     *  练习：
     *  创建List<String>后，往其中添加10条随机字符串，每条字符串长度为10以内的随机整数
     *  每条字符串的每个字符都为随机生成的字符，字符可以重复，每条随机生成的字符串不可重复
     */
    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));//如果已经包含随机数k则需要继续生成一个随机数
            integerList.add(k);
            System.out.println("成功添加整数："+k);
        }
        System.out.println("----------排序前----------");
        //迭代integer中的每个元素
        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);
        }
    }
   
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        CollectionsTest ct=new CollectionsTest();
        ct.testSort1();
        ct.testSort2();
    }

}

 public void testSort3() { 
        List<String> stringList = new ArrayList<String>(); 
        for (int i = 0; i < 10; i++) { 
            StringBuilder tempString = new StringBuilder(); 
            Random random = new Random(); 
            Character[] ku = { '0', 'A', 'a' };
            do { 
                int k = (int) (Math.random() * 10); 
            // System.out.println(k); 
            for (int j = 0; j <= k; j++) { 
            int t = random.nextInt(3); 
            if (t == 0) { 
                tempString.append((char) (ku[t].charValue() + random .nextInt(10))); 
                } else {
                    tempString.append((char) (ku[t].charValue() + random .nextInt(26))); 
                    } 
            } 
            } while (stringList.contains(tempString.toString()));
            stringList.add(tempString.toString());
            } 
        System.out.println("-------------排序前-------------"); 
        for (String st : stringList) { 
            System.out.println("元素：" + st); 
            } 
        Collections.sort(stringList); 
        System.out.println("-------------排序后-------------");
        for (String st : stringList) { 
            System.out.println("元素：" + st); 
            } 
        }
        

public void testSort4(){ 
         List<String> stringList = new ArrayList<String>(); 
         for (int i = 0; i < 10; i++) { 
             StringBuilder tempString = new StringBuilder(); 
             Random random = new Random(); 
             do { 
                 int k = random.nextInt(10); 
                 for (int j = 0; j <= k; j++){ 
                     int t = random.nextInt(3); 
                     if (t == 0) { 
                         tempString.append((char)('0' + random.nextInt(10))); 
                         } else if (t == 1) { 
                             tempString.append((char)('A' + random.nextInt(26))); 
                         } else { 
                             tempString.append((char)('a' + random.nextInt(26))); 
                         } 
                     } 
                 } while(stringList.contains(tempString.toString())); 
             stringList.add(tempString.toString()); 
             } 
         System.out.println("--------排序前--------"); 
         for (String st : stringList) { 
             System.out.println("将要添加字符串：'" + st + "'"); 
             } 
         Collections.sort(stringList); 
         System.out.println("--------排序后--------"); 
         for (String st : stringList) { 
             System.out.println("元素：" + st); 
             } 
         }

6、学生选课-尝试对学生序列排序

7、Cpmparable&Comparator简介

8、学生选课-实现学生序列排序

java 集合框架--collection接口--collections工具类--Map接口--Comparator接口--Comparable接口

// 3、对其他类型泛型的List进行排序，以Student为例
     /*
      * comparable接口，给对象定义了默认的排序规则，comparator接口--临时比较规则，
      * comparable接口--可比较的
      * --实现该接口表示：这个类的实例可以比较大小，可以进行自然排序
      * --定义了默认的比较规则
      * --其实现类需实现compareTo()方法
      * --compareTo()方法返回正数表示的，负数表示小，0表示相等
      * comparator接口--比较工具
      * --用于定义临时比较规则，而不是默认比较规则
      * --其实现类需要实现compare()方法
      * --comparator和comparable都是Java集合框架的成员
      */
    public void testSort5(){
        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+"","Lake"));
        System.out.println("--------排序前--------");
         for (Student student: studentList) { 
             System.out.println("学生：" +student.id+":"+ student.name ); 
             } 
         //需要对Student类进行改造，使它实现comparable接口
         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 ); 
             } 
    }

student.java
public class Student implements Comparable<Student> {

...........
@Override
    public int compareTo(Student o) {
        // TODO Auto-generated method stub
        return this.id.compareTo(o.id);
    }
}

3.6 Java 中的集合框架（下）（常用工具类）

1、学生选课-判断List中课程是否存在

2、学生选课-判断Set中课程是否存在

3、学生选课-获取List中课程的位置

4、学生选课-判断Map中是否包含指定的key和value

5、应用Collections.sort()实现List排序

6、学生选课-尝试对学生序列排序

7、Cpmparable&Comparator简介

8、学生选课-实现学生序列排序

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

TECH_JAVA

JAVA集合