利用Map集合写一个通讯录系统

通讯录

这是一个模拟手机通讯录的项目.没有页面, 功能通过控制台展示.

需求说明

通讯录项目要实现: 菜单打印, 添加联系人, 查看全部联系人, 根据分组查看联系人, 根据姓名关键字查看联 系人, 根据电话关键字查看联系人, 修改联系人, 删除联系人, 退出等.

功能展示

 (1) 菜单打印

打印通讯录项目的所有功能菜单. 程序一启动就需要打印菜单, 等待用户选择. 用户执行完某一菜单功能 之后, 需要重新打印菜单,等待用户继续操作.

 

 (2) 添加联系人

当用户选择菜单1的时候, 进入添加联系人功能. 分别提示用户输入姓名, 手机号. 如果姓名和手机号无误, 创建联系人对象, 添加到通讯录中, 并提示添加成功.

 多加几个联系人,以便后续操作,就不一一截图了

 (3) 查看全部联系人

当用户选择菜单2的时候, 进入查看全部联系人功能. 需要打印出通讯录中全部联系人, 打印顺序要按联系 人分组的ASCII顺序打印.如下图所示:

 (4) 根据分组名查看联系人

当用户选择菜单3的时候, 进入根据分组查看联系人功能. 输入分组的名称(可以输入大写分组名, 也可以输 入小写分组名), 查看本分组的所有联系人, 如果本组没有联系人, 打印"x分组尚无联系人". 如果分组有联 系人, 打印出分组所有的联系人, 如下图所示:

(5) 根据姓名关键字查看联系人

当用户选择菜单4的时候, 进入根据姓名关键字查看联系人功能. 先提示用户输入姓名关键字(可以是姓名 中的某些字, 或者全名), 打印通讯录中所有匹配的结果. 如果没有匹配的联系人, 打印"没有找到符合的联系人", 如果有多个匹配结果, 需要全都打印出来.

 (6) 根据电话关键字查看联系人

当用户选择菜单5的时候, 进入根据电话关键字查看联系人功能. 先提示用户输入电话关键字(可以是电话 中的某些数字, 或者完整电话号码), 打印通讯录中所有匹配的结果. 如果没有匹配的联系人, 打印"没有找 到符合的联系人", 如果有多个匹配结果, 需要全都打印出来

 

 (7) 修改联系人

当用户选择菜单6的时候, 进入根据修改联系人功能. 先提示用户输入要修改的联系人的全名, 如果存在这 个人, 再提示输入新的姓名, 新的手机号码, 根据信息封装联系人对象, 更新到通讯录中, 如果联系人不存 在, 则提示用户"要修改的联系人不存在".

 (8) 删除联系人

当用户选择菜单7的时候, 进入根据删除联系人功能. 提示用户输入要删除的联系人的全名, 如果存在这个 人, 就删除, 如果不存在这个联系人, 提示"通讯录中没有这个人."删除之后再查看联系人信息,看看有没有删除成功.

 (9) 退出

当用户选择菜单8的时候, 进入根据退出功能. 退出之前进行一个确认操作, 如果用户输入了Y或者y才退出.

 功能展示结束,下面是代码

代码:

 再导一个jar包用来获取联系人姓氏首字母:

导入一个jar包,下面的PinYin4j类需要用到这个jar包,放在下面的连接里了.

链接: https://pan.baidu.com/s/18cifKQPQfyk-xIaMjrloHw?pwd=1475 提取码: 1475 

总体预览:

先建一个Contact类:

import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;

public class Contact {
    private String name;
    private String phone;
    private String groupName;
    static Pinyin4j py=new Pinyin4j();

    @Override
    public String toString() {
        return "\t"+name+"("+phone+")";

    }
    public Contact() {
    }

    public Contact(String name, String phone){
        this.name = name;
        this.phone = phone;
        try {
            this.groupName = py.toPinYinUppercaseInitials(this.name);

        } catch (BadHanyuPinyinOutputFormatCombination e) {
            throw new RuntimeException(e);
        }
    }



    public String getName() {
        return name;

    }

    public void setName(String name) {
        this.name = name;
        try {
            this.groupName=py.toPinYinUppercaseInitials(this.name);
        } catch (BadHanyuPinyinOutputFormatCombination e) {
            throw new RuntimeException(e);
        }
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;

    }

    public String getGroupName() {
        return groupName;
    }

    public void setGroupName(String groupName) {
        this.groupName = groupName;
    }
}

建一个AddressBook类:

import day12.Home.Gun;

import java.rmi.MarshalledObject;
import java.util.*;

public class AddressBook {

    Scanner scanner=new Scanner(System.in);


    Map<String,List<Contact>> map=new TreeMap<>();
    //添加联系人

    public void addContact(){
        System.out.println("请输入联系人的姓名：");
        String name=scanner.next();
//        String reg1="^[\u4e00-\u9fa5]$";
//        boolean b1 = name.matches(reg1);
        System.out.println("请输入手机号码：");
        String phone=scanner.next();
//        String reg2="^(13|15|17|18|19)\\d{9}$";
//        boolean b2 = phone.matches(reg2);
        Contact c=new Contact(name,phone);
        String groupName = c.getGroupName();
        List<Contact> list=new ArrayList();

        if (map.containsKey(groupName)){ //判断map集合里的key有没有groupName
            List<Contact> contacts = map.get(groupName);//获得value值（就是List<Contact>）
            //有key为groupName的集合，只需要向list集合中添加对象就行

            boolean b = contacts.add(c);
            if (b){
                System.out.println("添加成功！");
            }else {
                System.out.println("添加失败！");
            }
        }else {//如果没有key名为groupName的集合，则需要新建一个list集合，把集合放入map集合中
            boolean add = list.add(c);
            map.put(groupName,list);
            if (add){
                System.out.println("添加成功！");
            }else {
                System.out.println("添加失败！");
            }
        }

    }
    //查看全部联系人
    public void showAllContacts(){//遍历map集合
        Set<Map.Entry<String, List<Contact>>> entries = map.entrySet();
        for (Map.Entry<String, List<Contact>> en:entries){
            String key = en.getKey();
            List<Contact> value = en.getValue();
            System.out.println(key);
            for (Contact cc:value){
                System.out.println(cc);
            }
        }
    }

    //根据分组查看联系人
    public void showContactsByGroupName(){
        System.out.println("请输入您要查询的分组：");
        String s=scanner.next();
        Set<Map.Entry<String, List<Contact>>> entries = map.entrySet();
        for (Map.Entry<String, List<Contact>> en:entries){
            String key = en.getKey();
            if (key.equalsIgnoreCase(s)){
                List<Contact> value = en.getValue();
                System.out.println(key);
                for (Contact cc:value){
                    System.out.println(cc);
                    return;
                }
            }
        }
        System.out.println(s+"分组尚无联系人");
    }
    //根据姓名关键字查看联系人
    public void showContactsByName(){
        System.out.println("请输入要查询的联系人的姓名关键字：");
        String s=scanner.next();
        int n=0;
        Set<Map.Entry<String, List<Contact>>> entries = map.entrySet();
        for (Map.Entry<String, List<Contact>> en:entries){
            String key = en.getKey();
            List<Contact> value = en.getValue();
                for (Contact cc:value){
                    if (cc.getName().contains(s)){
                        System.out.println(key);
                        System.out.println(cc);
                        n++;
                    }
                }
        }
        if (n==0){
            System.out.println("查无此人！");
        }
    }
    //根据手机号关键字查看联系人
    public void showContactsByPhone(){
        System.out.println("请输入要查询的联系人的手机号码关键字：");
        String s=scanner.next();
        int n=0;
        Set<Map.Entry<String, List<Contact>>> entries = map.entrySet();
        for (Map.Entry<String, List<Contact>> en:entries){
            String key = en.getKey();
            List<Contact> value = en.getValue();
            for (Contact cc:value){
                if (cc.getPhone().contains(s)){
                    System.out.println(key);
                    System.out.println(cc);
                    n++;
                }
            }
        }
        if (n==0){
            System.out.println("查无此人！");
        }
    }
    //修改联系人
    public void modifyContact(){
        System.out.println("请输入您想要修改的联系人的姓名（全名）：");
        String s = scanner.next();
        int n=0;
        Set<Map.Entry<String, List<Contact>>> entries = map.entrySet();
        Iterator<Map.Entry<String, List<Contact>>> it = entries.iterator();
        while (it.hasNext()) {
            Map.Entry<String, List<Contact>> next = it.next();
            String key = next.getKey();
            List<Contact> value = next.getValue();
            for (int i = 0; i < value.size(); i++) {
                Contact cc = value.get(i);
                if (cc.getName().equals(s)) {
                    n++;
                    System.out.println("您要修改的联系人信息为：");
                    System.out.println(key);
                    System.out.println(cc);
                    System.out.println("您确定要修改吗（Y/N）");
                    String ss = scanner.next();
                    if (ss.equalsIgnoreCase("Y")) {
                        value.remove(i);

                        if (value.size()==0){
                            map.remove(key);
                        }
                        addContact(); //重新调用添加方法
                        System.out.println("修改成功！");
                        return;
                    } else {
                        System.out.println("修改删除");
                    }
                }
            }
            if (n==0){
                System.out.println("查无此人");
            }
        }



    }
    //删除联系人
    public void deleteContactByName() {
        System.out.println("请输入您想要删除的联系人的姓名（全名）：");
        String s = scanner.next();
        int n=0;
        Set<Map.Entry<String, List<Contact>>> entries = map.entrySet();
        Iterator<Map.Entry<String, List<Contact>>> it = entries.iterator();
        while (it.hasNext()) {
            Map.Entry<String, List<Contact>> next = it.next();
            String key = next.getKey();
            List<Contact> value = next.getValue();
            for (int i = 0; i < value.size(); i++) {
                Contact cc = value.get(i);
                if (cc.getName().equals(s)) {
                    n++;
                    System.out.println("您要删除的联系人信息为：");
                    System.out.println(key);
                    System.out.println(cc);
                    System.out.println("您确定要删除吗（Y/N）");
                    String ss = scanner.next();
                    if (ss.equalsIgnoreCase("Y")) {
                        value.remove(i);
                        System.out.println("删除成功！");
                        if (value.size()==0){
                            map.remove(key);
                        }
                        return;
                    } else {
                        System.out.println("取消删除");
                    }
                }
            }
            if (n==0){
                System.out.println("查无此人");
            }
        }
    }
}

 再建一个测试类ContactTest:

import java.util.Scanner;

public class ContactTest {
    Scanner sc=new Scanner(System.in);
    AddressBook addressBook=new AddressBook();
    public  void ui(){
        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("8.退出");
            System.out.println("请输入您的选择（1-8）：");
            int n=sc.nextInt();
            if (n==1){
                addressBook.addContact();
            }else if (n==2){
                addressBook.showAllContacts();
            }else if (n==3){
                addressBook.showContactsByGroupName();
            }else if (n==4){
                addressBook.showContactsByName();
            }else if (n==5){
                addressBook.showContactsByPhone();
            }else if (n==6){
                addressBook.modifyContact();

            }else if (n==7){
                addressBook.deleteContactByName();
            }else if (n==8){
                System.out.println("您确定要退出吗（Y/N）");
                String s=sc.next();
                if (s.equalsIgnoreCase("Y")){
                    System.out.println("欢迎下次光临！");
                    System.exit(0);
                }else {
                    System.out.println("取消退出");
                }
            }else {
                System.out.println("您输入的功能还没有开发，尽情期待！");
            }

        }


    }


    public static void main(String[] args) {
        ContactTest ct=new ContactTest();
        ct.ui();
    }
}

创建类Pinyin4j:

import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;

/**
 * 汉字转换成拼音方法
 *
 * @author 蔡龙
 */

public class Pinyin4j {

    HanyuPinyinOutputFormat format = null;

    public static enum Type {
        UPPERCASE,              //全部大写
        LOWERCASE,              //全部小写
        FIRSTUPPER            //首字母大写
    }

    public Pinyin4j() {
        format = new HanyuPinyinOutputFormat();
        format.setCaseType(HanyuPinyinCaseType.UPPERCASE);
        format.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
    }

    /**
     * 转换全部大写
     *
     * @param str 字符串
     * @return str为颐和园 ,return获取到的是YHY
     * @throws BadHanyuPinyinOutputFormatCombination
     */
    public String toPinYinUppercase(String str) throws BadHanyuPinyinOutputFormatCombination {
        return toPinYin(str, "", Type.UPPERCASE);
    }

    /**
     * 转换全部大写
     *
     * @param str   字符串
     * @param spera 转换字母间隔加的字符串,如果不需要为""
     * @return str为颐和园 ,spera为** return获取到的是Y**H**Y
     * @throws BadHanyuPinyinOutputFormatCombination
     */
    public String toPinYinUppercase(String str, String spera) throws BadHanyuPinyinOutputFormatCombination {
        return toPinYin(str, spera, Type.UPPERCASE);
    }

    /**
     * 转换全部小写
     *
     * @param str 字符串
     * @throws BadHanyuPinyinOutputFormatCombination
     * @return str为颐和园 ,return获取到的是yhy
     */
    public String toPinYinLowercase(String str) throws BadHanyuPinyinOutputFormatCombination {
        return toPinYin(str, "", Type.LOWERCASE);
    }

    /**
     * 转换全部小写
     *
     * @param str   字符串
     * @param spera 转换字母间隔加的字符串,如果不需要为""
     * @throws BadHanyuPinyinOutputFormatCombination
     * @return str为颐和园 ,spera为** return获取到的是y**h**y
     */
    public String toPinYinLowercase(String str, String spera) throws BadHanyuPinyinOutputFormatCombination {
        return toPinYin(str, spera, Type.LOWERCASE);
    }

    /**
     * 获取拼音首字母(大写)
     *
     * @param str 字符串
     * @return str为颐和园 ,return获取到的是Y
     * @throws BadHanyuPinyinOutputFormatCombination 异常信息
     */
    public String toPinYinUppercaseInitials(String str) throws BadHanyuPinyinOutputFormatCombination {
        String initials = null;
        String py = toPinYinUppercase(str);
        if (py.length() > 1) {
            initials = py.substring(0, 1);
        }
        if (py.length() <= 1) {
            initials = py;
        }
        return initials.trim();
    }

    /**
     * 获取拼音首字母(小写)
     *
     * @param str 字符串
     * @return str为颐和园 ,return获取到的是y
     * @throws BadHanyuPinyinOutputFormatCombination 异常信息
     */
    public String toPinYinLowercaseInitials(String str) throws BadHanyuPinyinOutputFormatCombination {
        String initials = null;
        String py = toPinYinLowercase(str);
        if (py.length() > 1) {
            initials = py.substring(0, 1);
        }
        if (py.length() <= 1) {
            initials = py;
        }
        return initials.trim();
    }

    /**
     * 将str转换成拼音，如果不是汉字或者没有对应的拼音，则不作转换
     *
     * @param str   字符串
     * @param spera 默认,可为""
     * @param type  转换格式
     * @return 按照转换格式转换成字符串
     * @throws BadHanyuPinyinOutputFormatCombination 异常信息
     */
    public String toPinYin(String str, String spera, Type type) throws BadHanyuPinyinOutputFormatCombination {
        if (str == null || str.trim().length() == 0) {
            return "";
        }
        if (type == Type.UPPERCASE) {
            format.setCaseType(HanyuPinyinCaseType.UPPERCASE);
        } else {
            format.setCaseType(HanyuPinyinCaseType.LOWERCASE);
        }
        String py = "";
        String temp = "";
        String[] t;
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if ((int) c <= 128) {
                py += c;
            } else {
                t = PinyinHelper.toHanyuPinyinStringArray(c, format);
                if (t == null) {
                    py += c;
                } else {
                    temp = t[0];
                    if (type == Type.FIRSTUPPER) {
                        temp = t[0].toUpperCase().charAt(0) + temp.substring(1);
                    }
                    if (temp.length() >= 1) {
                        temp = temp.substring(0, 1);
                    }
                    py += temp + (i == str.length() - 1 ? "" : spera);
                }
            }
        }
        return py.trim();
    }
}