Java基础-15-集合2

Java基础-集合

集合进阶

1、集合框架（TreeSet）

Set：无序，不可以重复元素。

  Set
    |---HashSet：数据结构是哈希表。线程是非同步的。保证元素唯一性的原理：判断元素的hashCode值是否相同，如果相同，还会继续判断元素的equals方法，是否为true。
    |---TreeSet：可以对Set集合中的元素进行排序。

代码：

import java.util.*;
class TreeSetDemo
{
    public static void main(String []args)
    {
        TreeSet ts = new TreeSet();
        ts.add("cba");
        ts.add("abcd");
        ts.add("aaa");
        ts.add("abcd");
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

输出结果：

aaa
abcd
cba

2、集合框架（TreeSet存储自定义对象）

需求：往TreeSet集合中存储自定义对象学生，想按照学生的年龄进行排序。

import java.util.*;
class Student implements Comparable//该接口强制学生具备比较性。
{
    private String name ;
    private int age;
    public Student(String name, int age)
    {
        this.name = name ;
        this.age =age ;
    }
    public String getName()
    {
        return name ;

    }
    public int getAge()
    {
        return age ;
    }
    public int compareTo(Object obj)
    {
        if(!(obj instanceof Student ))
        {
            throw new RuntimeException("不是学生对象");
        }
        Student s = (Student ) obj;
        System.out.println(this.name +"...com..."+s.name);
        if(this.age > s.age)
        {
            return 1;
        }
        if(this.age == s.age)
        {
            return this.name.compareTo(s.name);//记住排序时，当主要条件相同时，一定要判断一下次要条件
        }
        return -1;
    }
}
class TreeSetTest
{
    public static void main(String []args)
    {
        TreeSet ts = new TreeSet();
        ts.add(new Student("lisi02",22));//往TreeSet里存的对象必须具备比较性
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi09",19));
        ts.add(new Student("lisi01",40));
        ts.add(new Student("lisi08",19));
        Iterator it = ts.iterator();
        while (it.hasNext())
        {
            Student s = (Student ) it.next();
            System.out.println(s.getName()+"...."+s.getAge());
        }

    }
}

输出：

lisi02...com...lisi02
lisi007...com...lisi02
lisi09...com...lisi02
lisi09...com...lisi007
lisi01...com...lisi007
lisi01...com...lisi02
lisi08...com...lisi007
lisi08...com...lisi09
lisi08....19
lisi09....19
lisi007....20
lisi02....22
lisi01....40

3、集合框架（二叉树）

图：

现在有一个需求：如何按存进去的顺序取出元素？ 解：在接口Comparable中的功能compareTo(Object obj)里只写return 1;这样会导致二叉树会按一下图存储：

|----TreeSet：可以对Set集合中的元素进行排序，底层数据结构是二叉树，保证元素唯一性的依据：compareTo方法return 0;

TreeSet排序的第一种方式：让它自身具备比较性。元素需要实现Comparable接口，覆盖这种方式也成为元素的自然顺序，或叫默认顺序。

4、集合框架（实现Comparator方法排序）

TreeSet的第二种排序方式：当元素自身不具备比较性时，或者具备的比较性不是需要的，这时就需要让集合自身具备比较性，在集合一初始化时，就有了比较方式。

当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时需要让容器自身具备比较性，定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

而当两种排序都存在时，以比较器为主，定义一个类，实现Comparator接口，覆盖compare方法。

以下是测试代码：

import java.util.*;
class Student implements Comparable//该接口强制学生具备比较性。
{
    private String name ;
    private int age;
    public Student(String name, int age)
    {
        this.name = name ;
        this.age =age ;
    }
    public String getName()
    {
        return name ;

    }
    public int getAge()
    {
        return age ;
    }
    public int compareTo(Object obj)
    {
        if(!(obj instanceof Student ))
        {
            throw new RuntimeException("不是学生对象");
        }
        Student s = (Student ) obj;
        System.out.println(this.name +"...com..."+s.name);
        if(this.age > s.age)
        {
            return 1;
        }
        if(this.age == s.age)
        {
            return this.name.compareTo(s.name);//记住排序时，当主要条件相同时，一定要判断一下次要条件
        }
        return -1;
    }
}
class TreeSetDemo
{
    public static void main(String []args)
    {
        TreeSet ts = new TreeSet(new MyCompare());
        ts.add(new Student("lisi02",22));
        ts.add(new Student("lisi02",21));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi09",19));
        ts.add(new Student("lisi06",18));
        ts.add(new Student("lisi06",18));
        ts.add(new Student("lisi007",20));
        Iterator it = ts.iterator();
        while (it.hasNext())
        {
            Student s = (Student)it.next();
            System.out.println(s.getName()+"..."+s.getAge());
        }

    }
}
class MyCompare implements Comparator
{
    public int compare(Object o1,Object o2)
    {
        Student s1 = (Student) o1;
        Student s2 = (Student) o2;
        int num = s1.getName().compareTo(s2.getName());
        if(num == 0 )
        {
            return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));

        }
        return num;
    }
}

输出：

lisi007...20
lisi02...21
lisi02...22
lisi06...18
lisi09...19

5、集合框架（TreeSet练习）

练习：按照字符串长度排序

字符串本身具备的比较性，可是它的比较性方式不是所需要的，这时就只能使用比较器。

import java.util.*;
class StrLenComparator implements Comparator
{
    public int compare(Object o1,Object o2)
    {
        String s1 = (String) o1;
        String s2 = (String )o2;
        int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
        if(num == 0)
        {
            return s1.compareTo(s2);
        }
        return num ;
    }
}
class TreeSetDemo
{
    public static void main(String []args)
    {
        TreeSet ts = new TreeSet(new StrLenComparator());
        ts.add("abcd");
        ts.add("cc");
        ts.add("cba");
        ts.add("aaa");
        ts.add("zz");
        ts.add("hahaha");
        ts.add("z");
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }

}

输出：

z
cc
zz
aaa
cba
abcd
hahaha

6、集合框架（泛型概述）

泛型：JDK1.5版本后出现了新特性，用于解决安全问题，是一个安全机制。 好处：

1、将运行时期出现的问题ClassCastException转移到了编译时期，方便于程序员解决问题。让运行时期问题减少，安全。
2、避免了强制转换麻烦。

Demo

import java.util.*;
class GenericDemo
{
    public static void main(String []args)
    {
        ArrayList <String>  al = new ArrayList<String>();
        al.add("abc01");
        al.add("abc2121");
        al.add("abcasd");
        //al.add(4);
        //al.add(new Integer(4));
        //以上注释掉的代码是不允许的，编译失败，是由泛型限制导致的

        Iterator<String> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

输出：

abc01
abc2121
abcasd

7、集合框架（泛型使用）

泛型格式：通过<>来定义要操作的引用数据结构。 在使用Java提供的对象时，什么时候使用泛型？ 通常在集合框架中很常见，只要见到<>就是用来定义泛型，其实<>就是用来接收类型的，当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

import java.util.*;
class GenericDemo2
{
    public static void main(String []args)
    {
        TreeSet ts = new TreeSet(new StrLenComparator());
        ts.add("abcd");
        ts.add("cc");
        ts.add("cba");
        ts.add("aaa");
        ts.add("zz");
        ts.add("hahaha");
        ts.add("z");
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}
class StrLenComparator implements Comparator<String>//使用泛型
{
    public int compare(String o1,String o2)
    {

        int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
        if(num == 0)
        {
            return o1.compareTo(o2);
        }
        return num ;
    }
}

输出：

z
cc
zz
aaa
cba
abcd
hahaha

8、泛型框架（泛型类）

什么时候定义泛型类？ 当类中要操作的引用数据类型不确定的时候，早期定义Oject来完成扩展，现在 定义泛型来完成扩展。

测试代码

import java.util.*;
class GenericDemo3_1
{
    public static void main(String []args)
    {
        /*
        Tool t = new Tool();
        t.setObject(new Student());
        Worker w = (Worker)t.getObject();
        //Exception in thread "main" java.lang.ClassCastException: Student cannot be cast to Worker at GenericDemo3.main(GenericDemo3.java:8)
        */
        //以上代码出现异常。
        Utils u = new Utils();
        u.setObject(new Student());
        Worker w = (Worker)u.getObject();
        //以上代码在编译时期就有提醒风险。
    }
}
class Worker
{}
class Student
{
}
class Tool
{
    private Object obj;
    public void setObject(Object obj)
    {
        this.obj = obj ;
    }
    public Object getObject()
    {
        return obj;
    }
}
class Utils<QQ>
{
    public QQ q;
    public void setObject(QQ q)
    {
        this.q = q;
    }
    public QQ getObject()
    {
        return q ;
    }
}

输出：

9、集合框架（泛型方法）

泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有操作的类型就已经固定了，为了让不同方法可以操作不同类型，而且类型还不能确定，那么可以将泛型定义在方法上。

import java.util.*;
class GenericMethodTest
{
    public static void main(String []   args)
    {
        GenericMethod d = new GenericMethod()   ;
        d.show("asadsada");
        d.show(4);
        d.print("asadfasda");
        d.print(212);
    }
}
class GenericMethod
{
    public <T> void show(T t)
    {
        System.out.println("show:"+t);
    }
    public <Q> void print (Q q)
    {
        System.out.println("print:"+q);
    }

}

输出：

10、集合框架（静态方法泛型）

特殊之处：静态方法不可以访问类上定义的泛型，如果静态方法操作的应用数据不确定，可以将泛型定义在方法上：格式

public <W> static void method(W w){}//正确
public static <W> void method(W w){}//错误，<W>的位置要注意，位置是固定的。

11、集合框架（泛型接口）

import java.util.*;
//泛型定义在接口上
interface Inter<T>
{
    void show(T t);

}
/*//这样可以，注释了为了令另外的代码运行
class InterImpl implements Inter<String >
{
    public void show(String t)
    {
        System.out.println("show:"+t);
    }
}
*/

class InterImpl<T> implements Inter<T>
{
    public void show(T t )
    {
        System.out.println("show:"+t);
    }
}
class GenericDemo1
{
    public static void main(String []args)
    {
        //InterImp i = new InterImpl ();
        //i.show("haha");
        InterImpl<Integer> i = new InterImpl<Integer> ();
        i.show(4);
    }
}

输出：

12、集合框架（泛型限定）

? ：通配符，也可以理解为占位符。 泛型的限定：? extends E ：可以接收E类型或者E 的子类型，上限。？super E ：可以接收E类型或者E的父类型，下限。

import java.util.*;
class Person
{
    private String name;
    Person(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }

}
class Student extends Person
{
    Student(String name)
    {
        super(name);
    }
}

class GenericDemo6
{
    public static void main(String []   args)
    {
        ArrayList<Person> al = new ArrayList<Person>();
        al.add(new Person("abc1"));
        al.add(new Person("abc2"));
        al.add(new Person("abc3"));
        al.add(new Person("abc4"));

        ArrayList<Student> al2 = new ArrayList<Student>();
        al2.add(new Student("abc--1"));
        al2.add(new Student("abc--2"));
        al2.add(new Student("abc--3"));
        printColl(al);
        printColl(al2);
    }
    public static void printColl(ArrayList<? extends Person>al)//泛型限定
    {
        Iterator<? extends Person> it = al.iterator()   ;
        while(it.hasNext())
        {
            System.out.println(it.next().getName());
        }
    }

}

输出结果：