主要是把第一个版本里边的操作类功能纯化，把管理类增删改查+排序功能封装到一个仓库类，通过系统类调用仓库类来进行主播数组的增删改查+排序。

代码如下：

anchor.java(优化一下：构造方法链式，采用参数多的方法被其他方法调用)

package com.xuetang9.kenny.showerdemo;
/**
* 类说明:anchor 主播实体类，基本属性+打印格式toString
* 优化一下：构造方法链式，采用参数多的方法被其他方法调用
* @author: Yu
* @version: 2.0
* 创建时间：2021年2月2日 下午6:57:13 
*/

public class anchor {
    private long id;        //主播id
    private String name;    //主播姓名
    private String skill;    //主播技能
    private String intro;    //主播介绍
    private long fansCount; //主播粉丝数
    private double face;    //主播颜值
    private String imagePath;//主播头像路径
    public anchor() {
        this(0, "默认主播", "天生我才", "我就是彪悍");
    }
    public anchor(long id, String name, String skill, String intro) {
        this(id, name, skill, intro, 0, 0, "主播默认路径");
        this.fansCount = (int)(Math.random() * 10000)% 1001 + 1000; 
    }
    
    public anchor(long id, String name, String skill, String intro, long fansCount, double face, String imagePath) {
        this.id = id;
        this.name = name;
        this.skill = skill;
        this.intro = intro;
        this.fansCount = fansCount;
        this.face = face;
        this.imagePath = imagePath;
    }
    //用来控制主播的打印格式
    public String toString() {
        String str = String.format("%d\t%s\t%s\t%s\t%d", id, name, skill, intro, fansCount);
        return str;
    }
    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSkill() {
        return skill;
    }
    public void setSkill(String skill) {
        this.skill = skill;
    }
    public String getIntro() {
        return intro;
    }
    public void setIntro(String intro) {
        this.intro = intro;
    }
    public long getFansCount() {
        return fansCount;
    }
    public void setFansCount(long fansCount) {
        this.fansCount = fansCount;
    }
    public double getFace() {
        return face;
    }
    public void setFace(double face) {
        this.face = face;
    }
    public String getImagePath() {
        return imagePath;
    }
    public void setImagePath(String imagePath) {
        this.imagePath = imagePath;
    }
    
    
}

管理类优化为：封装一个仓库类对传入的对象进行数组对象的增删改查+排序，然后在系统类调用仓库类，并传入主播对象给仓库类进行增删改查+排序操作，在系统类通过框架：while+switch（循环+选择）---程序执行结构

anchorStore.java

package com.xuetang9.kenny.showerdemo;

import java.util.Arrays;

/**
 * 类说明: 主播仓库类anchorStore，用来对于传入的主播对象进行增删改查和排序操作
 * 
 * @author: Yu
 * @version: 2.0 创建时间：2021年2月9日 下午10:20:22
 */

public class anchorStore {
    /** 主播数组的最大容量 */
    private static final int Max_Capacity = Integer.MAX_VALUE - 8;
    /** 默认主播对象数组的容量 */
    private static final int Default_Capacity = 10;
    /** 主播仓库核心操作数组，保存主播仓库的操作数据 */
    private static anchor[] anchorArray = new anchor[Default_Capacity];
    // 静态块，用于测试
    static {
        for (int i = 0; i < 5; i++) {
            anchorArray[i] = new anchor(i, "test" + i, null, null);
        }
    }

    // 1.增加操作
    /**
     * 把传入的主播对象添加的主播数组中，添加成功返回新添加的主播对象下标，失败返回-1
     * 
     * @param anchor
     * @return
     */
    public int addAnchor(anchor anchor) {
        // 判断传入的主播是否为空
        if (null == anchor)
            return -1;
        // 判断主播数组容量是否足够（先获取当前主播数组的实际元素个数），如果不够，则扩容
        int size = ensureCapacity();
        // 添加主播对象到主播数组
        anchorArray[size] = anchor;
        return size;
    }

    // 2.查看当前主播数组中所有主播对象
    /**
     * 查看当前主播数组中所有主播对象
     */
    public void showAll() {
        System.out.println("主播编号\t姓名\t技能\t介绍\t粉丝数");
        int size = getSize();
        for (int i = 0; i < size; i++) {
            System.out.println(anchorArray[i]);
        }
    }

    // 3.删除：根据id删除主播，删除成功返回删除主播下标，删除失败返回-1
    /**
     * 根据id删除主播，删除成功返回删除主播下标，删除失败返回-1
     * 
     * @param id
     * @return
     */
    public int deleteById(long id) {
        // 判断传入id是否合法
        int size = getSize();
        if (id > size || id < 0)
            return -1;
        // 根据id 查找主播数组下标
        int deleteId = findIndex(id);
        // 执行删除操作
        System.arraycopy(anchorArray, deleteId + 1, anchorArray, deleteId, anchorArray.length - 1 - deleteId);
        // 把最后一个元素置空
        anchorArray[size] = null;
        return deleteId;
    }

    // 4.改：根据传入的主播对象更改对应主播数组的主播
    /**
     * 根据传入的主播对象更改对应主播数组的主播,更改成功返回true，失败返回false
     * 
     * @param anchor
     * @return
     */
    public boolean update(anchor anchor) {
        // 判断传入主播对象是否为空
        if (null == anchor)
            return false;
        // 根据id查找主播数组中的主播对象
        anchor updateAnchor = findById(anchor.getId());
        // 执行更新操作，除了id其余属性都更新
        updateAnchor.setName(anchor.getName());
        updateAnchor.setSkill(anchor.getSkill());
        updateAnchor.setIntro(anchor.getIntro());
//        int updateIndex = findIndex(anchor.getId());
//        anchorArray[updateIndex] = anchor;
        return true;
    }

    // 5.排序：
    // 根据指定成员进行升序或降序
    private static final int sortById = 1;
    private static final int sortByName = 2;
    private static final int sortByFansCount = 3;

    /**
     * 根据指定成员进行升序或降序
     * 
     * @param sortBy
     * @param isAsc
     */
    public void sort(int sortBy, boolean isAsc) {
        if (sortBy > 3 || sortBy < 1)
            return;
        int size = getSize();
        // 选择排序
        for (int i = 0; i < size; i++) {
            int minIndex = i;
            int maxIndex = i;
            anchor minAnchor = anchorArray[i];
            anchor maxAnchor = anchorArray[i];
            int j; // 循环变量
            boolean condition = false;
            for (j = i + 1; j < size; j++) {
                if (sortBy == sortById) { // 根据id排序
                    if (isAsc) { // 升序
                        condition = minAnchor.getId() > anchorArray[j].getId();
                    } else { // 降序
                        condition = maxAnchor.getId() < anchorArray[j].getId();
                    }
                } else if (sortBy == sortByName) { // 根据name排序
                    if (isAsc) { // 升序
                        condition = minAnchor.getName().compareToIgnoreCase(anchorArray[j].getName()) > 0;
                    } else { // 降序
                        condition = maxAnchor.getName().compareToIgnoreCase(anchorArray[j].getName()) < 0;
                    }
                } else if (sortBy == sortByFansCount) { // 根据FansCount排序
                    if (isAsc) {
                        condition = minAnchor.getFansCount() > anchorArray[j].getFansCount();
                    } else {
                        condition = maxAnchor.getFansCount() < anchorArray[j].getFansCount();
                    }
                }
                if (condition && isAsc) { // 升序
                    minIndex = j;
                    minAnchor = anchorArray[j];
                } else if (condition && !isAsc) { // 降序
                    maxIndex = j;
                    maxAnchor = anchorArray[j];
                }
            }
            // 升序交换
            if (minIndex > i  && isAsc) {
//                 swap(anchorArray[i], anchorArray[minIndex]);
                anchor tempAnchor = anchorArray[i];
                anchorArray[i] = anchorArray[minIndex];
                anchorArray[minIndex] = tempAnchor;
            }else if (maxIndex > i && !isAsc) {
//                swap(anchorArray[i], anchorArray[maxIndex]);
                anchor tempAnchor = anchorArray[i];
                anchorArray[i] = anchorArray[maxIndex];
                anchorArray[maxIndex] = tempAnchor;
            }
        }
    }

    /**
     * 主播对象交换，交换成功返回true，失败返回false
     * 
     * @param anchor1
     * @param anchor2
     * @return
     */
    private void swap(anchor anchor1, anchor anchor2) {
        anchor tempAnchor = anchor1;
        anchor1 = anchor2;
        anchor2 = tempAnchor;
    }

    /**
     * 根据id查找主播数组中的主播对象
     * 
     * @param id
     * @return
     */
    private anchor findById(long id) {
        int size = getSize();
        for (int i = 0; i < size; i++) {
            if (id == anchorArray[i].getId()) {
                return anchorArray[i];
            }
        }
        // 循环结束，没有找到，返回null
        return null;
    }

    /**
     * 根据传入的id查找主播数组下标
     * 
     * @return
     */
    private int findIndex(long id) {
        int size = getSize();
        for (int i = 0; i < size; i++) {
            if (id == anchorArray[i].getId())
                return i;
        }
        // 循环结束，找不到，返回-1
        return -1;
    }

    /**
     * 获取当前主播数组的非空元素个数
     * 
     * @return
     */
    private int getSize() {
        for (int i = 0; i < anchorArray.length; i++) {
            if (null == anchorArray[i]) {
                return i;
            }
        }
        // 循环结束，返回数组长度
        return anchorArray.length;
    }

    /**
     * 确保主播数组容量充足，并且返回当前主播数组的实际个数
     * 
     * @return
     */
    private int ensureCapacity() {
        int size = getSize();
        if (size < anchorArray.length) {
            return size;
        }
        // 扩容操作
        anchorArray = Arrays.copyOf(anchorArray, size * 2);
        return size;
    }
}

anchorSystem.java

package com.xuetang9.kenny.showerdemo;

import java.util.Scanner;

/**
* 类说明: 通过主播系统调用主播类
* @author: Yu
* @version: 1.0
* 创建时间：2021年2月9日 下午10:44:45 
*/

public class anchorSystem {
    Scanner scanner = new Scanner(System.in);
    anchorStore anchorStore = null;
    anchor anchor = null;
    public anchorSystem() {
        anchorStore = new anchorStore();    
        anchor = new anchor();
    }
    public void start() {
        System.out.println("1.添加主播:");
        System.out.println("2.查看所有主播:");
        System.out.println("3.删除主播");
        System.out.println("4.更改主播:");
        System.out.println("5.主播排序:");
        while(true) {
            System.out.println("请输入选择:");
            int choice = scanner.nextInt();
            switch(choice) {
            case 1:
                addAnchor();
                anchorShow();
                break;
            case 2:
                anchorShow();
                break;
            case 3:
                deleteAnchor();
                anchorShow();
                break;
            case 4:
                updateAnchor();
                anchorShow();
                break; 
            case 5:
                sort();
                anchorShow();
                break; 
                default:
                    break;
            }
            System.out.println("是否继续(y/n):");
            if(! "y".equalsIgnoreCase(scanner.next()))
                break;
        }
        System.out.println("已经退出系统！欢迎再次使用！");
    }
    /**
     * 添加主播，添加成功返回新添加的主播对象下标，失败返回-1
     */
    public int addAnchor() {
        System.out.println("添加主播信息:");
        System.out.println("主播编号:");
        anchor.setId(scanner.nextLong());
        System.out.println("主播姓名:");
        anchor.setName(scanner.next());
        System.out.println("主播技能:");
        anchor.setSkill(scanner.next());
        System.out.println("主播个人介绍:");
        anchor.setIntro(scanner.next());
        return anchorStore.addAnchor(anchor);
    }
    /**
     * 查看所有主播
     */
    public void anchorShow() {
        anchorStore.showAll();
    }
    /**
     * 更新主播对象
     * @return
     */
    public boolean updateAnchor() {
        System.out.println("更新主播信息:");
        System.out.println("主播编号:");
        anchor.setId(scanner.nextLong());
        System.out.println("主播姓名:");
        anchor.setName(scanner.next());
        System.out.println("主播技能:");
        anchor.setSkill(scanner.next());
        System.out.println("主播个人介绍:");
        anchor.setIntro(scanner.next());
        return anchorStore.update(anchor);
    }
    /**
     * 删除主播对象，删除成功返回删除主播下标，失败返回-1
     * @return
     */
    public int deleteAnchor() {
        System.out.println("删除主播信息:");
        System.out.println("主播编号:");
        int id = scanner.nextInt();
        return anchorStore.deleteById(id);
    }
    /**
     * 主播排序
     */
    public void sort() {
        System.out.println("1.根据id排序:");
        System.out.println("2.根据姓名排序:");
        System.out.println("3.根据粉丝数排序:");
        System.out.println("请输入排序条件:");
        int sortBy = scanner.nextInt();
        System.out.println("1.升序:");
        System.out.println("2.降序:");
        int isAsc = scanner.nextInt();
        boolean asc = false;
        if(isAsc == 1) {
            asc = true;
        }else {
            asc = false;
        }
        if(sortBy == 1) {
            if(asc) {
                System.out.println("根据id升序:");
            }else {
                System.out.println("根据id降序:");
            }
        }else if(sortBy == 2) {
            if(asc) {
                System.out.println("根据name升序:");
            }else {
                System.out.println("根据name降序:");
            }
        }else if(sortBy == 3) {
            if(asc) {
                System.out.println("根据FansCount升序:");
            }else {
                System.out.println("根据FansCount降序:");
            }
        }        
        anchorStore.sort(sortBy, asc);
        
    }

}

app.java

package com.xuetang9.kenny.showerdemo;
/**
* 类说明: 
* @author: Yu
* @version: 1.0
* 创建时间：2021年2月10日 下午4:05:41 
*/

public class app {
    public static void main(String[] args) {
        anchorSystem anchorSystem = new anchorSystem();
        anchorSystem.start();
    }

}

以上来自老九学堂课堂个人笔记~~