Java day14-15

Day14

一、集合

1.ArrayList:

底层数据结构是数组的形式,满足数组结构的特点:查询快,增删慢

    从线程安全问题来看:线程不安全的,不同步,执行效率高

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

    存储字符串并遍历

importjava.util.ArrayList;

importjava.util.Iterator;

publicclass ArrayListDemo {

    public static void main(String[] args){

        //创建一个ArrayList集合对象

        ArrayList array = new ArrayList();

        //添加元素

        array.add("hello");

        array.add("hello");

        array.add("world");

        array.add("world");

        array.add("java");

        array.add("java");

        Iteratorit = array.iterator();

        while(it.hasNext()){

            String s = (String)it.next();

            System.out.println(s);

        }

    }

}

2.Vector:

底层数据结构是数组的形式,查询快,增删慢

    从线程角度看:线程安全的类,同步,执行效率低

    特有功能:

            public void addElement(Eobj)------->相当于:add(Objecte)

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

            Enumeration<E>接口:向量的组件枚举有两个方法

                    booleanhasMoreElements():------>相当于:hasNext()

                    ObjectnextElement():----------->相当于:next();

    源码:

        synchronized:同步锁(多线程中讲):它就可以保证线程安全!

     public synchronized void addElement(E obj) {//由同步代码块演变过来的同步方法

            modCount++;

            ensureCapacityHelper(elementCount+ 1);

            elementData[elementCount++]= obj;

    }

 

importjava.util.Enumeration;

importjava.util.Vector;

publicclass VectorDemo {

    public static void main(String[] args) {

        //创建一个Vector集合对象

        Vector v = new Vector();

        //添加元素

        //public void addElement(E obj)

        v.addElement("hello");

        v.addElement("hello");

        v.addElement("world");

        v.addElement("Java");

        Enumeration en = v.elements();

        //遍历元素

        while(en.hasMoreElements()){

            //获取元素

            String s = (String)en.nextElement();

            System.out.println(s);

        }

    }

}

3.LinkedList:

底层数据结构是链接列表,特点:查询慢,增删快

    从线程角度看:线程不安全的一个类,不同步,执行效率高

    特有功能:

        添加功能:

            public void addFirst(E e)将指定元素插入此列表的开头。

            public void addLast(E e)将指定元素添加到此列表的结尾。

        获取功能:

            public Object getFirst()返回此列表的第一个元素

            public Object getLast()返回此列表的最后一个元素。

        删除功能:

            public Object removeFirst()移除并返回此列表的第一个元素。

            public Object removeLast()移除并返回此列表的最后一个元素。

importjava.util.LinkedList;

publicclass LinkedListDemo {

    public static void main(String[] args) {

        //创建LinkedList集合

        LinkedList link = new LinkedList();

        //添加元素

        link.addFirst("hello");

        link.addFirst("world");

        link.addFirst("Java");

        //public void addFirst(E e)将指定元素插入此列表的开头

        /*link.addFirst("android");

        link.addLast("JavaWeb");*/

        /*

        Object obj = link.getFirst();

        System.out.println(obj);

        Object obj2 = link.getLast();

        System.out.println(obj2);*/

        /*System.out.println("removeFirst:"+link.removeFirst());

        System.out.println("removeLast:"+link.removeLast());*/

        //输出集合

        System.out.println("link:"+link);

    }

}

4.总结List集合的子实现类的特点:

ArrayList:

底层数据结构是数组的形式,足数组结构的特点:查询快,增删慢

    从线程安全问题来看:线程不安全的,不同步,执行效率高

Vector:

    底层数据结构是数组的形式,查询快,增删慢

    从线程角度看:线程安全的类,同步,执行效率低

LinkedList:

    底层数据结构是链接列表,特点:查询慢,增删快

    从线程角度看:线程不安全的一个类,不同步,执行效率高

    如果实现多线程程序,一般要是安全的类:

    StringBuffer,Vector<E>,hashtable<K,V>

                    synchronized(同步锁对象){

                        代码;

                    }

    如果在一般的需求中没有指明使用集合去完成,都默认采用ArrayList

    如果需求中要考虑线程安全,那么使用Vector集合!

    笔试过程中,一些需求用到集合:就是用ArrayList

5.需求:ArrayList去除集合中字符串的重复元素

    1)首先创建一个集合

    2)给集合中添加很多重复元素

    3)再次创建一个新集合

    4)获取迭代器遍历

    5)获取到该集合中的每一个元素

     判断新集合中是否包含这些有素

     有,不搭理它

     没有.说明不重复,添加进来

    6)遍历新集合

importjava.util.ArrayList;

importjava.util.Iterator;

publicclass ArrayListTest {

    public static void main(String[] args) {

        //1)创建一个集合

        ArrayList array = new ArrayList();

        //2)给集合中添加多个重复元素

        array.add("hello");

        array.add("hello");

        array.add("hello");

        array.add("world");

        array.add("world");

        array.add("world");

        array.add("Java");

        array.add("Java");

        array.add("hello");

        array.add("Javaweb");

        array.add("JavaEE");

        array.add("JavaEE");

        //3)创建一个新的集合

        ArrayList newArray = new ArrayList();

        //4)遍历旧集合,获取当前迭代器对象

        Iteratorit = array.iterator();

        while(it.hasNext()){

            Strings = (String) it.next();

            //拿到了每一个字符串元素

            //判断新集合是否包含旧集合中的元素

            if(!newArray.contains(s)){

                //不包含,就将元素直接添加到新集合中

                newArray.add(s);

            }

        }

        //遍历新集合

        Iterator it2 = newArray.iterator();

        while(it2.hasNext()){

            Strings = (String) it2.next();

            System.out.println(s);

        }

    }

}

6.需求:ArrayList去除集合中字符串的重复元素,

附件条件:不能创建新集合!

importjava.util.ArrayList;

importjava.util.Iterator;

publicclass ArrayListTest {

    public static void main(String[] args){

        //创建一个集合,添加重复元素

        ArrayList array = new ArrayList();

        array.add("hello");

        array.add("hello");

        array.add("hello");

        array.add("world");

        array.add("world");

        array.add("world");

        array.add("Java");

        array.add("Java");

        array.add("hello");

        array.add("Javaweb");

        array.add("JavaEE");

        array.add("JavaEE");

        /**

         *由选择排序的逻辑想到:

         *拿0索引对应的元素依次和后面索引对应的元素进行比较

         *同理,1索引对应的元素和后面.....

         *前面的索引对应的元素如果和后面索引对应的元素重复了,从集合移出后面索引的对应的元素

         */

        for(int x = 0 ;x <array.size() -1 ; x++){

            for(int y= x +1 ; y <array.size();y++){

                //判断

                if(array.get(x).equals(array.get(y))){

                    array.remove(y);

                    y -- ;

                }

            }

        }

        //遍历集合

        Iteratorit = array.iterator() ;

        while(it.hasNext()){

            Strings = (String) it.next();

            System.out.println(s);

        }

    }

}

7.需求：ArrayList去除集合中自定义对象的重复值(对象的成员变量值都相同)

发现问题:

    使用刚才创建新集合的思想,逻辑步骤和去除集合中重复的字符串是一样,但是出现了并没有将自定义对象的重复值(成员变量值一样)并没有去除掉

   contains()底层依赖于一个equals()方法,equals()方法是Object类的中的方法,该法默认比较的是对象的地址值是否相同,必须要重写Object中的eqauls()方法,才能比较内容是否相同;

在自定义对象的类中重写Object中的equasl()方法,才能比较成员变量的值是否相同

importjava.util.ArrayList;

importjava.util.Iterator;

publicclass ArrayListTest3 {

    public static void main(String[] args) {

        //创建一个ArrayList集合对象

        ArrayList array = new ArrayList();

        //2)创建学生对象

        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);

        //3)创建一个新集合

        ArrayList newArray = new ArrayList();

        //遍历旧集合,获取迭代器对象

        Iterator it = array.iterator();

        while(it.hasNext()){

            Student s = (Student) it.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());

        }

    }

}

classStudent {

    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 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;

    }

}

8.需求:使用LinkedList模拟一个栈结构的特点

表达的意思:自定义栈集合类,然后使用LinkedList的一些特有功能模拟栈结构特点

importjava.util.Iterator;

importjava.util.LinkedList;

publicclass LinkedListDemo {

    public static void main(String[] args){

        //创建LinkedList集合的对象

        LinkedList link = new LinkedList();

        //LinkedList集合的特有功能:addFirst(Object e)

        //栈结构的特点:先进后出

        link.addFirst("hello");

        link.addFirst("world");

        link.addFirst("java");

        Iterator it = link.iterator();

        while(it.hasNext()){

            String s = (String)it.next();

            System.out.println(s);

        }

    }

}

9.自定义栈集合

importjava.util.LinkedList;

publicclass MyStackDemo {

    public static void main(String[] args) {

        //创建自定义栈集合类的对象

        MyStack ms = new MyStack();

        //调用添加功能

        ms.add("hello");//link.addFier("hello")

        ms.add("world");

        ms.add("java");

        //当前栈集合中有元素了

        //获取集合集合中的元素

        //给当前集合对象来判断:判断集合是否为空

        while(!ms.isEmpty()){

            System.out.println(ms.get());

        }

    }

}

classMyStack {

    //成员变量

    private LinkedList link;

    //无参构造

    //通过无参进行LinkedList集合对象 的创建

    public MyStack(){

        link = new LinkedList();

    }

    //添加功能

    public void add(Object obj){

        link.addFirst(obj);//向集合中列表插入到第一个元素

    }

    //获取功能

    public Object get(){

        return link.removeFirst();//删除集合列表中的第一个元素,返回值是被删除的元素

    }

    //定义判断集合是否为空

    public boolean isEmpty(){

        return link.isEmpty();

    }

}

二、泛型

1. 泛型:把数据类型的明确工作提供提前到了创建对象或者是调用方法的时期明确的一种特殊类型.参数化类型,可以像参数一样进行传递

   格式:

        <引用类型>:泛型只能放引用类型

泛型好处:

    1)将运行时期异常提前到了编译时期

    2)解决了黄色警告线问题

    3)获取数据的时候,不用强制类型转换了

泛型的应用:

    一般情况:泛型可以应用在接口,类,或者方法上;主要用在集合中比较多!

importjava.util.ArrayList;

importjava.util.Iterator;

publicclass GenericDemo {

    public static void main(String[] args) {

        //创建一个ArrayList集合对象

        ArrayList<String> array = newArrayList<String>();//jdk7特性:泛型推断!:建议:后面永远给出类型

        //给集合中添加元素

        array.add("hello");

        array.add("world");

        array.add("java");

        //获取迭代器对象并遍历

        Iterator<String> it =array.iterator();

        //遍历

        while(it.hasNext()){

            //不用强制类型转换了

            String s = it.next() ;

            System.out.println(s);

        }

    }

}

2. 泛型可以提供程序的安全性

早期的时候,用Object类型代表任意的类型

 向上转型是不会出现问题的,但是向下转型的时候,由于隐藏了类型转换,导致出现错误!

 JDK5以后,提供了泛型可以解决程序的安全性

publicclass ObjectToolDemo {

    public static void main(String[] args) {

        //创建ObjectTool对象

        ObjectTool ot = new ObjectTool();

        //设置数据

        ot.setObj(27);

        //获取

        Integer i = (Integer) ot.getObj();//向下转型

        System.out.println("年龄是:"+i);

        ObjectTool ot2 = new ObjectTool();

        //设置

        ot2.setObj("Tom") ;

        //获取

        String str = (String) ot2.getObj();//类型转换了:向下转型:隐藏了类型转换

        System.out.println("姓名是:"+str);

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

        ObjectTool ot3 = new ObjectTool();

        ot3.setObj("邓超");

        Integer ii = (Integer) ot3.getObj();//强制类型转换的接收类型不匹配:程序不安全

        System.out.println("姓名是:"+ii);

    }

}

classObjectTool {

    private Object obj;

    //获取

    public Object getObj(){

        return obj;

    }

    //设置

    public void setObj(Object obj){

        this.obj = obj;

    }

}

3. 工具类

使用泛型:将泛型定义在类上:解决以上可能出现错误

实际开发中根据具体类型在测试中书写

publicclass ObjectTool<T> {

    private T obj;

    //获取

    public T getObj(){

        return obj;

    }

    //设置

    public void setObj(T obj){

        this.obj = obj;

    }

}

//测试类

publicclass ObjectToolDemo{

    public static void main(String[] args) {

        //创建ObjectTool<T>对象

        ObjectTool<String> ot = newObjectTool<String>();

        //设置数据

        ot.setObj("Tom");

        //获取数据

        String name = ot.getObj();

        System.out.println("姓名是:" +name);

        //创建对象

        ObjectTool<Integer> ot2 = newObjectTool<Integer>();

        //设置数据

        ot2.setObj(22);

        //获取数据

        Integer i = ot2.getObj();

        System.out.println("年龄是:"+i);

    }

}

4. 把泛型定义在成员方法上

publicclass ObjectTool<T> {

    //形式参数是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 void show(T t){

        System.out.println(t);

    }

}

//测试类

publicclass ObjectToolDemo{

        public static void main(String[] args){

//          创建工具类对象

            ObjectTool ot = new ObjectTool();

            ot.show("hello");

            ot.show(100);

            ot.show(true);

}

}

简化，泛型可以直接定义在方法上

publicclass ObjectTool{

    //将泛型定义在方法上

    public <T> void show(T t){

        System.out.println(t);

    }

}

//测试类

publicclass ObjectToolDemo {

        public static void main(String[] args) {

//创建工具类对象

            ObjectTool ot = new ObjectTool();

            ot.show("hello");

            ot.show(true);

            ot.show(100);

        }

}

5. 接口加入泛型:

第一种情况:接口的子实现类已经知道传递的是什么数据类型

/*publicclass InterImpl<String> implements Inter<String> {

    public void show(String t) {

        System.out.println(t);

    }

}*/

第二种情况:接口的子实现类在实现接口的时候,不知道具体的数据类型是什么

在测试类的时候,传入具体数据类型

//面向接口编程

//JavaEE:Sping框架 :AOP:面向切面编程

publicclass InterImpl<T> implements Inter<T>{

    public void show(T t) {

        System.out.println(t);

    }

}

//把泛型定义在接口上

publicinterface Inter<T> {

    public abstract void show(T t);

}

//测试类

publicclass InterDemo {

    public static void main(String[] args) {

        //创建接口对象

        //第一种情况：

        Inter<String> i = newInterImpl<String>();

        i.show("hello");

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

        //第二种情况:

        Inter<Integer> i2 = newInterImpl<Integer>();

        i2.show(21);

        Inter<String> i3 = newInterImpl<String>();

        i3.show("Tom");

    }

}

6.

泛型的高级:通配符

  <?> :可以是任意类型,包括Object类型以及任意的Java类

  <? extends E>:向下限定,E类型以及E类型的子类

  <? super E>:向上限定,E类型以及E类型的父类

importjava.util.ArrayList;

importjava.util.Collection;

publicclass GenericDemo {

    public static void main(String[] args) {

        //创建Collection集合的对象

        //前后的数据类型保持一致

//Collection<Object> c1 = newArrayList<Animal>();

//Collection<Object> c2 = newArrayList<Cat>();

//Collection<Object> c3 = newArrayList<Dog>();

        Collection<Object> c3 = newArrayList<Object>();

        // <?> :可以是任意类型,包括Object类型以及任意的Java类

        Collection<?> c4 = newArrayList<Object>();

        Collection<?> c5 = newArrayList<Animal>();

        Collection<?> c6 = newArrayList<Cat>();

        Collection<?> c7 = newArrayList<Dog>();

        //<? extends E>:向下限定,E类型以及E类型的子类

        Collection<? extends Object> c8 =new ArrayList<Object>();

        Collection<? extends Animal> c9 =new ArrayList<Animal>();

//Collection<? extends Animal> c10 =new ArrayList<Object>();

        Collection<? extends Object> c11 =new ArrayList<Cat>();

        //<? super E>:向上限定,E类型以及E类型的父类

        Collection<? super Animal> c12 =new ArrayList<Object>();

        Collection<? super Animal> c13 =new ArrayList<Animal>();

//Collection<? super Animal> c14 =new ArrayList<Dog>();

    }

}

//自定义两个类

classAnimal{

}

classCat extends Animal{

}

classDog extends Animal{

}

三、jdk5 news

1.JDK5以后提供了很多特性:

   泛型,增强for循环,可变参数,静态导入,自动拆装箱,枚举等的呢过

   增强for循环

   书写格式:

       for(集合或者数组中的数据类型变量名:集合或者数组的对象名){

                    输出变量名;

            }

   增强for循环的弊端:

                遍历数组或者集合的时候,数组对象或者集合对象不能为null

                如果对象为空,一般加上非空判断

   增强for循环的出现就是为了替代迭代器遍历集合的,以后开发中就是用增强for遍历元素

importjava.util.ArrayList;

importjava.util.Iterator;

publicclass ForDemo {

    public static void main(String[] args) {

        //定义一个数组,静态初始化

        int[] arr = {11,22,33,44,55};

        //普通for循环的遍历

        for(int x = 0 ; x < arr.length ; x++){

            System.out.println(arr[x]);

        }

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

        //使用增强for遍历

        for(int i :arr){

            System.out.println(i);

        }

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

        //定义一个字符串数组,并遍历

        String[] strArray ={"hello","world","java"};

        //直接使用增强for循环

        for(String s : strArray){

            System.out.println(s);

        }

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

        //创建ArrayList集合对象,添加并遍历元素

        ArrayList<String> array = newArrayList<String>();

        //添加元素

        array.add("hello");

        array.add("world");

        array.add("java");

        //之前:迭代器遍历

        /*Iterator<String> it =array.iterator();

        while(it.hasNext()){

            String s = it.next();

            //判断当前集合中是否有"world",如果有就添加元素

            //java.util.ConcurrentModificationException

            if("world".equals(s)){

                //使用集合添加元素

                array.add("javaee");

            }

        }*/

        //使用增强for遍历该集合

        for(String s :array){

            //获取到每一个元素

           

            //判断当前集合中是否有"world",如果有就添加元素

            if("world".equals(s)){

                array.add("javaee");

            }

        }

    }

}

2.使用ArrayList集合存储自定义对象并遍历

    1)toArray()

    2)Collection集合的迭代器:Iterator iterator();

    3)List集合的迭代器:ListIterator listiterator();

    4)普通for循环:size()和get(int index)相结合

    5)增强for循环

importjava.util.ArrayList;

importjava.util.Iterator;

publicclass ForDemo{

    public static void main(String[] args) {

        // 创建ArrayList集合

        ArrayList<Student> array = newArrayList<Student>();

        // 创建学生对象

        Student s1 = new Student("Tom",23);

        Student s2 = new Student("Tom",20);

        Student s3 = new Student("Anny",22);

        Student s4 = new Student("Anny",21);

        // 给集合中添加元素

        array.add(s1);

        array.add(s2);

        array.add(s3);

        array.add(s4);

        //普通for循环:size()和get(intindex)相结合

        for(int x =0 ; x < array.size() ; x++){

            Student s = array.get(x);

            System.out.println(s.getName()+"---"+s.getAge());

        }

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

        //Collection集合的迭代器:Iterator iterator();

        Iterator<Student> it =array.iterator();

        while(it.hasNext()){

            Student s = it.next();

            System.out.println(s.getName()+"----"+s.getAge());

        }

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

        //增强for遍历

        for(Student s : array){

            System.out.println(s.getName()+"----"+s.getAge());

        }

    }

}

classStudent {

    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;

    }

}

Day15

一、Set

1.Set接口:Set集合继承自Collection集合

Set:底层数据结构是一个哈希表,能保证元素是唯一的,元素不重复!

   它通过它的子实现了HashSet集合去实例化,HashSet集合底层是HashMap集合的实例!

需求:Set集合存储字符串元素并遍历

importjava.util.HashSet;

importjava.util.Set;

publicclass SetDemo {

    public static void main(String[] args) {

        //创建Set集合对象

        Set<String> set = newHashSet<String>();

        //添加元素

        set.add("hello");

        set.add("java");

        set.add("java");

        set.add("world");

        set.add("world");

        set.add("world");

        //增强for遍历

        for(String s :set){

            System.out.println(s);

        }

    }

}

2. Set集合的子实现类:

   此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。。

HashSet集合的add()方法,底层是依赖于双列集合HashMap<K,V>的put(K key,V value)来实现的

put(K key,V value):底层又依赖于HashCode()和equals()方法,传递添加元素的时候,首先判断的是每一个元素对应的HashCode值是否一样,如果HashCode值一样,还比较他们的equals()方法,由于现在集合存储的是String类型,String类型本身重写了equals()方法,所以,默认比较的是内容是否相同,如果内容相同,这里最终返回的就是第一次存储的那个元素,由这两个方法保证元素唯一性

importjava.io.Serializable;

importjava.util.HashSet;

publicclass SetDemo implements Serializable{

    //private int num;//setDemo.class 固定id=100

     transient int num;

    public static void main(String[] args) {

        //创建HashSet集合对象

        HashSet<String> hs = newHashSet<String>();

        //给该集合中添加元素

        hs.add("hello");

        hs.add("world");

        hs.add("world");

        hs.add("Java");

        hs.add("Java");

        //遍历

        for(String s :hs){

            System.out.println(s);

        }

    }

}

3.使用HashSet集合存储自定义对象并遍历

   List集合和Set集合的区别?

   Set:元素是唯一的,无序性(存储和取出不一致)

   List:元素可以重复,有序性(存储和取出一致)

   由于现在是自定义对象:在当前自定义对象的类中没有重写两个方法

   hashCode和equals()方法;HashSet底层是依赖于这两个实现来保证元素的唯一性!

importjava.util.HashSet;

publicclass HashSetDemo {

    public static void main(String[] args) {

        //创建一个HashSet集合对象

        HashSet<Student> hs = newHashSet<Student>() ;

        //创建学生对象

        Student s1 = new Student("Tom",23);

        Student s2 = new Student("张三", 22);

        Student s3 = new Student("李四", 25);

        Student s4 = new Student("邓超", 27);

        Student s5 = new Student("胡歌", 23);

        Student s6 = new Student("Anny",29);

        //给集合中添加学生对象

        hs.add(s1);

        hs.add(s2);

        hs.add(s3);

        hs.add(s4);

        hs.add(s5);

        hs.add(s6);

        //增强for遍历

        for(Student s : hs){

            System.out.println(s.getName()+"---"+s.getAge());

        }

    }

}

//学生类

publicclass 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;

    }

    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;

    }

}

4. LinkedHashSet集合:

  由哈希表保证元素的唯一性

  由链接列表来保证元素的有序性!

importjava.util.LinkedHashSet;

publicclass LinkedHashSetDemo {

    public static void main(String[] args) {

        //创建LinkedHashSet集合对象

        LinkedHashSet<String> link = newLinkedHashSet<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);

        }

    }

}

5.TreeSet集合底层是依赖于TreeMap的实例,而TreeMap<K,V>是依赖于红黑树结构实现的

 分两种:

     自然排序:

     比较器排序

 这种排序的使用取决于开发者是用什么样的构造方法

TreeSet存储Integer类型添加以下元素

20,18,23,22,17,24,19,18,24

 

importjava.util.TreeSet;

publicclass TreeSetDemo {

    public static void main(String[] args){

        //创建TreeSet集合对象

        //构造方法:

        //public TreeSet():无参构造:根据其元素的自然顺序进行排序

        //publict TreeSet(Comparaptr<E>com)

        TreeSet<Integer> ts = newTreeSet<Integer>();//

        //添加元素

        //20,18,23,22,17,24,19,18,24

        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遍历

        for(Integer i : ts){

        System.out.print(i+ " ");//1718 19 20 22 23 24 :唯一并且排序:自然排序(升序排序)

        }

    }

}

6.TreeSet集合存储自定义对象并遍历

    实现了compareable接口,重写了comapreTo()方法,里面的逻辑是一个排序条件:

    需求:

        按照学生的年龄从小到大进行排序:主要条件

        对于自定义对象什么情况下保证元素是唯一的

        成员变量的值相同,认为是同一个元素

        主要条件给定,需要分析次要条件

        一个类中的元素想要自然排序,那么必须实现Compareable接口,实现compareTo(类名 对象名){}方法   

 按照正常存储对象的操作以及遍历对象出现了问题:类转换异常

importjava.util.TreeSet;

publicclass TreeSetDemo2 {

    public static void main(String[] args) {

        //创建TreeSet集合对象

        TreeSet<Student> ts = newTreeSet<Student>();//

        //创建学生对象

        Student s1 = new Student("linqingxia",28);

        Student s2 = newStudent("fengqingy", 28);

        Student s3 = newStudent("gaoyuanyuan", 27);

        Student s4 = newStudent("liushishi", 26);

        Student s5 = newStudent("wanglihong", 29);

        Student s6 = newStudent("zhangguorong", 30);

        Student s7 = newStudent("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());

        }

    }

}

//对于TreeSet集合存储自定义对象必须实现一个接口:compareable接口

publicclass Student implements Comparable<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;

    }

    //重写了compareTo()方法

    @Override

    public int compareTo(Student s) {

        //排序的代码了,需要定义排序的条件

        //主要条件:按照学生的年龄从小到大进行排序

        int num =s.age - this.age ;//年龄从大到小

        //当num==0认为年龄一样,年龄一样,不代表姓名的的内容是否相同,需要自己给出次要条件

        int num2 = num==0 ? this.name.compareTo(s.name):num;

        return num2;

    }

}

7.

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

分析:

    1)创建一个学生类,提供姓名,语文,数学,英语这个成员变量

    2)创建TreeSet集合对象:TreeSet<Student>(Comparator<Student>com)

    3)分析条件:主要条件:总分从高到低

              次要条件:总分相同,语文..

    4)键盘录入5个学生:for循环

    5)输出

importjava.util.Comparator;

importjava.util.Scanner;

importjava.util.TreeSet;

publicclass TreeSetTest {

    public static void main(String[] args) {

        // 创建TreeSet集合对象,使用有参构造

        // 比较器排序匿名内部类的方式

        TreeSet<Student> ts = newTreeSet<Student>(new Comparator<Student>() {

            @Override

            public int compare(Student s1,Student s2) {

                // 主要条件:总分从高到到第进行排序

                int num = s2.getSum() -s1.getSum();

                // 总分相同,不一定语文成绩相同,比较语文成绩

                int num2 = num == 0 ?s1.getChinese() - s2.getChinese() : num;

                // 总分相同,语文成绩相同,比较数学成绩

                int num3 = num2 == 0 ?s1.getMath() - s2.getMath() : num2;

                // 总分相同,语文成绩相同,数学相同,比较英语

                int num4 = num3 == 0 ?s1.getEnglish() - s2.getEnglish() : num3;

                // 总分以及各科成绩都相同,不一定是同一个人,姓名内容是否相同

                int num5 = num4 == 0 ?s1.getName().compareTo(s2.getName())

                        : num4;

                return num5;

            }

        });

        System.out.println("录入学生信息开始:");

        // 键盘录入5个学生的信息,姓名,语文成绩,数学成绩,英语成绩

        for (int x = 1; x <= 5; x++) {

            // 创建键盘录入对象

            // 为了方便录入数据,数据类型都使用String类型接收

            Scanner sc = new Scanner(System.in);

            System.out.println("请输入第" + x + "个学生的姓名:");

            String name = sc.nextLine();

            System.out.println("请输入第" + x + "个学生的语文成绩:");

            String chineseString =sc.nextLine();

            System.out.println("请输入第" + x + "个学生的数学成绩:");

            String mathString = sc.nextLine();

            System.out.println("请输入第" + x + "个学生的英语成绩:");

            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英语成绩");

        // 增强for遍历集合

        for (Student s : ts) {

            System.out.println(s.getName() +"\t" + s.getChinese() + "\t"

                    + s.getMath() +"\t" + s.getEnglish());

        }

    }

}

publicclass 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, intmath, 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;

    }

}