Java第十四天~十五天/11.11~11.12

第十四天/11.11

一、数据结构

1、栈结构特点：先进后出
进栈方式：压栈
出栈方式：弹栈
2、队列结构特点：先进先出

3、数组特点：查询快，增删慢
4、链表特点：查询慢，增删快

二、List集合的子实现类的特点

ArrayList:
        底层数据结构是数组的形式,满足数组结构的特点:查询快,增删慢
        从线程安全问题来看:线程不安全的,不同步,执行效率高

Vector:
        底层数据结构是数组的形式,查询快,增删慢
        从线程角度看:线程安全的类,同步,执行效率低
LinkedList:
        底层数据结构是链接列表,特点:查询慢,增删快
        从线程角度看:线程不安全的一个类,不同步,执行效率高

如果在一般的需求中没有指明使用集合去完成,都默认采用ArrayList
如果需求中要考虑线程安全,那么使用Vector集合!

三、ArrayList

1、集合中元素可以重复，且存储和取出一致

ArrayList:
            底层数据结构是数组的形式,满足数组结构的特点:查询快,增删慢
            从线程安全问题来看:线程不安全的,不同步,执行效率高

    由于ArrayList是List集合的自实现类,它元素可以重复,并且存储和取出一致

package org.westos_arraylist_01;

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListDemo {

    public static void main(String[] args) {

        //创建ArrayList集合对象
        ArrayList array=new ArrayList();

        //添加元素
        array.add("hello");
        array.add("hello");
        array.add("java");
        array.add("java");
        array.add("world");
        array.add("world");
        //获取迭代器遍历元素
        Iterator it = array.iterator();
        while(it.hasNext()){
            String s=(String) it.next();
            System.out.println(s);
            /*hello
            hello
            java
            java
            world
            world*/
        }
    }
}

2、ArrayList集合存储自定义对象并遍历

package org.westos_arraylist_01;

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListDemo2 {

    public static void main(String[] args) {

        //创建ArrayList集合对象
        ArrayList array=new ArrayList();
        //创建学生对象
        Student s1=new Student("二哈",2);
        Student s2=new Student("金毛",3);
        Student s3=new Student("萨摩耶",4);
        Student s4=new Student("柴犬",3);
        //添加元素
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);
        //迭代器遍历
        Iterator it = array.iterator();
        while(it.hasNext()){
            Student s=(Student) it.next();
            System.out.println(s);
            /*Student [name=二哈, age=2]
              Student [name=金毛, age=3]
              Student [name=萨摩耶, age=4]
              Student [name=柴犬, age=3]*/

        }
    }
}
package org.westos_arraylist_01;

public class Student {

    private String name;
    private int age;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    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;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

}

3、Vector集合
特点：
底层数据结构是数组的形式,查询快,增删慢
从线程角度看:线程安全的类,同步,执行效率低
存储和取出一致

package org.westos_vector;

import java.util.Enumeration;
import java.util.Vector;

/**
 * 特有功能:

            public void addElement(E obj)------->相当于:add(Object e)

            public Enumeration<E> elements()----->相当于:Iterator iterator() ;


            Enumeration<E>接口:向量的组件枚举有两个方法
                    boolean hasMoreElements():------>相当于:hasNext()
                    Object nextElement():----------->相当于:next();

    源码: 

        synchronized:同步锁(多线程中讲):它就可以保证线程安全!
     public synchronized void addElement(E obj) {//由同步代码块演变过来的同步方法

             modCount++;
            ensureCapacityHelper(elementCount + 1);
            elementData[elementCount++] = obj;

    }
 * @author 小鑫
 *
 */
public class VectorDemo {

    public static void main(String[] args) {

        //创建Vector集合对象
        Vector v=new Vector();
        v.addElement("hello");
        v.addElement("hello");
        v.addElement("java");
        v.addElement("world");
        v.addElement("javaweb");
        //public Enumeration<E> elements()----->相当于:Iterator iterator() ;
        Enumeration en= v.elements();
        /**
         * 遍历元素
         * boolean hasMoreElements():------>相当于:hasNext()
        Object nextElement():----------->相当于:next();
         */
        while(en.hasMoreElements()){
            String s=(String) en.nextElement();
            System.out.println(s);
            /*hello
            hello
            java
            world
            javaweb*/
        }
    }
}

4、LinkedList:
底层数据结构是链接列表,特点:查询慢,增删快
从线程角度看:线程不安全的一个类,不同步,执行效率高

package org.westos_linkedlist;

import java.util.LinkedList;
/**
 * 特有功能:
        添加功能:
            public void addFirst(E e)将指定元素插入此列表的开头。
            public void addLast(E e)将指定元素添加到此列表的结尾。
        获取功能:
            public Object getFirst()返回此列表的第一个元素
            public Object getLast()返回此列表的最后一个元素。
        删除功能:
            public Object removeFirst()移除并返回此列表的第一个元素。
            public Object removeLast()移除并返回此列表的最后一个元素。
 * @author 小鑫
 *
 */
public class LinkedListDemo {

    public static void main(String[] args) {

        //创建LinkedList集合对象
        LinkedList link=new LinkedList();
        //添加元素
        link.addFirst("hello");
        link.addFirst("java");
        link.addFirst("world");
        System.out.println(link);//[world, java, hello]
        link.addFirst("javaweb");
        System.out.println(link);//[javaweb, world, java, hello]
        /**
         * public Object getFirst()返回此列表的第一个元素
            public Object getLast()返回此列表的最后一个元素。
         */
        Object first = link.getFirst();
        System.out.println(first);//javaweb
        Object last = link.getLast();
        System.out.println(last);//hello        
        /**
         * public Object removeFirst()移除并返回此列表的第一个元素。
            public Object removeLast()移除并返回此列表的最后一个元素。
         */
        System.out.println("removeFirst:"+link.removeFirst());//removeFirst:javaweb
        System.out.println("removeLast:"+link.removeLast());//removeLast:hello

        System.out.println(link);//[world, java]
    }
}

5、练习

package org.westos_arraylist_test;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * 需求:ArrayList去除集合中字符串的重复元素
 *      1)首先创建一个集合
 *      2)给集合中添加很多重复元素
 *      3)再次创建一个新集合
 *      4)获取迭代器遍历
 *      5)获取到该集合中的每一个元素
 *              判断新集合中是否包含这些有素
 *              有,不搭理它
 *              没有.说明不重复,添加进来
 *       6)遍历新集合
 * @author 小鑫
 *
 */
public class ArrayListTest {

    public static void main(String[] args) {

        //创建集合
        ArrayList array=new ArrayList();
        //添加元素
        array.add("hello");
        array.add("hello");
        array.add("java");
        array.add("world");
        array.add("javaweb");
        array.add("hello");
        array.add("javaweb");
        array.add("hello");
        array.add("world");
        array.add("java");
        //创建新集合
        ArrayList newArray=new ArrayList();
        //遍历旧集合
        Iterator it1 = array.iterator();
        while(it1.hasNext()){
            String s=(String) it1.next();
            //判断新集合是否包含旧集合的元素
            if(!newArray.contains(s)){
                newArray.add(s);
            }
        }
        Iterator it2 = newArray.iterator();
        while(it2.hasNext()){
            String s=(String) it2.next();
            System.out.println(s);
            /*hello
            java
            world
            javaweb*/

        }
    }
}

不创建新的集合来出去集合中的重复元素，两个for循环

package org.westos_arraylist_test;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * 需求:ArrayList去除集合中字符串的重复元素,
 *          附件条件:不能创建新集合!
 * @author 小鑫
 *
 */
public class ArrayListTest2 {

    public static void main(String[] args) {

        //创建新集合
        ArrayList array=new ArrayList();

        array.add("hello");
        array.add("hello");
        array.add("java");
        array.add("world");
        array.add("javaweb");
        array.add("hello");
        array.add("javaweb");
        array.add("hello");
        array.add("world");
        array.add("java");
        /**
         * 由选择排序的逻辑想到:
         * 拿0索引对应的元素依次和后面索引对应的元素进行比较
         * 同理,1索引对应的元素和后面.....
         * 前面的索引对应的元素如果和后面索引对应的元素重复了,从集合移出后面索引的对应的元素         
         */
        for(int i=0;i<array.size()-1;i++){
            for(int j=i+1;j<array.size();j++){
                if(array.get(i).equals(array.get(j))){
                    array.remove(j);
                    j--;
                }
            }
        }
        Iterator it = array.iterator();
        while(it.hasNext()){
            String s = (String) it.next();
            System.out.println(s);
            /*hello
            java
            world
            javaweb*/
        }
    }
}

6、ArrayList集合去除自定义对象中的重复值
contains()底层重写了equal()方法

package org.westos_arraylist_test;

import java.util.ArrayList;
import java.util.Iterator;
/**
 * 需求：ArrayList去除集合中自定义对象的重复值(对象的成员变量值都相同)
 *  
 *  发现问题:
 *          使用刚才创建新集合的思想,逻辑步骤和去除集合中重复的字符串是一样,但是出现了并没有将自定义对象的重复值(成员变量值一样)并没有去除掉
 *  
 *          contains()底层依赖于一个equals()方法,equals()方法是Object类的中的方法,该法默认比较的是对象的地址值是否相同,必须要重写Object中的eqauls()
 *  方法,才能比较内容是否相同;
 *          在自定义对象的类中重写Object中的equasl()方法,才能比较成员变量的值是否相同
 *  看源码:
 *  
 *          ArrayList集合的Contains()源码
 *            public boolean contains(Object o) {
                return indexOf(o) >= 0;
    }


    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
 * @author 小鑫
 *
 */
public class ArrayListTest3 {

    public static void main(String[] args) {

        //创建一个ArrayList集合对象
        ArrayList array = new ArrayList() ;

        //创建学生对象
        Student s1 = new Student("高圆圆", 27) ;
        Student s2 = new Student("高圆圆", 20) ;
        Student s3 = new Student("邓超", 29) ;
        Student s4 = new Student("邓超", 25) ;
        Student s5 = new Student("黄晓明", 30) ;
        Student s6 = new Student("高圆圆", 27) ;

        //将学生对象添加到array集合中
        array.add(s1) ;
        array.add(s2) ;
        array.add(s3) ;
        array.add(s4) ;
        array.add(s5) ;
        array.add(s6) ;

        //创建一个新集合
        ArrayList newArray = new ArrayList() ;
        //迭代器遍历旧集合
        Iterator it1 = array.iterator();
        while(it1.hasNext()){
            Student s=(Student) it1.next();
            //判断新集合中是否包含这些对象
            if(!newArray.contains(s)){
                //不包含就添加到新集合中
                newArray.add(s);
            }
        }
        //遍历新集合
        Iterator it2 = newArray.iterator();
        while(it2.hasNext()){
            Student s=(Student) it2.next();
            System.out.println(s.getName()+"---"+s.getAge());
            /*高圆圆---27
                         高圆圆---20
                         邓超---29
                         邓超---25
                         黄晓明---30*/

        }
    }
}
package org.westos_arraylist_test;

public class Student {

    private String name;
    private int age;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    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;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    //自动生成：Alt+Shift+s--->h
    @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 (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

}

7、使用LinkedList集合模拟栈结构特点

package org.westos_stack;

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListDemo {

    public static void main(String[] args) {

        //创建LinkedList集合对象
        LinkedList link=new LinkedList();
        //LinkedList集合特有功能：addFirst()
        //栈结构特点：先进后出
        link.add("hello");
        link.add("java");
        link.add("world");
        Iterator it = link.iterator();
        while(it.hasNext()){
            String s = (String) it.next();
            System.out.println(s);
            /*hello
            java
            world*/

        }
    }
}

8、自定义栈集合

package org.westos_stack;
/**
 * 自定义栈集合的测试类
 * @author 小鑫
 *
 */
public class StackDemo {

    public static void main(String[] args) {

        //自定义栈集合对象
        Stack s=new Stack();
        //调用添加功能
        s.add("hello");//link.addFirst("hello")
        s.add("java");
        s.add("world");

        /*System.out.println(s.get());//world
        System.out.println(s.get());//java
        System.out.println(s.get());//hello
        //java.util.NoSuchElementException:没有这样元素的异常
        //System.out.println(s.get());
*/      
        /*if(!s.isEmpty()){
            System.out.println(s.get());//world
        }*/
        while(!s.isEmpty()){
            System.out.println(s.get());
            /*world
            java
            hello*/

        }
    }
}
package org.westos_stack;

import java.util.LinkedList;

/**
 * 自定义的栈集合类
 * @author 小鑫
 *
 */
public class Stack {

    private LinkedList link;

    //无参构造
    public Stack(){
        link=new LinkedList();
    }
    //添加功能
    public void add(Object obj){
        link.addFirst(obj);
    }
    //获取功能
    public Object get(){
        return link.removeFirst();
    }
    //判断是否为空
    public boolean isEmpty(){
        return link.isEmpty();
    }
}

四、泛型

1、泛型的提出

使用ArrayList存储元素
 *      给ArrayList集合存储了一些元素,String类型的元素,Integer类型的元素
 * 但是通过迭代器遍历元素,由于,系统不知道集合中存储了哪些元素,所有使用String类型接收,就会出现ClassCastException:类转换异常
 * 这样设计不够好!
 *      定义一个数组:字符串数组
//      String[] str = new String[3] ;
//      str[0] = "hello" ;
//      str[1] = "world" ;
//      str[2] = 100 ;
 * 
 * 数组设计这样好处:提前告诉了开发者,这里只能装String类型的元素,Java根据数组特点---->引出:泛型
 * 泛型:把数据类型的明确工作提供提前到了创建对象或者是调用方法的时期明确的一种特殊类型.参数化类型,可以像参数一样进行传递
 *      格式:
 *          <引用类型>:泛型只能放引用类型

2、泛型的好处

package org.westos_generic;

import java.util.ArrayList;
import java.util.Iterator;

/**
 *      格式:
 *          <引用类型>:泛型只能放引用类型
 *      泛型好处:
 *              1)将运行时期异常提前到了编译时期
 *              2)解决了黄色警告线问题
 *              3)获取数据的时候,不用强制类型转换了
 * @author 小鑫
 *
 */
public class GenericDemo1 {

    public static void main(String[] args) {
        //创建ArrayList集合对象
        ArrayList<String> array=new ArrayList<String>();
        array.add("hello");
        array.add("java");
        array.add("world");
        Iterator<String> it = array.iterator();
        while(it.hasNext()){
            String s=it.next();
            System.out.println(s);
            /*hello
            java
            world*/

        }
    }
}

3、使用ArrayList集合泛型存储自定义对象并遍历

package org.westos_generic;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * 使用ArrayList集合存储自定义对象并遍历
 * @author 小鑫
 *
 */
public class GenericDemo2 {

    public static void main(String[] args) {
        //创建ArrayList集合对象
        ArrayList<Student> array=new ArrayList<Student>();
        //创建学生对象
        Student s1 = new Student("王昭君", 20) ;
        Student s2 = new Student("貂蝉", 25) ;
        Student s3 = new Student("杨贵妃", 29) ;
        Student s4 = new Student("凤姐", 22) ;
        //添加元素
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);
        //迭代器遍历
        Iterator<Student> it = array.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s);
            /*Student [name=王昭君, age=20]
            Student [name=貂蝉, age=25]
            Student [name=杨贵妃, age=29]
            Student [name=凤姐, age=22]*/
        }   
    }
}
package org.westos_generic;

public class Student {

    private String name;
    private int age;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    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;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

}

4、向下转型隐藏转换类型，报错案例

package org.westos_objectTool;
/**
 * 泛型可以提供程序的安全性!
 * 早期的时候,用Object类型代表任意的类型
 * 向上转型是不会出现问题的,但是向下转型的时候,由于隐藏了类型转换,导致出现错误!
 * JDK5以后,提供了泛型可以解决程序的安全性
 * @author 小鑫
 *
 */
public class ObjectToolDemo {

    public static void main(String[] args) {

        //创建ObjectTool对象
        ObjectTool ot=new ObjectTool();
        //设置数据
        ot.setObj(24);//Object obj=new Integer(24);向上转型
        //获取
        Integer i = (Integer) ot.getObj();
        System.out.println("号码是："+i);//号码是：24

        ObjectTool ot2=new ObjectTool();
        ot2.setObj("科比");//Object obj=new String("科比");
        String s = (String) ot2.getObj();//向下转型
        System.out.println(s);//科比

        ObjectTool ot3=new ObjectTool();
        ot3.setObj("欧文");
        Integer ii = (Integer) ot3.getObj();
        System.out.println(ii);//java.lang.ClassCastException类型不匹配
    }
}
package org.westos_objectTool;

public class ObjectTool {

    private Object obj;
    //获取
    public Object getObj(){
        return obj;
    }
    //设置
    public void setObj(Object obj){
        this.obj=obj;
    }
}

5、将泛型定义在方法上

package org.westos_objectTool_01;

public class ObjectToolDemo {

    public static void main(String[] args) {

        /*  ObjectTool<String> ot1 = new ObjectTool<String>() ;
        ot1.show("hello") ;

        ObjectTool<Integer> ot2 = new ObjectTool<Integer>() ;
        ot2.show(100) ;

        ObjectTool<Boolean> ot3 = new ObjectTool<Boolean>() ;
        ot3.show(true) ;*/
        ObjectTool ot=new ObjectTool();
        ot.show("hello");
        ot.show(100);
        ot.show(true);
        System.out.println(ot);
    }
}
package org.westos_objectTool_01;


public class ObjectTool {

    /*//形式参数是String
    public void show(String s){
        System.out.println(s);
    }
    //形式参数是Integer类型
    public void show(Integer i){
        System.out.println(i);
    }
    public void show(Boolean b){
        System.out.println(b);
    }*/
    //将泛型定义在方法上
    public <T> void show(T t){
        System.out.println(t);
    }

}

6、泛型定义在接口上

package org.westos_generic_interface;

public class InterDemo {

    public static void main(String[] args) {
        //创建接口对象
        //第一种情况：已知传递的类型
        Inter<String> i=new InterImpl<String>(); 
        i.show("hello");//hello
        System.out.println("-------------");

        //第二种情况：不知道传入的类型
        Inter<Integer> i2=new InterImpl<Integer>();
        i2.show(24);//24
        Inter<String> i3=new InterImpl<String>();
        i3.show("欧文");//欧文
    }
}
package org.westos_generic_interface;

//接口加入泛型
//第一种情况：接口的子实现类已经知道传递的是什么数据类型
/*public class InterImpl<String> implements Inter<String> {

    @Override
    public  void show(String t) {

        System.out.println(t);
    }
}*/

//第二种情况：接口的子实现类实现接口时，不知道具体数据类型
//在测试类时传入数据类型
public class InterImpl<T> implements Inter<T>{

    @Override
    public void show(T t) {
        System.out.println();

    }

}
package org.westos_generic_interface;

public interface Inter <T>{

    public abstract void show(T t);
}

7、泛型的高级特性：通配符

package org.westos_generic_高级特性;

import java.util.ArrayList;
import java.util.Collection;

/**
 * 泛型的高级:通配符
 * <?> :可以是任意类型,包括Object类型以及任意的Java类
 * <? extends E>:向下限定,E类型以及E类型的子类
 * <? super E>:向上限定,E类型以及E类型的父类
 * @author 小鑫
 *
 */
public class GenericDemo {

    public static void main(String[] args) {
        //创建Collection集合对象
        //前后一致
        Collection<Object> c1 =new ArrayList<Object>();
        Collection<Animal> c2 =new ArrayList<Animal>();

        //<?> :可以是任意类型,包括Object类型以及任意的Java类
        Collection<?> c3=new ArrayList<Object>();
        Collection<?> c4=new ArrayList<Animal>();
        Collection<?> c5=new ArrayList<Dog>();

        //<? extends E>:向下限定,E类型以及E类型的子类
        Collection<? extends Object> c6 = new ArrayList<Object>() ;
        Collection<? extends Animal> c7 = new ArrayList<Animal>() ;
      //Collection<? extends Animal> c8 = new ArrayList<Object>() ;
        Collection<? extends Object> c9 = new ArrayList<Dog>() ;

        //<? super E>:向上限定,E类型以及E类型的父类
        Collection<? super Animal> c10 = new ArrayList<Object>() ;
        Collection<? super Animal> c11 = new ArrayList<Animal>() ;
      //Collection<? super Animal> c12 = new ArrayList<Dog>() ;
    }
}
//自定义两个类
class Animal{

}

class Dog extends Animal{

}

五、增强for循环

1、增强for循环格式

书写格式:
    for(集合或者数组中的数据类型 变量名:集合或者数组的对象名){
            输出变量名;
    }

package org.westos_增强for;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * JDK5以后提供了很多特性:
 *      泛型,增强for循环,可变参数,静态导入,自动拆装箱,枚举等的呢过
 * 增强for循环的弊端:
 *              遍历数组或者集合的时候,数组对象或者集合对象不能为null
 *              如果对象为空,一般加上非空判断
 * 增强for循环的出现就是为了替代迭代器遍历集合的,以后开发中就是用增强for遍历元素
 * @author 小鑫
 *
 */
public class ForDemo {

    public static void main(String[] args) {

        //定义一个数组
        int[] arr={11,22,33,44,55};
        //普通for
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
        //增强for
        for(int i:arr){
            System.out.println(i);
        }
        System.out.println("--------------");

        //定义一个字符数组
        String[] str={"hello","world","java","javaweb","javaee"};
        //增强for
        for(String s:str){
            System.out.println(s);
        }
        System.out.println("--------------");

        //创建ArrayList集合对象
        ArrayList<String> array=new ArrayList<String>();
        array.add("hello");
        array.add("world");
        array.add("JavaSE");
        array.add("JavaEE");
        //迭代器遍历
        /*Iterator<String> it = array.iterator();
        while(it.hasNext()){
            String s = it.next();
            //java.util.ConcurrentModificationException
            //判断当前集合中是否有"world",如果有就添加元素
            if("world".equals(s)){
                array.add("JavaWeb");
            }       
        }*/
        //增强for
        for(String s:array){
            if("world".equals(s)){
                array.add("JavaWeb");
            }           
        }
        /*  array = null ;
        //java.lang.NullPointerException:空指针异常
        if(array!=null){
            //增强for循环
            for(String s:array){
                System.out.println(s);
            }
        }*/
    }
}

2、使用ArrayList集合存储自定义对象并遍历的五种方式:

* 使用ArrayList集合存储自定义对象并遍历
 *    五种方式:
 *    1)toArray()
 *    2)Collection集合的迭代器:Iterator iterator();
 *    3)List集合的迭代器:ListIterator listiterator();
 *    4)普通for循环:size()和get(int index)相结合
 *    5)增强for循环

package org.westos_增强for;

import java.util.ArrayList;
import java.util.Iterator;

public class ForDemo2 {

    public static void main(String[] args) {
        // 创建ArrayList集合
        ArrayList<Student> array = new ArrayList<Student>();

        // 创建学生对象
        Student s1 = new Student("高圆圆", 27);
        Student s2 = new Student("高圆圆", 20);
        Student s3 = new Student("邓超", 29);
        Student s4 = new Student("邓超", 25);

        // 给集合中添加元素
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);

        //普通for循环:size()和get(int index)相结合
        for(int i=0;i<array.size();i++){
            Student s = array.get(i);
            System.out.println(s);
            /*
             * Student [name=高圆圆, age=27]
             * Student [name=高圆圆, age=20]
             * Student[name=邓超, age=29] 
             * Student [name=邓超, age=25]
             */
        }
        System.out.println("----------------");

        //Collection集合的迭代器:Iterator iterator();
        Iterator<Student> it = array.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s);
            /*
             * Student [name=高圆圆, age=27] 
             * Student [name=高圆圆, age=20] 
             * Student[name=邓超, age=29] 
             * Student [name=邓超, age=25]
             */

        }
        System.out.println("-----------------");

        //增强for
        for(Student s:array){
            System.out.println(s);
            /*
             * Student [name=高圆圆, age=27] 
             * Student [name=高圆圆, age=20] 
             * Student[name=邓超, age=29] 
             * Student [name=邓超, age=25]
             */
        }   
    }
}
package org.westos_增强for;

public class Student {

    private String name;
    private int age;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    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;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

}

3、ArrayList集合的嵌套

package org.westos_ArrayList集合的嵌套;

import java.util.ArrayList;

/**
 * 假设有一个Java班,看成一个容器,这个容器里面有很多学生
 * ArrayList<Student>,但是又不止一个Java班,
 * 大的集合:ArrayList<ArrayList<Student>>
 * 集合的嵌套遍历
 * @author 小鑫
 *
 */
public class ArrayListDemo {

    public static void main(String[] args) {

        //创建大集合
        ArrayList<ArrayList<Student>> bigArray=new ArrayList<ArrayList<Student>>();

        //创建第一个子集合
        ArrayList<Student> firstArray=new ArrayList<Student>();
        //创建学生对象
        Student s1=new Student("二哈",3);
        Student s2=new Student("金毛",4);
        Student s3=new Student("柴犬",2);
        //给第一个集合添加元素
        firstArray.add(s1);
        firstArray.add(s2);
        firstArray.add(s3);
        //将第一个子集合添加到大集合中
        bigArray.add(firstArray);

        //创建第二个子集合对象
        ArrayList<Student> secondArray=new ArrayList<Student>();
        //创建学生对象
        Student s4 = new Student("高圆圆", 30) ;
        Student s5 = new Student("邓超", 22) ;
        Student s6 = new Student("朱亚文", 26) ;
        // 给第二个子集合中添加元素
        secondArray.add(s4);
        secondArray.add(s5);
        secondArray.add(s6);
        //将第二个子集合添加到大集合中
        bigArray.add(secondArray);

        // 创建第三个子集合对象
        ArrayList<Student> thirdArray = new ArrayList<Student>();
        // 创建学生对象
        Student s7 = new Student("孙悟空", 988);
        Student s8 = new Student("猪八戒", 977);
        Student s9 = new Student("唐僧", 1000);
        // 给第二个子集合中添加元素
        thirdArray.add(s7);
        thirdArray.add(s8);
        thirdArray.add(s9);
        // 将第二个子集合添加到大集合中
        bigArray.add(thirdArray);

        //遍历大集合
        //ArrrayList<ArrayList<student>>
        for(ArrayList<Student> array:bigArray ){
            for(Student s:array){
                System.out.println(s);
                /*Student [name=二哈, age=3]
                  Student [name=金毛, age=4]
                  Student [name=柴犬, age=2]
                  Student [name=高圆圆, age=30]
                  Student [name=邓超, age=22]
                  Student [name=朱亚文, age=26]
                  Student [name=孙悟空, age=988]
                  Student [name=猪八戒, age=977]
                  Student [name=唐僧, age=1000]*/
            }
        }
    }
}
package org.westos_ArrayList集合的嵌套;

public class Student {

    private String name;
    private int age;
    public Student() {
        super();
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    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;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

}

第十五天/11.12

一、Set集合

Set接口：Set集合继承自Collection集合
Set:底层数据结构是一个哈希表,能保证元素是唯一的,元素不重复!
它通过它的子实现了HashSet集合去实例化,HashSet集合底层是HashMap集合的实例!
* HashSet集合的add()方法,底层是依赖于双列集合HashMap

package org.westos_set;

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

public class SetDemo {

    public static void main(String[] args) {
        Set<String> set=new HashSet<String>();
        //添加元素
        set.add("hello");
        set.add("abc");
        set.add("world");
        set.add("world");
        set.add("java");
        for(String s:set){
            System.out.println(s);
            /*hello
            abc
            java
            world*/         
        }
    }
}

二、HashSet集合

1、HashSet集合
* List集合和Set集合的区别?
* Set:元素是唯一的,无序性(存储和取出不一致)
* List:元素可以重复,有序性(存储和取出一致)

package org.westos_hashset;

import java.util.HashSet;

/**
 * 需求:使用HashSet集合存储自定义对象并遍历
 * 由于现在是自定义对象:在当前自定义对象的类中没有重写两个方法
 * hashCode和equals()方法;HashSet底层是依赖于这两个实现来保证元素的唯一性!
 * @author 小鑫
 *
 */
public class HashSetDemo {

    public static void main(String[] args) {

        //创建HashSet集合对象
        HashSet<Student> hs=new HashSet<Student>();
        // 创建学生对象
        Student s1 = new Student("高圆圆", 27);
        Student s2 = new Student("张三", 25);
        Student s3 = new Student("唐嫣", 26);
        Student s4 = new Student("邓超", 29);
        Student s5 = new Student("胡歌", 23);
        Student s6 = new Student("高圆圆", 27);
        //给集合添加元素
        hs.add(s1) ;
        hs.add(s2) ;
        hs.add(s3) ;
        hs.add(s4) ;
        hs.add(s5) ;
        hs.add(s6) ;
        for(Student s:hs){
            System.out.println(s.getName()+"---"+s.getAge());
            /*高圆圆---27
            邓超---29
            胡歌---23
            唐嫣---26
            张三---25*/

        }
    }
}
package org.westos_hashset;

public class Student {

    private String name;
    private int age;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    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;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.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 (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

}

2、LinkedHashSet集合:
* 由哈希表保证元素的唯一性
* 由链接列表来保证元素的有序性!

package org.westos_linkedhashset;

import java.util.LinkedHashSet;

/**
 * 具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
 * @author 小鑫
 *
 */
public class LinkedHashSetDemo {

    public static void main(String[] args) {

        //创建LinkedHashSet集合对象
        LinkedHashSet<String> link=new LinkedHashSet<String>();
        //给集合添加元素
        link.add("hello");
        link.add("world") ;
        link.add("world") ;
        link.add("Java") ;
        link.add("Java") ;
        link.add("JavaWeb") ;
        link.add("JavaWeb") ;

        for(String s:link){
            System.out.println(s);
            /*hello
            world
            Java
            JavaWeb*/
        }
    }
}

三、TreeSet集合

TreeSet:Set集合中的一个重点
*
* TreeSet集合底层是依赖于TreeMap的实例,而TreeMap

package org.westos_treeset;

import java.util.TreeSet;

/**
 * 对于TreeSet集合要实现自然排序,那么该集合该集合中存储自定义类型必须实现一个接口:Comparable,并且重写该接口中的compareTo()方法
 * @author 小鑫
 *
 */
public class TreeSetDemo {

    public static void main(String[] args) {

        //创建TreeSet集合对象
        TreeSet<Integer> ts=new TreeSet<Integer>();
        //添加元素
        ts.add(20);// Integer i = Integer.valueOf(20) ;自动拆装箱
        ts.add(18) ;
        ts.add(23) ;
        ts.add(22) ;
        ts.add(17) ;
        ts.add(24) ;
        ts.add(19) ;
        ts.add(18) ;
        ts.add(24) ;
        for(Integer i:ts){
            System.out.print(i+" ");
            //17 18 19 20 22 23 24 
        }
    }
}

2、红黑树结构
红黑树结构，也叫二叉树结构或者自平衡的二叉树结构。
存储元素的特点
第一次存储的元素作为根节点，后面依次存储的数和根节点比较。
如果比根节点小了，作为左孩子存到左边；如果比根节点大了，作为右孩子存到右边；如果与根节点相等，则不搭理该存储元素。
取出元素的特点
前序遍历，中序遍历，后续遍历，一次取出每一个元素
排序了：依赖于TreeMap

package org.westos_treeset;

import java.util.TreeSet;

/**
 * TreeSet集合存储自定义对象并遍历
 *      实现了compareable接口,重写了comapreTo()方法,里面的逻辑是一个排序条件:
 *      需求:
 *          按照学生的年龄从小到大进行排序:主要条件
 *          对于自定义对象什么情况下保证元素是唯一的
 *          成员变量的值相同,认为是同一个元素
 *          主要条件给定,需要分析次要条件
 *              
 *      一个类中的元素想要自然排序,那么必须实现Compareable接口,实现compareTo(类名 对象名){}方法
 *      
 * 按照正常存储对象的操作以及遍历对象出现了问题:
 * 类转换异常
 * java.lang.ClassCastException: org.westos_treeset.Student cannot be cast to java.lang.Comparable
 * @author 小鑫
 *
 */
public class TreeSetDemo2 {

    public static void main(String[] args) {

        //创建TreeSet集合对象
        TreeSet<Student> ts=new TreeSet<Student>();
        // 创建学生对象
        Student s1 = new Student("linqingxia", 28);
        Student s2 = new Student("fengqingy", 28);
        Student s3 = new Student("gaoyuanyuan", 27);
        Student s4 = new Student("liushishi", 26);
        Student s5 = new Student("wanglihong", 29);
        Student s6 = new Student("zhangguorong", 30);
        Student s7 = new Student("zhangguorong", 30);

        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        ts.add(s7);
        for(Student s:ts){
            System.out.println(s.getName()+"---"+s.getAge());
            /*liushishi---26
            gaoyuanyuan---27
            fengqingy---28
            linqingxia---28
            wanglihong---29
            zhangguorong---30*/

        }
    }
}
package org.westos_treeset;

public class Student implements Comparable<Student>{

    private String name;
    private int age;
    public Student() {
        super();
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    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;
    }

    //实现Comparable接口后自动生成
    @Override
    public int compareTo(Student s) {
        // 按照学生年龄从小到大排序
        int num = this.age - s.age;
        // 从大到小则为s.age-this.age
        int num2 = num == 0 ? this.name.compareTo(s.name) : num;
        return num2;
    }

}

4、需求:按照学生姓名长度从小到大进行排序

package org.westos_treesetTest;

import java.util.TreeSet;

public class TreeSetDemo {

    public static void main(String[] args) {
        // 创建TreeSet集合对象
        TreeSet<Student> ts = new TreeSet<Student>();

        // 创建几个学生对象
        Student s1 = new Student("gaoyuanyan", 27);
        Student s2 = new Student("liushishi", 22);
        Student s3 = new Student("fengqingy", 23);
        Student s4 = new Student("wuqilong", 35);
        Student s5 = new Student("gaoyuanyuan", 27);
        Student s6 = new Student("zhangguorong", 29);
        Student s7 = new Student("gaoyuanyuan", 26);

        // 给集合中添加元素
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        ts.add(s7);
        for(Student s:ts){
            System.out.println(s.getName()+"\t"+s.getAge()+"\t");
            /*wuqilong    35    
            fengqingy     23    
            liushishi     22    
            gaoyuanyan    27    
            gaoyuanyuan   26    
            gaoyuanyuan   27    
            zhangguorong  29    */

        }
    }
}
package org.westos_treesetTest;

public class Student implements Comparable<Student>{

    private String name;
    private int age;
    public Student() {
        super();
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    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;
    }
    @Override
    public int compareTo(Student s) {

        //return 0;
        int num=this.name.length()-s.name.length();
        int num2=num==0?this.name.compareTo(s.name):num;
        int num3=num2==0?this.age-s.age:num2;
        return num3;
    }

}

5、TreeSet集合的比较器排序
依赖于构造方法:
public TreeSet(Comparator comparator)
（1）方式一：自定义一个类，类实现Comparator接口，作为子实现类

package org.westos_treeset比较器排序;

import java.util.TreeSet;

/**
 * 需求:按照学生姓名长度从小到大进行排序
 * 
 * //元素唯一性:取决返回值是否为0
 * //方式一：自定义一个类，类实现Comparator接口，作为子实现类
 * author 小鑫
 *
 */
public class TreeSetDemo {

    public static void main(String[] args) {
        //方式一：自定义一个类，类实现Comparator接口，作为子实现类
        TreeSet<Student> ts=new TreeSet<Student>(new MyComparator());
        // 创建学生对象
        Student s1 = new Student("gaoyuanyan", 27);
        Student s2 = new Student("liushishi", 22);
        Student s3 = new Student("fengqingy", 23);
        Student s4 = new Student("wuqilong", 35);
        Student s5 = new Student("gaoyuanyuan", 27);
        Student s6 = new Student("zhangguorong", 29);
        Student s7 = new Student("gaoyuanyuan", 26);

        // 添加元素
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        ts.add(s7);

        // 增强for遍历
        for (Student s : ts) {
            System.out.println(s.getName() + "\t" + s.getAge());
            /*wuqilong      35
            fengqingy       23
            liushishi       22
            gaoyuanyan      27
            gaoyuanyuan     26
            gaoyuanyuan     27
            zhangguorong    29*/

        }

    }
}
package org.westos_treeset比较器排序;

import java.util.Comparator;

public class MyComparator implements Comparator<Student>{

    @Override
    public int compare(Student s1, Student s2) {
        //return 0;
        //按照学生姓名长度从小到大排序
        //this--->s1
        //s--->s2
        int num1=s1.getName().length()-s2.getName().length();
        int num2=num1==0 ? s1.getName().compareTo(s2.getName()):num1;
        int num3=num2==0?s1.getAge()-s2.getAge():num2;
        return num3;

    }

}
package org.westos_treeset比较器排序;

public class Student {

    private String name;
    private int age;
    public Student() {
        super();

    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    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;
    }

}

（2）

package org.westos_treeset比较器排序;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * //方式2:可以使用接口的匿名内部类来实现:开发中,由于减少代码书写量,
 * 不需要自定义接口的子实现类,直接这种格式!
 * @author 小鑫
 *
 */
public class TreeSetDemo2 {

    public static void main(String[] args) {
        /**
         * 格式：
         * new 接口名或者类名(){
         *    重写方法()
         * }
         */
        TreeSet<Student> ts=new TreeSet<Student>(new Comparator<Student>(){

            @Override
            public int compare(Student s1, Student s2) {
                int num1=s1.getName().length()-s2.getName().length();
                int num2=num1==0 ? s1.getName().compareTo(s2.getName()):num1;
                int num3=num2==0?s1.getAge()-s2.getAge():num2;
                return num3;
            }

        });

        //创建学生对象
        Student s1 = new Student("gaoyuanyan", 27) ;
        Student s2 = new Student("liushishi", 22);
        Student s3 = new Student("fengqingy", 23) ;
        Student s4 = new Student("wuqilong", 35) ;
        Student s5 = new Student("gaoyuanyuan",27) ;
        Student s6 = new Student("zhangguorong",29) ;
        Student s7 = new Student("gaoyuanyuan",26) ;


        //添加元素
        ts.add(s1) ;
        ts.add(s2) ;
        ts.add(s3) ;
        ts.add(s4) ;
        ts.add(s5) ;
        ts.add(s6) ;
        ts.add(s7) ;

        //增强for遍历
        for(Student s : ts){
            System.out.println(s.getName()+"\t"+s.getAge());
            /*wuqilong      35
            fengqingy       23
            liushishi       22
            gaoyuanyan      27
            gaoyuanyuan     26
            gaoyuanyuan     27
            zhangguorong    29*/

        }
    }
}
package org.westos_treeset比较器排序;

public class Student {

    private String name;
    private int age;
    public Student() {
        super();

    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    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;
    }

}

6、键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台

package org.westos_treeset五个学生成绩排序;

import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

/**
 * 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台
 *  
 * 分析：
 *    1）创建学生类，提供姓名，总分，语文成绩，数学成绩，英语成绩
 *    2）创建TreeSet集合对象
 *    3）分析条件：主要条件：总分
 *             次要条件：总分相同，语文成绩...
 *    4）键盘录入，for循环
 *    5）输出
 * @author 小鑫
 *
 */
public class TreeSetTest {

    public static void main(String[] args) {
        TreeSet<Student> ts=new TreeSet<Student>(new Comparator<Student>(){

            @Override
            public int compare(Student s1, Student s2) {
                //return 0;
                int num1=s2.getSum()-s1.getSum();
                int num2=num1==0 ? s2.getChinese()-s1.getChinese():num1;
                int num3=num2==0 ? s2.getMath()-s1.getMath():num2;
                int num4=num3==0 ? s2.getEnglish()-s1.getEnglish():num3;
                return num4;
            }

        });
        System.out.println("录入学生信息开始：");
        for(int i=1;i<=5;i++){
            Scanner sc=new Scanner(System.in);
            System.out.println("请输入第"+i+"个学生姓名");
            String name=sc.nextLine();
            System.out.println("请输入第"+i+"个学生语文成绩");
            String chineseString = sc.nextLine();
            System.out.println("请输入第"+i+"个学生数学成绩");
            String mathString = sc.nextLine();
            System.out.println("请输入第"+i+"个学生英语成绩");
            String englishString = sc.nextLine();

            //创建学生对象，把信息封装到学生对象中
            Student s=new Student();
            s.setName(name);
            s.setChinese(Integer.parseInt(chineseString));
            s.setMath(Integer.parseInt(mathString));
            s.setEnglish(Integer.parseInt(englishString));
            ts.add(s);
        }

        System.out.println("学生信息录入结束");
        System.out.println("学生信息总分从高到底排列数学如下:");
        System.out.println("姓名\t  总分\t  语文成绩\t  数学成绩\t  英语成绩");

        for(Student s:ts){
            System.out.println(s.getName()+"\t"+s.getSum()+"\t"+s.getChinese()+"\t"+s.getMath()+"\t"+s.getEnglish());
        }
    }
}
package org.westos_treeset五个学生成绩排序;

public class Student {

    private String name;
    private int chinese;
    private int math;
    private int english;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int chinese, int math, int english) {
        super();
        this.name = name;
        this.chinese = chinese;
        this.math = math;
        this.english = english;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getChinese() {
        return chinese;
    }
    public void setChinese(int chinese) {
        this.chinese = chinese;
    }
    public int getMath() {
        return math;
    }
    public void setMath(int math) {
        this.math = math;
    }
    public int getEnglish() {
        return english;
    }
    public void setEnglish(int english) {
        this.english = english;
    }
    //总分方法
    public int getSum(){
        return this.chinese+this.math+this.english;
    }
}

四、用户注册登录案例

如何分析需求:
    用户登陆注册案例:
        符号面向对象分析特点:
                1)当前需求中有哪些类?
                2)知道某些类,这些类中有什么东西
                3)这些类和类之间有什么关系

    1)有哪些类:
        用户类
        用户的基本信息描述:
            在这个基本描述类中提供:成员:username password ,提供set()/get()方法
                具体的划分:
                    按照功能划分:
                        注册功能
                        登陆功能

                用户操作的接口:
                    注册();登陆();
                用户操作的接口实现类:
                    注册(){..}
                    登陆(){..}
                用户要进行操作:
                    注册
                    登陆
                测试类:
                    Usertest:用户测试类:
                        用户类和测试类:
                            在测试类中需要创建用户类对象,来操作登陆和注册功能

        经常会按照功能划分,模块划分:
                1)先按照功能划分,在按照模块划分
                2)先模块划分,功能划分.           


给每一个包命名的时候:
    用户的描述类:user类
        包:公司域名.entity;实体类
            org.westos.entity;
    用户操作的接口:
        包:公司域名.dao:里面放的 是接口
           org.westos.dao :接口层
    用户操作接口的实现类:
        包:
            org.westos.dao.impl:业务逻辑层:接口子实现类
    测试类:
        包:
            org.westos.test:需要针对注册或者的登陆进行测试

package org.westos.entity;
/**
 * 用户实体类
 * @author 小鑫
 *
 */
public class User {

    private String username;
    private String password;
    public User() {
        super();
    }
    public User(String username, String password) {
        super();
        this.username = username;
        this.password = password;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }

}

package org.westos.dao;

import org.westos.entity.User;

public interface UserDao {

    /**
     * 该方法是用户登录功能
     * @param username
     *    被传递的用户名
     * @param password
     *    被传递的用户密码
     * @return
     *    返回值表示最终是否登录成功
     */
    public abstract boolean isLogin(String username,String password);


    /**
     * 该方法表示用户注册功能
     * @param user
     *    表示需要注册的用户
     */
    public abstract void regist(User user);

}

package org.westos.impl;

import java.util.ArrayList;

import org.westos.dao.UserDao;
import org.westos.entity.User;
/**
 * 这是用户操作的接口实现类:业务逻辑层
 * @author 小鑫
 * @version V1.0
 */
public class UserDaoImpl implements UserDao{

    //为了多个功能使用这个集合中的用户，将集合的对象定义到成员变量中
    //为了不让外界修改，private修饰
    //将集合对象共享，注册和登录使用同一个集合对象
    private static ArrayList<User> array=new ArrayList<User>();

    @Override
    public boolean isLogin(String username, String password) {
        //登录，需要将注册的用户全部遍历出来，创建ArrayList集合
        //假设：定义标记，用户登录不成功
        boolean flag=false;

        //需要遍历集合获取每一个用户
        for(User u:array){
            if(u.getUsername().equals(username) && u.getPassword().equals(password)){
                //修改标记
                flag=true;
                break;
            }
        }
        return flag;
    }

    @Override
    public void regist(User user) { 
        //创建用户集合
        //将用户存储到集合中
        array.add(user);
    }

}

package org.westos.game;

import java.util.Scanner;

public class GuessNumberGame {

    private GuessNumberGame(){

    }
    //静态功能
    public static void start(){
        //产生随机数
        int number=(int) (Math.random()*100+1);
        int count=0;
        while(true){
            Scanner sc=new Scanner(System.in);
            System.out.println("请您输入一个数字");
            int guessNumber = sc.nextInt();
            count++;
            if(guessNumber>number){
                System.out.println("您猜的数据"+guessNumber+"大了");
            }else if(guessNumber<number){
                System.out.println("您猜的数据"+guessNumber+"小了");
            }else{
                System.out.println("恭喜您！第"+count+"次猜中了！");
                break;
            }
        }
    }
}

package org.westos.test;

import java.util.Scanner;

import org.westos.dao.UserDao;
import org.westos.entity.User;
import org.westos.game.GuessNumberGame;
import org.westos.impl.UserDaoImpl;

/**
 * 用户的测试类
 * 
 * 注意事项:
 *      1)登陆功能和注册功能使用的是同一个集合,将集合的对象的数据共享,应该用static
 *      2):登陆成功应该退出界面,
 *          现在使用switch语句,遇见break,只是结束switch语句并不能结束循环语句----->
 * @author 小鑫
 *
 */
public class UserTest {

    public static void main(String[] args) {

        while(true){
            //给出选择界面
            System.out.println("-------欢迎光临-------");
            System.out.println("请选择");
            System.out.println("1  注册");
            System.out.println("2  登录");
            System.out.println("3  退出");

            //创建键盘录入
            Scanner sc=new Scanner(System.in);
            //根据不同的选择给出界面,简单分析下
            //为了方便数据的录入,就是用String类型接收
            String choiceString=sc.nextLine();
            //由于用户都需要调用注册和登录功能，通过接口多态，将该用户操作的登录对象定义在switch外边
            UserDao ud=new UserDaoImpl();

            switch(choiceString){
            case "1":
                //注册界面
                System.out.println("------注册界面------");
                System.out.println("请您输入用户名：");
                String newUserName=sc.nextLine();
                System.out.println("请输入密码");
                String newPassWord = sc.nextLine();

                //将用户名和密码封装到用户对象中
                User u=new User();
                u.setUsername(newUserName);
                u.setPassword(newPassWord);
                //调用注册功能
                //接口多态
                ud.regist(u);
                System.out.println("注册成功");
                break;
            case "2":
                //登录界面
                System.out.println("-------登录界面-------");
                System.out.println("请输入用户名");
                String username = sc.nextLine();
                System.out.println("请输入密码");
                String password = sc.nextLine();

                //调用登录功能
                boolean flag = ud.isLogin(username, password);
                if(flag){
                    System.out.println("登陆成功，开始玩游戏吗？");
                    System.out.println("玩游戏吗？y/n");
                    while(true){
                        String resultString = sc.nextLine();
                        if(resultString.equalsIgnoreCase("y")){
                            //开始玩游戏
                            GuessNumberGame.start();
                            System.out.println("还玩吗？y/n");
                        }else{
                            break;
                        }
                    }
                    System.out.println("谢谢使用，下次再来");
                    //break只是结束switch语句并不能结束循环
                    System.exit(0);
                }else{
                    System.out.println("用户名或密码错误，请重新登录");
                }
                break;
            case "3":
                default:
                    System.out.println("谢谢使用，下次再来！");
                    System.exit(0);
                    break;
            }
        }
    }
}

运行如下：

-------欢迎光临-------
请选择
1  注册
2  登录
3  退出
1
------注册界面------
请您输入用户名：
sunshine
请输入密码
12345
注册成功
-------欢迎光临-------
请选择
1  注册
2  登录
3  退出
2
-------登录界面-------
请输入用户名
sunshine
请输入密码
123123
用户名或密码错误，请重新登录
-------欢迎光临-------
请选择
1  注册
2  登录
3  退出
2
-------登录界面-------
请输入用户名
sunshine
请输入密码
12345
登陆成功，开始玩游戏吗？
玩游戏吗？y/n
y
请您输入一个数字
50
您猜的数据50大了
请您输入一个数字
25
您猜的数据25大了
请您输入一个数字
10
您猜的数据10小了
请您输入一个数字
15
您猜的数据15大了
请您输入一个数字
13
您猜的数据13大了
请您输入一个数字
11
恭喜您！第6次猜中了！
还玩吗？y/n
n
谢谢使用，下次再来