知识点范围：集合与IO流

一、选择题

1. 以下选项中关于Java集合的说法错误的是（ AC ）。（选择2项）

• • A：List接口和Set接口是Collections接口有两个子接口
• • B：List接口中存放的元素具有有序，不唯一的特点
• • C：Set接口中存放的元素具有无序，不唯一的特点
• • D：Map接口存放的是映射信息，每个元素都是一个键值对

解析：

• A选项：Collection接口、Collections集合工具类，两者具有本质上的不同，错误。
• B选项：List集合特点：有序、不唯一、允许有null值，正确
• C选项：Set集合特点：无序、唯一、最多允许有一个null值，错误
• D选项：Map集合特点：Key-Value键值对（Entry）、无序、Key唯一且最多允许有一个null值、Value不唯一且允许有null值，正确

2. 如下Java代码，输出的运行结果是（ A ）。（选择1项）

public class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("str1");
        list.add(2, "str2");
        String s = list.get(1);
        System.out.println(s);
    }
}

• • A：运行时出现异常
• • B：输出str1
• • C：输出str2
• • D：编译时出现异常

解析：
add(int index, Object obj)方法指的是在指定位置添加元素。执行list.add("str1");后，集合中元素的size是1，但是执行list.add(2, "str2");需要向下标为2的位置添加数据，此时集合最大下标值是1，所以会抛出IndexOutOfBoundsException。

3. 以下Java代码的作用是将一个数组的内容存入集合，然后判断集合中是否有指定的元素存在，其中共有（ D ）处错误。（选择1项）

public class Test {
    public int getIndexofArray(float[] f) {
        int rtn = -1;
        float objf = 3.4;
        List list = null;

        for (int i = 0; i < f.size(); i++) {
            list.add(f[i]);
        }

        for (int i = 0; i < list.size(); i++) {
            float tmp = (float) list.get(i);

            if (objf == tmp) {
                rtn = i;
            }
        }

        return rtn;
    }
}

• • A：0
• • B：1
• • C：2
• • D：3

解析：

1. float objf = 3.4;float类型的小数后面未加F或f
2. List list = null;List集合只有声明，没有实例化
3. f.size();数组只有length属性，没有size()方法

4. 分析如下Java代码，编译运行后将输出（ B ）。（选择1项）

public class Test {
    public Test() {}

    static void print(List<Integer> al) {
        al.add(2);
        al = new ArrayList<Integer>();
        al.add(3);
        al.add(4);
    }

    public static void main(String[] args) {
        List<Integer> al = new ArrayList<Integer>();
        al.add(1);
        print(al);
        System.out.println(al.get(1));
    }
}

• • A：1
• • B：2
• • C：3
• • D：4

解析：
print()方法中的形参是实参的一个副本，二者的值为同一个引用地址，指向同一个对象，直到执行了al = new ArrayList<Integer>();，此后形参与实参指向了不同的对象，形参的任何操作也就无法影响实参。

5. 在Java中，下列集合类型可以存储无序、不重复的数据的是（ D ）。（选择1项）

• • A：ArrayList
• • B：LinkedList
• • C：TreeSet
• • D：HashSet

解析：

• ArrayList：有序，不唯一，允许有null值
• LinkedList：有序，不唯一，允许有null值
• TreeSet：有序，唯一，不允许有null值
• HashSet：无序，唯一，最多允许有一个null值

6. 在Java中，下列关于读写文件的描述错误的是（ B ）。（选择1项）

• • A：Reader类的read()方法用来从源中读取一个字符的数据
• • B：Reader类的read(int n)方法用来从源中读取一个字符的数据
• • C：Writer类的write(int n)方法用来向输出流写入单个字符
• • D：Writer类的write(String str)方法用来向输出流写入一个字符串

解析：
Reader类没有read(int n)方法。

7. 分析如下Java代码，共有（ C ）处错误。（选择1项）

public class Test {
    public static void main(String[] args) {
        String str = "文件写入练习";
        FileWriter fw = null; // 1

        try {
            fw = new FileWriter("c:\mytext.txt"); // 2
            fw.writerToEnd(str); // 3
        } catch (IOException e) { // 4
            e.printStackTrace();
        } finally {
            // 此处省略关闭流
        }
    }
}

• • A：0
• • B：1
• • C：2
• • D：3

解析：

• fw = new FileWriter("c:\mytext.txt");：\为转义字符，若想表达\的含义，需使用\\或/
• fw.writerToEnd(str);：FileWriter类没有writerToEnd(str)方法

8. 分析如下Java代码，有标注的四行代码中，有错误的是第（ D ）处。（选择1项）

public class Test {
    public static void main(String[] args) {
        String str = "Hello World";
        FileWriter fw = null;
        try {
            fw = new FileWriter("c:\\hello.txt"); // 1
            fw.write(str); // 2
        } catch (IOException e) {
            e.printStackTrace(); // 3
        } finally {
            fw.close(); // 4
        }
    }
}

• • A：1
• • B：2
• • C：3
• • D：4

解析：
fw.close();没有处理异常。

9. 以下选项中关于如下代码的说法正确的是（ AD ）。（选择2项）

public class Test {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("d:/bjsxt1.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("d:/bjsxt2.txt"));
        String str = br.readLine();

        while (str != null) {
            bw.write(str);
            bw.newLine();
            str = br.readLine();
        }

        br.close();
        bw.close();
    }
}

• • A：该类使用字符流实现了文件复制，将d:/bjsxt1.txt复制为d:/bjsxt2.txt
• • B：FileReader和FileWriter是处理流，直接从文件读写数据
• • C：BufferedReader和BufferedWriter是节点流，提供缓冲区功能，提高读写效率
• • D：readLine()可以读取一行数据，返回值是字符串类型，简化了操作

解析：
FileReader和FileWriter属于节点流，BufferedReader和BufferedWriter属于处理流。

10. InputStreamReader是转换流，可以将字节流转换成字符流，是字符流与字节流之间的桥梁。它的实现使用的设计模式是（ C ）。（选择1项）

• • A：工厂模式
• • B：装饰模式
• • C：适配器模式
• • D：代理模式

解析：
Java IO流中用到的最多的设计模式就是装饰模式。

二、简答题

1. 说明数组和集合的区别。

   
   image.png
2. 简述List、Set、Collection、Map的区别和联系。
   1. List和Set是Collection接口的两个子接口
   2. Collection接口存储一组无序、不唯一的对象
   3. List接口存储有序、不唯一的对象
   4. Set接口存储无序、唯一的对象
   5. Map接口存储键值对对象，其中key唯一，最多可以有一个null值，value不唯一，可以有多个null值
3. 简述哈希表的原理。
   1. 哈希表对数据的操作速度特别快。
   2. HashMap、HashSet这些集合采用的都是哈希表结构，需要用到哈希码，哈希码是一个整数值。
   3. 系统类已经覆盖了hashCode方法，自定义类如果要放入hash类集合，一般会重写hashCode方法和equals方法，如果不重写，调用的是Object类的hashCode方法和equals方法，而Object类的hashCode方法返回的是对象的地址，equals方法会默认调用==判断对象的地址是否相同。
   4. 向哈希表中添加数据的原理：当向集合中增加对象时，首先集合会计算要增加对象的哈希码，并根据该哈希码得到一个位置存放当前对象，如果该位置没有对象存在的话，那么集合认为该对象在集合中不存在，直接放入，如果该位置有对象存在的话，会调用equals方法比较两个对象是否相等，如果相等，则集合认为集合中已经存在该对象，就不会再放入该对象，如果不相等，则集合就会再进行一次散列，并将该对象放到散列后计算出的新地址中。
   5. 在哈希表中判断是否已包含某个元素需要使用到hashCode方法和equals方法。hashCode方法决定元素在表中的存储位置，equals方法判断是否存在相同的元素。
4. 说明节点流和处理流的区别与联系。
   节点流是连接两个节点的最基本的流，处理流是处理节点流、增强其性能和可操作性的流。
   例如：
   FileInputStream/FileOutputStream、FileReader/FileWriter，对文件进行读写。
   BufferedInputStream/BufferedOutputStream、BufferedReade/ BufferedWriter，增加缓冲功能，避免频繁在硬盘上进行读写操作。
   关闭时可以只关闭处理流，不用手动关闭节点流，处理流关闭时，会自动调用其处理的节点流的关闭方法。如果先关闭节点流再关闭处理流，就会抛出IOException。
5. 列举常用的字节输入流和字节输出流并说明其特点，至少5对。
   1. FileInputStream和FileOutputStream：节点流，以文件为数据源和目的地
   2. BufferedInputStream和BufferedOutputStream：处理流，提供了缓冲功能，避免频繁在硬盘上进行读写操作，提高读写效率
   3. DataInputStream和DataOutputStream：处理流，提供了方便读写基本数据类型和String类型数据的方法
   4. ObjectInputStream和ObjectOutputStream：处理流，提供了方便读写基本数据类型和引用数据类型数据的方法
   5. ByteArrayInputStream和ByteArrayOutputStream：节点流，以字节数组为数据源和目的地

三、编码题

1. 使用List和Map存放多个图书信息，遍历并输出。其中商品属性包括：编号、名称、单价、出版社，并使用商品编号作为Map中的key。

• 代码：

package leif;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class Test {
    public static void main(String args[]) {
        Book book1 = new Book(1, "Java从入门到精通", 20, "清华大学出版社");
        Book book2 = new Book(2, "Java编程思想", 80, "清华大学出版社");
        Book book3 = new Book(3, "Java设计模式", 50, "清华大学出版社");
        List<Book> bookList = new ArrayList<Book>();
        bookList.add(book1);
        bookList.add(book2);
        bookList.add(book3);

        for (Book book : bookList) {
            System.out.println(book);
        }

        Map<Integer, Book> iBookMap = new HashMap<Integer, Book>();
        iBookMap.put(book1.getId(), book1);
        iBookMap.put(book2.getId(), book2);
        iBookMap.put(book3.getId(), book3);

        for (Entry<Integer, Book> iBookEntry : iBookMap.entrySet()) {
            System.out.println(iBookEntry.getKey() + " " + iBookEntry.getValue());
        }
    }
}

class Book {
    private int id;
    private String name;
    private double price;
    private String press;

    public Book(int id, String name, double price, String press) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.press = press;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getPress() {
        return press;
    }

    public void setPress(String press) {
        this.press = press;
    }

    @Override
    public String toString() {
        return "Book [id=" + id + ", name=" + name + ", price=" + price + ", press=" + press + "]";
    }
}

• 结果截图：

  
  image.png

2. 使用HashSet和TreeSet存储多个商品信息，遍历并输出。其中商品属性包括编号、名称、单价、出版社，要求向其中添加多个相同的商品，验证集合中元素的唯一性。

• 代码：

package leif;

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

public class Test {
    public static void main(String args[]) {
        Book book1 = new Book(1, "Java从入门到精通", 20, "清华大学出版社");
        Book book2 = new Book(2, "Java编程思想", 80, "清华大学出版社");
        Book book3 = new Book(3, "Java设计模式", 50, "清华大学出版社");
        Book book4 = new Book(1, "Java从入门到精通", 20, "清华大学出版社");
        Book book5 = new Book(2, "Java编程思想", 80, "清华大学出版社");
        Book book6 = new Book(3, "Java设计模式", 50, "清华大学出版社");
        Set<Book> bookSet = new HashSet<Book>();
        bookSet.add(book1);
        bookSet.add(book2);
        bookSet.add(book3);
        bookSet.add(book4);
        bookSet.add(book5);
        bookSet.add(book6);

        for (Book book : bookSet) {
            System.out.println(book);
        }

        TreeSet<Book> bookTreeSet = new TreeSet<Book>();
        bookTreeSet.add(book1);
        bookTreeSet.add(book2);
        bookTreeSet.add(book3);
        bookTreeSet.add(book4);
        bookTreeSet.add(book5);
        bookTreeSet.add(book6);

        for (Book book : bookTreeSet) {
            System.out.println(book);
        }
    }
}

class Book implements Comparable<Book> {
    private int id;
    private String name;
    private double price;
    private String press;

    public Book(int id, String name, double price, String press) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.press = press;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getPress() {
        return press;
    }

    public void setPress(String press) {
        this.press = press;
    }

    @Override
    public String toString() {
        return "Book [id=" + id + ", name=" + name + ", price=" + price + ", press=" + press + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + ((press == null) ? 0 : press.hashCode());
        long temp;
        temp = Double.doubleToLongBits(price);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (obj == null) {
            return false;
        }

        if (getClass() != obj.getClass()) {
            return false;
        }

        Book other = (Book)obj;

        if (id != other.id) {
            return false;
        }

        if (name == null) {
            if (other.name != null) {
                return false;
            }
        } else if (!name.equals(other.name)) {
            return false;
        }

        if (press == null) {
            if (other.press != null) {
                return false;
            }
        } else if (!press.equals(other.press)) {
            return false;
        }

        if (Double.doubleToLongBits(price) != Double.doubleToLongBits(other.price)) {
            return false;
        }

        return true;
    }

    @Override
    public int compareTo(Book another) {
        int i = id - another.getId();

        if (i == 0) {
            return name.compareTo(another.getName());
        } else {
            return i;
        }
    }
}

• 结果截图：

  
  image.png

3. 实现List和Map数据的转换。具体要求如下：
   1. 定义方法public void listToMap() {}，将List中的Student元素封装到Map中
      1. 使用构造方法Student(int id, String name, int age, String sex)创建多个学生信息并存入List
      2. 遍历List，输出每个Student信息
      3. 将List中的数据放入Map中，将Student的id属性作为key、Student对象作为value
      4. 遍历Map，输出每个Entry的key和value
   2. 定义方法public void mapToList() {}，将Map中的Student映射信息封装到List中
      1. 创建实体类StudentEntry，可以存储Map中每个Entry的信息
      2. 使用构造方法Student(int id, String name, int age, String sex)创建多个学生信息，并将Student的id属性作为key、Student对象作为value，存入Map
      3. 创建元素类型为StudentEntry的List对象
      4. 将Map中的每个Entry存入List
   3. 通过分数对学生进行排序

• 代码：

package sxt;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class Test {
    public static void main(String args[]) {
        Util.listToMap();
        Util.mapToList();
    }
}

class Student {
    private int id;
    private String name;
    private int age;
    private String sex;
    private double score;

    public Student(int id, String name, int age, String sex, double score) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.score = score;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", age=" + age + ", sex=" + sex + ", score=" + score + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        long temp;
        temp = Double.doubleToLongBits(score);
        result = prime * result + (int)(temp ^ (temp >>> 32));
        result = prime * result + ((sex == null) ? 0 : sex.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (obj == null) {
            return false;
        }

        if (getClass() != obj.getClass()) {
            return false;
        }

        Student other = (Student)obj;

        if (age != other.age) {
            return false;
        }

        if (id != other.id) {
            return false;
        }

        if (name == null) {
            if (other.name != null) {
                return false;
            }
        } else if (!name.equals(other.name)) {
            return false;
        }

        if (Double.doubleToLongBits(score) != Double.doubleToLongBits(other.score)) {
            return false;
        }

        if (sex == null) {
            if (other.sex != null) {
                return false;
            }
        } else if (!sex.equals(other.sex)) {
            return false;
        }

        return true;
    }
}

class Util {
    private Util() {}

    public static void listToMap() {
        List<Student> studentList = new ArrayList<Student>();
        studentList.add(new Student(1, "小明", 18, "男", 90));
        studentList.add(new Student(2, "小红", 17, "女", 100));
        studentList.add(new Student(3, "小刚", 20, "男", 80));
        Map<Integer, Student> iStudentMap = new HashMap<Integer, Student>();

        for (Student student : studentList) {
            System.out.println(student);
            iStudentMap.put(student.getId(), student);
        }

        for (Entry<Integer, Student> iStudentEntry : iStudentMap.entrySet()) {
            System.out.println(iStudentEntry.getKey() + " " + iStudentEntry.getValue());
        }
    }

    public static void mapToList() {
        class StudentEntry<T> {
            private Entry<Integer, Student> iStudentEntry;

            public StudentEntry(Entry<Integer, Student> iStudentEntry) {
                this.iStudentEntry = iStudentEntry;
            }

            public Entry<Integer, Student> getiStudentEntry() {
                return iStudentEntry;
            }

            @Override
            public String toString() {
                return "StudentEntry [iStudentEntry=" + iStudentEntry + "]";
            }
        }

        Student student1 = new Student(1, "小明", 18, "男", 90);
        Student student2 = new Student(2, "小红", 17, "女", 100);
        Student student3 = new Student(3, "小刚", 20, "男", 80);
        Map<Integer, Student> iStudentMap = new HashMap<Integer, Student>();
        iStudentMap.put(student1.getId(), student1);
        iStudentMap.put(student2.getId(), student2);
        iStudentMap.put(student3.getId(), student3);
        List<StudentEntry<Entry<Integer, Student>>> studentEntryList = new ArrayList<StudentEntry<Entry<Integer, Student>>>();

        for (Entry<Integer, Student> iStudentEntry : iStudentMap.entrySet()) {
            studentEntryList.add(new StudentEntry<Entry<Integer, Student>>(iStudentEntry));
        }

        Collections.sort(studentEntryList, new Comparator<StudentEntry<Entry<Integer, Student>>>() {
            @Override
            public int compare(StudentEntry<Entry<Integer, Student>> studentEntry1, StudentEntry<Entry<Integer, Student>> studentEntry2) {
                int i = (int)(studentEntry1.getiStudentEntry().getValue().getScore() - studentEntry2.getiStudentEntry().getValue().getScore());

                if (i == 0) {
                    return String.valueOf(studentEntry1.getiStudentEntry().getValue().getName()).compareTo(String.valueOf(studentEntry2.getiStudentEntry().getValue().getName()));
                } else {
                    return i;
                }
            }
        });

        for (StudentEntry<Entry<Integer, Student>> studentEntry : studentEntryList) {
            System.out.println(studentEntry);
        }
    }
}

• 结果截图：

  
  image.png

4. 复制文件夹d:\sxtjava下面所有文件和子文件夹内容到d:\sxtjava2。

• 代码：

package sxt;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test {
    public static void main(String args[]) throws FileNotFoundException {
        copy("D:\\sxtjava", "D:\\sxtjava2");
    }

    public static void copy(String oldPath, String newPath) throws FileNotFoundException {
        File oldFile = new File(oldPath);

        if (!oldFile.exists()) {
            throw new FileNotFoundException("路径错误！");
        }

        for (File file : oldFile.listFiles()) {
            File newFile = new File(file.getPath().replace(oldPath, newPath));

            if (file.isDirectory()) {
                if (!newFile.exists()) {
                    newFile.mkdirs();
                }

                copy(file.getPath(), file.getPath().replace(oldPath, newPath));
            } else {
                FileInputStream fileInputStream = null;
                BufferedInputStream bufferedInputStream = null;
                FileOutputStream fileOutputStream = null;
                BufferedOutputStream bufferedOutputStream = null;

                try {
                    fileInputStream = new FileInputStream(file);
                    bufferedInputStream = new BufferedInputStream(fileInputStream);
                    fileOutputStream = new FileOutputStream(newFile);
                    bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
                    byte[] bs = new byte[1024];
                    int length = -1;

                    while ((length = bufferedInputStream.read(bs)) != -1) {
                        bufferedOutputStream.write(bs, 0, length);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    if (bufferedOutputStream != null) {
                        try {
                            bufferedOutputStream.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }

                    if (fileOutputStream != null) {
                        try {
                            fileOutputStream.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }

                    if (bufferedInputStream != null) {
                        try {
                            bufferedInputStream.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }

                    if (fileInputStream != null) {
                        try {
                            fileInputStream.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

• 结果截图：

  
  image.png
  image.png

四、程序题

• 项目结构+README：

  
  image.png
  image.png
  image.png
  image.png
  image.png
• 代码：

package dao;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import entity.Commodity;

public class CommodityDao {
    private static final List<Commodity> COMMODITY_LIST;
    private static final Set<Integer> COMMODITY_ID_SET;

    static {
        COMMODITY_LIST = new ArrayList<Commodity>();
        COMMODITY_ID_SET = new HashSet<Integer>();
    }

    private CommodityDao() {}

    private static volatile CommodityDao commodityDao = null;

    public static CommodityDao getInstance() {
        if (commodityDao == null) {
            synchronized (CommodityDao.class) {
                if (commodityDao == null) {
                    commodityDao = new CommodityDao();
                }
            }
        }

        return commodityDao;
    }

    public static List<Commodity> getCommodityList() {
        return COMMODITY_LIST;
    }

    public static Set<Integer> getCommodityIdSet() {
        return COMMODITY_ID_SET;
    }

    public static void addToCommodityList(Commodity commodity) {
        COMMODITY_LIST.add(commodity);
        COMMODITY_ID_SET.add(commodity.getId());
    }
}

package dao;

import java.util.HashMap;
import java.util.Map;

import entity.Commodity;

public class ShoppingCartDao {
    private static final Map<Commodity, Integer> COMMODITY_I_MAP;

    static {
        COMMODITY_I_MAP = new HashMap<Commodity, Integer>();
    }

    private ShoppingCartDao() {}

    private static volatile ShoppingCartDao shoppingCartDao = null;

    public static ShoppingCartDao getInstance() {
        if (shoppingCartDao == null) {
            synchronized (ShoppingCartDao.class) {
                if (shoppingCartDao == null) {
                    shoppingCartDao = new ShoppingCartDao();
                }
            }
        }

        return shoppingCartDao;
    }

    public static Map<Commodity, Integer> getCommodityIMap() {
        return COMMODITY_I_MAP;
    }

    public static void addToCommodityIMap(Commodity commodity, int quantity) {
        COMMODITY_I_MAP.put(commodity, quantity);
    }
}

package entity;

public class Commodity {
    private int id;
    private String name;
    private double price;
    private String color;
    private int size;
    private int stock;

    public Commodity(int id, String name, double price, String color, int size, int stock) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.color = color;
        this.size = size;
        this.stock = stock;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public int getStock() {
        return stock;
    }

    public void setStock(int stock) {
        this.stock = stock;
    }

    @Override
    public String toString() {
        return id + "\t" + name + "\t" + price + "\t" + color + "\t" + size + "\t" + stock;
    }
}

package exception;

public class CommodityException extends Exception {
    private static final long serialVersionUID = 1L;
    private String commodityExceptionMessage;

    public CommodityException(String commodityExceptionMessage) {
        this.commodityExceptionMessage = commodityExceptionMessage;
    }

    public String getCommodityExceptionMessage() {
        return commodityExceptionMessage;
    }

    public void setCommodityExceptionMessage(String commodityExceptionMessage) {
        this.commodityExceptionMessage = commodityExceptionMessage;
    }
}

package exception;

public class ShoppingCartException extends Exception {
    private static final long serialVersionUID = 1L;
    private String shoppingCartExceptionMessage;

    public ShoppingCartException(String shoppingCartExceptionMessage) {
        this.shoppingCartExceptionMessage = shoppingCartExceptionMessage;
    }

    public String getShoppingCartExceptionMessage() {
        return shoppingCartExceptionMessage;
    }

    public void setShoppingCartExceptionMessage(String shoppingCartExceptionMessage) {
        this.shoppingCartExceptionMessage = shoppingCartExceptionMessage;
    }
}

package service.impl;

import java.util.List;

import dao.CommodityDao;
import entity.Commodity;
import exception.CommodityException;
import service.CommodityService;

public class CommodityServiceImpl implements CommodityService {
    private CommodityServiceImpl() {}

    private static volatile CommodityServiceImpl commodityServiceImpl = null;

    public static CommodityServiceImpl getInstance() {
        if (commodityServiceImpl == null) {
            synchronized (CommodityServiceImpl.class) {
                if (commodityServiceImpl == null) {
                    commodityServiceImpl = new CommodityServiceImpl();
                }
            }
        }

        return commodityServiceImpl;
    }

    @Override
    public void create(Commodity commodity) throws CommodityException {
        if (CommodityDao.getCommodityIdSet().contains(commodity.getId())) {
            throw new CommodityException("该编号的商品已存在！");
        }

        CommodityDao.addToCommodityList(commodity);
    }

    @Override
    public List<Commodity> findAll() {
        return CommodityDao.getCommodityList();
    }

    @Override
    public Commodity findById(int id) throws CommodityException {
        if (!CommodityDao.getCommodityIdSet().contains(id)) {
            throw new CommodityException("该编号的商品不存在！");
        }

        for (Commodity commodity : CommodityDao.getCommodityList()) {
            if (commodity.getId() == id) {
                return commodity;
            }
        }

        return null;
    }
}

package service.impl;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Map;
import java.util.Map.Entry;

import dao.ShoppingCartDao;
import entity.Commodity;
import exception.ShoppingCartException;
import service.ShoppingCartService;

public class ShoppingCartServiceImpl implements ShoppingCartService {
    private ShoppingCartServiceImpl() {}

    private static volatile ShoppingCartServiceImpl shoppingCartServiceImpl = null;

    public static ShoppingCartServiceImpl getInstance() {
        if (shoppingCartServiceImpl == null) {
            synchronized (ShoppingCartServiceImpl.class) {
                if (shoppingCartServiceImpl == null) {
                    shoppingCartServiceImpl = new ShoppingCartServiceImpl();
                }
            }
        }

        return shoppingCartServiceImpl;
    }

    @Override
    public void create(Commodity commodity, int quantity) throws ShoppingCartException {
        if (commodity.getStock() < quantity) {
            throw new ShoppingCartException("该商品库存不足！");
        }

        ShoppingCartDao.addToCommodityIMap(commodity, quantity);
        commodity.setStock(commodity.getStock() - quantity);
    }

    @Override
    public Map<Commodity, Integer> findAll() {
        return ShoppingCartDao.getCommodityIMap();
    }

    @Override
    public void saveToFile() {
        FileWriter fileWriter = null;
        BufferedWriter bufferedWriter = null;

        try {
            fileWriter = new FileWriter(new File("C:\\Users\\Administrator\\Desktop\\ShoppingCart.txt"));
            bufferedWriter = new BufferedWriter(fileWriter);
            bufferedWriter.write("编号\t名称\t价格\t数量\t小计");
            bufferedWriter.newLine();
            int total = 0;

            for (Entry<Commodity, Integer> commodityIEntry : findAll().entrySet()) {
                Commodity commodity = commodityIEntry.getKey();
                int quantity = commodityIEntry.getValue();
                double subtotal = commodity.getPrice() * quantity;
                bufferedWriter.write(commodity.getId() + "\t" + commodity.getName() + "\t" + commodity.getPrice() + "\t" + quantity + "\t" + subtotal);
                bufferedWriter.newLine();
                total += subtotal;
            }

            bufferedWriter.write("总计：" + total);
            System.out.println("保存成功！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bufferedWriter != null) {
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (fileWriter != null) {
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

package service;

import java.util.List;

import entity.Commodity;
import exception.CommodityException;

public interface CommodityService {
    public abstract void create(Commodity commodity) throws CommodityException;

    public abstract List<Commodity> findAll();

    public abstract Commodity findById(int id) throws CommodityException;
}

package service;

import java.util.Map;

import entity.Commodity;
import exception.ShoppingCartException;

public interface ShoppingCartService {
    public abstract void create(Commodity commodity, int quantity) throws ShoppingCartException;

    public abstract Map<Commodity, Integer> findAll();

    public abstract void saveToFile();
}

package test;

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

import entity.Commodity;
import exception.CommodityException;
import exception.ShoppingCartException;
import service.CommodityService;
import service.ShoppingCartService;
import service.impl.CommodityServiceImpl;
import service.impl.ShoppingCartServiceImpl;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        CommodityService commodityService = CommodityServiceImpl.getInstance();
        ShoppingCartService shoppingCartService = ShoppingCartServiceImpl.getInstance();

        while (true) {
            System.out.println("----------欢迎进入京东商城----------");
            System.out.println("1. 添加商品");
            System.out.println("2. 查看所有商品");
            System.out.println("3. 查看指定编号商品");
            System.out.println("4. 添加到购物车");
            System.out.println("5. 显示购物车");
            System.out.println("6. 保存购物车");
            System.out.println("7. 退出");
            System.out.println("----------------------------------------");
            System.out.print("请选择菜单：");
            int flag = scanner.nextInt();

            switch (flag) {
                case 1:
                    System.out.println("请输入商品编号");
                    int id1 = scanner.nextInt();
                    System.out.println("请输入商品名称");
                    scanner.nextLine();
                    String name1 = scanner.nextLine();
                    System.out.println("请输入商品价格");
                    double price1 = scanner.nextDouble();
                    System.out.println("请输入商品颜色");
                    String color1 = scanner.next();
                    System.out.println("请输入商品尺寸");
                    int size1 = scanner.nextInt();
                    System.out.println("请输入商品库存");
                    int stock1 = scanner.nextInt();

                    try {
                        commodityService.create(new Commodity(id1, name1, price1, color1, size1, stock1));
                    } catch (CommodityException commodityException) {
                        System.out.println(commodityException.getCommodityExceptionMessage());
                    }

                    break;
                case 2:
                    System.out.println("编号\t名称\t价格\t颜色\t尺寸\t库存");

                    for (Commodity commodity : commodityService.findAll()) {
                        System.out.println(commodity);
                    }

                    break;
                case 3:
                    System.out.println("请输入要查询的商品编号");
                    int id3 = scanner.nextInt();
                    System.out.println("编号\t名称\t价格\t颜色\t尺寸\t库存");

                    try {
                        System.out.println(commodityService.findById(id3));
                    } catch (CommodityException commodityException) {
                        System.out.println(commodityException.getCommodityExceptionMessage());
                    }

                    break;
                case 4:
                    System.out.println("请输入要购买的商品的编号");
                    int id4 = scanner.nextInt();
                    System.out.println("请输入要购买的商品的数量");
                    int quantity4 = scanner.nextInt();

                    try {
                        shoppingCartService.create(commodityService.findById(id4), quantity4);
                    } catch (CommodityException commodityException) {
                        System.out.println(commodityException.getCommodityExceptionMessage());
                    } catch (ShoppingCartException shoppingCartException) {
                        System.out.println(shoppingCartException.getShoppingCartExceptionMessage());
                    }

                    break;
                case 5:
                    System.out.println("编号\t名称\t价格\t数量\t小计");
                    double total5 = 0;

                    for (Entry<Commodity, Integer> commodityIEntry : shoppingCartService.findAll().entrySet()) {
                        Commodity commodity5 = commodityIEntry.getKey();
                        int quantity5 = commodityIEntry.getValue();
                        double subtotal5 = commodity5.getPrice() * quantity5;
                        System.out.println(commodity5.getId() + "\t" + commodity5.getName() + "\t" + commodity5.getPrice() + "\t" + quantity5 + "\t" + subtotal5);
                        total5 += subtotal5;
                    }

                    System.out.println("总计：" + total5);
                    break;
                case 6:
                    shoppingCartService.saveToFile();
                    break;
                case 7:
                    scanner.close();
                    System.exit(0);
                default:
                    System.out.println("输入错误！");
                    break;
            }
        }
    }
}

• 结果截图：

  
  image.png
  image.png
  image.png
  image.png
  image.png
  image.png
  image.png
  image.png
  image.png
  image.png