使用数组制作简易的用户管理系统【java】

思路：

一、分析用户管理功能模块

　　- User类型属性值设定

　　　　private String username;　　// 用户id（唯一字段）

　　　　private String nickname;　　// 昵称

　　　　private String password;　　// 密码

　　　　private int age;　　// 年龄

　　- 实现用户数据（通过 UserManager 类进行 User 对象的数据管理）的“增删改查”功能；

　　　　增加用户：　add(user User):void　　　

　　　　删除功能：　delete(username String):void

　　　　修改用户：　update(user User):void

　　　　查询数据：　load(user User):User　　　　

　　- 实现用户登录功能；

　　　　登录功能：　login(username String,password String):void

　　　　UML图示：

　　　　

　二、创建User类和UserManager类

　　　　- User 类中只包含私有的 User 属性，并用 setter 方法和 getter 方法进行封装；

　　　　- UserManager 类包含上述的自定义方法，用于实现用户数据的“增删改查”操作；

　　　　　　思考：

　　　　　　在 UserManager 类中，需要存储 n 多一个User类型的数据，则可以在该类中 new 一个 User 类型的数组，即：User[] users;

　　　　　　数组的长度是未知的，如果直接在该类中定义死了，则这个系统的灵活性就降低了（无论如何只能用初始定义好的数组大小，后期需要扩容的时候面临需要修改源代码的烦恼）。因此可以考虑如果想增加数组的灵活性，能不能在main函数中管理者自己定义一个数组大小呢？答案是可以的，可以使用 UserManager 的构造方法来设定 users 数组的大小，即：

　　　　　　public class UserManager( int size ) {

　　　　　　　　users = new User[size];

　　　　　　}

　三、UserManager 类中各个功能模块的业务逻辑思路

　　　　　　1、load( String username ) 方法

　　　　　　　　实现通过参数 username 在整个数组中寻找到相应的数组元素，并返回该数组元素（User 对象）；

　　　　　　　　通过 for 循环遍历数组，在循环体中：将每次遍历的数组元素和参数 username 进行 equals 比较：

　　　　　　　　　　- 如果比较值为真，则表示找到了该 username 对应的数组元素，返回该遍历的数组；

　　　　　　　　　　- 如果整个遍历完了都没有找到，则在循环语句之后进行null值返回，因为 load() 方法返回值类型为 User 。

　　　　　　　　注意：

　　　　　　　　　　　如果这个数组的长度（size）是 5 ，数组中目前只有三条记录，那么遍历的时候就只需要遍历到这有记录的三条即可。

　　　　　　　　　　　那怎么让for循环遍历的时候只遍历到当前数据记录的最后一条的位置呢？

　　　　　　　　　　　我们可以人为的定义一个“标记”，这个标记用来表示，数组存到哪里，就指到哪里，为后期需要增加/删除新的元素操作做铺垫；

　　　　　　　　　　　比如：

　　　　　　　　　　    users = new User[10];　　//默认初始的5个数组内存中都是null，此时遍历元素值为 null 的数组元素没有任何意义。

　　　　　　　　　　　当user[0] 中增加了一条数据，我们就让“标记”记录一条，此时标记累计值为 1 ；

　　　　　　　　　　　当user[1] 中再增加一条数据，我们就让“标记”再记录一条，此时标记累计值为 2；

　　　　　　　　　　    ……

　　　　　　　　　　   当user[8 中再增加一条数据，我们就让“标记”再记录一条，此时标记累计值为 9；

　　　　　　　　　　　当user[9] 中再增加一条数据，我们就让“标记”再记录一条，此时标记累计值为 10；

　　　　　　　　　　　如果是删除数据，则是相类似的规律。nums 的值表示共存了 nums 个用户数据，而数组中依次存在 user[0] , user[1] , … ,user[nums-1] 当中。

　　　　　　　　　　   由此可以得出：标记的增加/减少与数组元素的下标值有关，因此可以人为设定一个 int 类型的 nums 变量，这个变量默认值为 0 ，放置到 UserManager 类的属性值中，只要创建了 UserManager 类的实例，就进行默认初始化。

　　　　　　　　　　　因此查询数组中的所有元素，就只需要遍历 nums 次，每次得到该次“标记”对应的数组元素即可。

　　　　　　2、add( User user ) 方法

　　　　　　　　用户数据信息的增加首先需要考虑的问题是：

　　　　　　　　　　- 数组剩余内存空间的多少，如果数组元素满员了，则需要提示管理者不可以再添加新的用户数据；

　　　　　　　　　　- username 关键字的唯一性，因此需要判断现有的数组元素中是否存在重复数据的问题，如果数据重复（关键字重叠），则需要提示数据已存在，不可以添加。

　　　　　　　　如果上述问题条件都没有发生，则表示新增的用户数据是全新的数据，并且数组内存中有“位置”将其添加。

　　　　　　　　实现思路：

　　　　　　　　// 剩余空间判断

　　　　　　　　本数组的长度（length）为 size，只需要判断“标记”（用 nums 标记数组内存中存了多少个有效的元素值）和数组长度的大小。

　　　　　　　　nums 只要大于或者等于数组长度则提示不可以再增加数据记录。

　　　　　　　　// 数据唯一性判断

　　　　　　　　可以通过load方法进行判断，让参数 user 对象的 username 属性值在 loa() 方法里进行搜索，如果搜索到的是一个 null 值则表示新增的数据没有和当前的数据库中的记录重复。

　　　　　　　　// 添加数据记录

　　　　　　　　将数据存至 user[nums] 当中，并让 nums 自增 1 即可。

　　　　　　　　【拓展】通过指定位置增加数组元素，见图：

　　　　　　3、update( User user ) 方法

　　　　　　　　update() 方法的实现思路与添加功能相似：

　　　　　　　　首先判断参数 user 是否在数组中存在，如果不存在则提示“要更新的原始数据不存在！”；

　　　　　　　　其次在上一个步骤中，已经找出了该需要更新的数据位置，直接将user的属性值利用 users 数组的 setter() 方法进行修改。

　　　　　　4、delete( String username ) 方法

　　　　　　　　删除数组元素操作思路见下图：

代码：

　　User 类

 package com.test.test01;

 public class User {
     private String username;
     private String nickname;
     private String password;
     private int age;

     public String getUsername() {
         return username;
     }
     public void setUsername(String username) {
         this.username = username;
     }
     public String getNickname() {
         return nickname;
     }
     public void setNickname(String nickname) {
         this.nickname = nickname;
     }
     public String getPassword() {
         return password;
     }
     public void setPassword(String password) {
         this.password = password;
     }
     public int getAge() {
         return age;
     }
     public void setAge(int age) {
         this.age = age;
     }

     public User(String username, String password, String nickname, int age) {
         super();
         this.username = username;
         this.nickname = nickname;
         this.password = password;
         this.age = age;
     }

     @Override
     public String toString() {
         return "User [username=" + username + ", nickname=" + nickname
                 + ", password=" + password + ", age=" + age + "]";
     }

 }

　　UserManager 类

 package com.test.test01;

 public class UserManager {
     User[] users;
     private int nums=0;

     public UserManager(int size) {
         users = new User[size];
     }

     public void add(User user) {
         //判断数组内存是否有剩余
         if(nums>=users.length) {
             System.out.println("对不起，用户数据内存已满，无法再添加"+user.getUsername()+"信息！");
             return;
         }

         //判断是否存在该用户数据
         User u = this.load(user.getUsername());
         if(u!=null) {
             System.out.println("对不起，该用户:"+u.getUsername()+"数据已存在！");
             return;
         }

         //添加数据
         users[nums] = user;
         nums++;
         System.out.println("用户:"+user.getUsername()+"数据已添加成功！");
         return;

     }

     public User load(String username) {
         for(int i=0;i<nums;i++) {
             User u = users[i];
             if(username.equals(u.getUsername())) {
                 return u;
             }
         }
         return null;
     }

     public void delete(String username) {
         int index=-1;
         //通过index索引找到需要删除的数组下标值
         for(int i=0;i<nums;i++) {
             User u = users[i];
             if(username.equals(u.getUsername())) {
                 index=i;
                 break;
             }
         }

         if(index==-1) {
             System.out.println("对不起，要删除的用户："+username+"不存在！");
             return;
         }

         //从index位置开始，后一个数组元素赋值到前一个数组元素中，最后再将users[nums]=null，nums自减
         for(int i=index+1;i<nums;i++) {
             users[i-1] = users[i];
         }
         users[nums-1]=null;
         nums--;
         System.out.println("用户："+username+"数据删除成功！");
         return;

     }

     public void add(int pos,User user) {
         //首先检查pos是否合法
         if(pos<0||pos>=nums) {
             System.out.println("对不起，用户"+user.getUsername()+"信息添加位置不正确！");
             return;
         }

         //判断pos是否可以插入，即nums个数据已经存满了就不可以再增加新数据
         if(nums>=users.length) {
             System.out.println("对不起，内存已满，无法再添加"+user.getUsername()+"信息！");
             return;
         }

         //检查是否已存在user对象
         User u = this.load(user.getUsername());
         if(u!=null) {
             System.out.println("对不起，该用户:"+u.getUsername()+"数据已存在！");
             return;
         }

         for(int i=nums;i>pos;i--) {
             //前面有nums>=users.length判断，因此users[nums]空间存在，可以被前面的元素赋值
             users[i] = users[i-1];
         }

         users[pos] = user;
         nums++;
         System.out.println("用户:"+user.getUsername()+"数据已添加成功！");
         return;
     }

     public void update(User user) {
         //检查是否存在该用户数据
         User u = this.load(user.getUsername());
         if(u==null) {
             System.out.println("对不起，该用户："+user.getUsername()+"数据不存在！");
             return;
         }

         //更新数据
         u.setNickname(user.getNickname());
         u.setPassword(user.getPassword());
         u.setAge(user.getAge());
         System.out.println("用户:"+user.getUsername()+"数据已更新成功！");
         return;
     }

     public void login(String username,String password) {
         //判断是否存在 username 用户名
         User u = this.load(username);

         if(u==null) {
             System.out.println("用户名："+username+"不正确，请检查输入！");
             return;
         }

         //判断密码是否正确
         if(!password.equals(u.getPassword())) {
             System.out.println("密码不正确，请检查输入！");
             return;
         }
         //成功登录系统
         System.out.println("欢迎"+username+"登录系统！");
         return;
     }

     public User[] list() {
         User[] tus = new User[nums];    //只遍历数组元素中存有有效元素值的数组
         for(int i=0;i<nums;i++) {
             tus[i] = users[i];
         }
         return tus;
     }
 }

　　TestUser 测试入口

 package com.test.test01;

 public class TestUser {

     public static void main(String[] args) {
         UserManager um = new UserManager(5);
         um.add(new User("zs","123","张三",24));    //添加信息成功
         um.add(new User("ls","123","李四",22));    //添加信息成功
         um.add(new User("ls","123","李四",23));    //添加不成功，已存在
         um.add(new User("ww","123","王五",21));    //添加信息成功
         um.add(new User("zl","123","赵六",21));    //添加信息成功
         um.add(new User("zq","123","朱七",22));    //添加信息成功

         um.add(new User("S","123","大S",22));    //满员了，添加信息不成功

         System.out.println("------分割线------");

         um.delete("ls");    //删除ls
         um.delete("ls1231");    //提示要删除的用户名不存在

         System.out.println("------分割线------");

         um.update(new User("S","1234","大S",23));    //提示要更新的用户名不存在
         um.update(new User("zq","1234","朱七",23));    //提示zq信息更新成功

         System.out.println("------分割线------");

         um.login("zs1", "1234");    //提示用户名错误
         um.login("zs1", "123412");    //提示用户名错误
         um.login("zs", "123412");    //提示密码错误
         um.login("zs", "123");        //提示成功登陆系统

         um.login("ls", "123");    //用户名不存在，提示错误

         System.out.println("------分割线------");

         User[] u = um.list();
         for(int i=0;i<u.length;i++) {
             System.out.println(u[i]);
         }

         System.out.println("------分割线------");

         um.add(1,new User("S","123","大S",22));
         um.delete("ww");
         um.add(1,new User("Y","123","大Y",22));
         um.delete("Y");
         um.add(3,new User("s","123","小S",22));

         System.out.println("------分割线------");

         User[] u2 = um.list();
         for(int i=0;i<u2.length;i++) {
             System.out.println(u2[i]);
         }
     }

 }