集合Collection

1.集合存在的理由

　　数据多了用对象存，对象多了用集合存！

　　它是变长的，可以接受各种不同的对象，是数组不能替代的！

2.大致结构

3.各子类数据结构：所以有什么特性自然明了

　　ArrayList：数组

　　LinkedList：双向非循环链表

　　HashSet：hash表

4.父接口Collection都干了什么事

　　存在有包java.util中

　　

5.List子接口都干了什么事

6.ArraylList

package collection;

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



/**
 * ArrayList的使用，注意iterator和listIterator
 */
public class ArrayListDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
//        构造初始容量为15的空列表
        ArrayList al=new ArrayList(15);
        
//        添加
        al.add("hi_one");
        al.add("hi_two");
        al.add(1,"hi_three");
        al.add("hi_one");
        
//        删除
        ArrayList bl=new ArrayList(al);
//        bl.removeRange(1,2);//不可用！！protected，继承了的子类可以使用该方法
        sop("start "+"bl="+bl+"
");
        bl.remove(1);
        bl.remove("hi_one");
        
//        修改
        bl.set(0, "hi");
        
//        查找
        String s=(String) al.get(1);
        int index=al.lastIndexOf("hi_one");
        sop("later "+"bl="+bl+"
");
        
        sop("
"+"start:"+"al"+"
");
//        迭代器  itrator()返回一个内部类对象，该对象封装了迭代操作方法hasNext(),next(),remove()
        for(Iterator it=al.iterator();it.hasNext();){
//            在使用迭代操作集合时，就不要用集合本身的方法操作数据，否则可能
//            java.util.ConcurrentModificationException异常
//            所以，即使能够获取到元素，也没有add（），set()方法！！！
            sop(it.next());
        }
//        List子类特有迭代器listIterator()，增加方法：
//        add();hasPrevious();previous();previousIndex();nextIndex();set()
        ListIterator lt=al.listIterator();
        sop("
"+"later:"+"al逆向遍历，并将元素后面添加!"+"
");
        
        //逆向遍历，并将元素后面添加!
        while(lt.hasNext()){
            Object obj=lt.next();//常用方式
            lt.set(obj+"!");
        }
        while(lt.hasPrevious()){
            sop(lt.previous());
        }
        

    }
    public static void sop(Object obj){
        System.out.println(obj);
    }

}

 练习：删除集合中相同的对象，“相同”的标准自定义

import java.util.ArrayList;
import java.util.Iterator;
/**
 * 
 *去除重复对象：以id和Name同则视为同
 */
public class ArrayListTest2 {

    public static void main(String[] args) {
//        定义容器
        ArrayList al=new ArrayList();
//        初始化
        al.add(new Student(1,"h1"));
        al.add(new Student(2,"h2"));
        al.add(new Student(1,"h1"));
        al.add(new Student(3,"h2"));
//        打印原始//可用迭代器
        System.out.println("start: ");
        for(int i=0;i<al.size();i++){
            Student s=(Student) al.get(i);
            System.out.print(s.getId()+" "+s.getName()+";");
        }
//        删除重复
        al=ArrayListTest2.noRepeat(al);
        System.out.println("
"+"later: ");
        for(int i=0;i<al.size();i++){
            Student s=(Student) al.get(i);
            System.out.print(s.getId()+" "+s.getName()+";");
        }
    }
    public static ArrayList noRepeat(ArrayList al){
//        定义容器
        ArrayList bl=new ArrayList();
        Iterator it=al.iterator();
        while(it.hasNext()){
            Student obj=(Student)it.next();
//            当调用contains，remov等方法时，默认会调用equals
            if(!bl.contains(obj)) bl.add(obj);
            
        }
        return bl;
    }

}
//定义对象
class Student{
    private int Id;
    private String Name;
    Student(int id,String name){
        this.Id=id;
        this.Name=name;
    }
    public int getId(){
        return Id;
    }
    public String getName(){
        return Name;
    }
//    重写equals，否则将以默认的equals判读对象是否相同！！！
    public boolean equals(Object obj){
        if(!(obj instanceof Student)) return false;
        Student s=(Student)obj;
        return this.Id==s.Id && this.Name.equals(s.Name);
    }
}

7.LinkedList

　　增加：除了父类的add，addAll

　　　　头插：void addFirst(E e)　　boolean offerFirst(E e)

　　　　尾插：void addLast(E e)　　boolean offerLast(E e)

　　删除：

　　　　获取并移除头：E pollFirst()，空则返回null，removeFirst()类似，但空抛出异常NoSuchElementException

　　　　获取并移除尾：E pollLast()，空则返回null

　　修改：

　　　　E set(int index, E element)

　　查询：

　　　　获取不移除头：E peekFirst()，空则返回null，getFirst()类似，但空抛出异常NoSuchElementException

　　　　获取不移除尾：E peekLast()，空则返回null　　　　

　　堆栈：

　　　　弹出： E pop()　　移除并返回此列表的第一个元素　　抛出：NoSuchElementException - 如果此列表为空

　　　　压栈：public void push(E e)　　等效于 addFirst(E)。  

 练习：LinkedList模拟队列数据结构

import java.util.LinkedList;

class DuiLie{
    private LinkedList link;
    DuiLie(){
        link=new LinkedList();
    }
    //头出并删除
    public final Object pop(){
        return link.pollFirst();
    }
    //尾入
    public final void  push(Object e){
        link.addLast(e);
    }
    //判空
    public boolean isEmpty(){
        return link.isEmpty();
    }
}
public class LinkListedDemo {

    public static void main(String[] args) {
        DuiLie d=new DuiLie();
        //入队
        d.push("a");
        d.push("b");
        d.push("c");
        //出队
        System.out.println(d.pop());
        System.out.println(d.pop());
        System.out.println(d.pop());
    }

}

8.Set接口都干了什么事

9.HashSet

　　特点：无序、不重复

　　不重复标准：当且仅当 两对象的hashCode()值相同且equals()返回true 时，认为两对象相同

　　也就是说：HashSet集合的添加、删除、contains等操作都依赖hashCode()和equals()两个方法！！

实例：在HashSet中存入和取出对象，并遵循自定义的“相同”规则

方式一：让存入的对象本身具有比较性：让类实现Comparable接口复写其compareTo方法

import java.util.Iterator;
import java.util.TreeSet;

/**
 * 
 *定义TreeSet集合，存入自定义对象，自定义比较规则
 *规则：首要按年龄排，在按姓名.compareTo()按字典排，两者相同则认为相同
 */
public class TreeSetDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TreeSet ts=new TreeSet();
//        存入
        ts.add(new Teacher("abc",20));
        ts.add(new Teacher("Abc",20));
        ts.add(new Teacher("adf",21));
        ts.add(new Teacher("jdc",23));
//        ts.add(new People(1,"2"));
        Iterator it=ts.iterator();
//        需要解决,加入不同类的对象，准备让所有的类都实现Comparable接口？？
//        ts.add(new Teacher("abc",20));
//        输出
        while(it.hasNext()){
            Teacher t=(Teacher)it.next();
            System.out.println(t.getName()+t.getAge());
            
        }
    }

}
//    实现Comparable接口=》具有比较性
class Teacher implements Comparable{
    private String Name;
    private int Age;
    public String getName() {
        return Name;
    }
    public int getAge() {
        return Age;
    }
    Teacher(String name , int age){
        this.Name=name;
        this.Age=age;
    }
    @Override
    public int compareTo(Object o) {
        // TODO Auto-generated method stub
        if(!(o instanceof Teacher)) return -1;
        if(this.Age>((Teacher)o).getAge()) return 1;
        if(this.Age==((Teacher)o).getAge()){
            //年龄相同时按字符串的字典顺序排，如字符相同，返回0剔除
            return this.Name.compareTo(((Teacher)o).getName());
        }
        else  return -1;
    }
    
}

import java.util.HashSet;
import java.util.Iterator;

/**
 * 
 *往hashSet集合存入自定义对象，可重复
 *hashSet如何比较：与List的不一样，要先调用hashCode()，当值相同时继续调用equals()，当且仅当hash值相同且equals为true才相同
 *先调用比较对象的hashCode值是否相同，显然如果不重写hashCode方法，new出来的对象hash值都不同
 *当hash值不同时，认为是不同的对象；当hash值相同时，这是才会调用equals方法！！！重写equals方法，自定义判断相同条件
 */
public class HashSetDemo {

    public static void main(String[] args) {
//        定义集合
        HashSet hs=new HashSet();
        hs.add(new People(1,"hash1"));
        hs.add(new People(2,"hash2"));
        hs.add(new People(1,"hash1"));
        hs.add(new People(3,"hash3"));
        hs.add(new People(3,"hash3"));
        hs.add(new People(3,"hash3"));
//        获取
        Iterator it=hs.iterator();
        while(it.hasNext()){
            People p=(People)(it.next());
            System.out.print(p.getId()+" "+p.getName()+";");
        }
        System.out.println("");
    }

}
//    常用写法：复写hashCode与equals方法，判断对象是否相等
class People{
    private int Id;
    private String Name;
    People(int id ,String name){
        this.Id=id;
        this.Name=name;
    }
    public int getId(){
        return Id;
    }
    public String getName(){
        return Name;
    }
    public boolean equals(Object obj){
//        System.out.println(this.Id+this.Name+"...equals..."+((People)obj).Id+((People)obj).Name);//测试调用equals
        if(!(obj instanceof People)) return false;
        return this.Id==((People)obj).Id && this.Name.equals(((People)obj).Name);
    }
    public int hashCode(){
//        相同对象的hash值相同，注意用到了包装类，因为int型的Id本身不是对象，不能调用Object的方法
        return new Integer(this.Id).hashCode()+this.Name.hashCode();
    }
}

10.SortedSet接口

11.TreeSet

　　特点：无序（不按存入顺序） 有序（会按值排序）

　　实例：存入自定义对象--看12

12. 泛型的使用

　　泛型——广泛的类型，可以通过泛型限定我们使用的  类、方法、接口，从而得到规范，排除了某些安全隐患——如传入非指定的参数，将会编译出错，错误从运行时转至编译时。

　　泛型的语法：

 class Point<T> {
     //这里用T来表示不确定的类型
     private T x;
     ...泛型类中可以使用其他的泛型方法——灵活 
 }

 public <E> void show(E e) {
      System.out.println(e.getClass());
 }

//定义一个泛型接口
interface Inter<T>
{
    public void print(T t);
}

//实现方式一：类实现接口的时候就指定类型
class InterDemo1 implements Inter<String> {
    public void print(String t) {
        System.out.println("print: " + t);
    }
}

//实现方式二：类实例化的时候才指定类型
class InterDemo2<T> implements Inter<T> {
    public void print(T t) {
        System.out.println("print: " + t);
    }
}

 　　泛型的应用——在TreeSet于LinkedList集合中存入锥体（名字，高，底），按照体积排序，底面可以是矩形圆等，名字和体积相同则认为是同一对象，用同一方法遍历

/**
 * 类中使用泛型
 * 方法中使用泛型
 * 接口中使用泛型
 */
package collection;

import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.TreeSet;

/**
 * 需求:在集合中存入锥，按照锥的体积排序，集合传入泛型接口的比较器，体积相同且名字相同，认为是同一个锥
 * 尝试用不同的集合存入锥，用同一个方法打印不同集合中锥对象
 */

public class GenericsDemo {

    public static void main(String[] args) {
        // TreeSet添加
        TreeSet<Zhui> tr = new TreeSet<Zhui>(new MyComp());

        tr.add(new Zhui("Zhui1", 5.0, new Juxing(1.5, 2.5)));
        tr.add(new Zhui("Yuan1", 3.0, new Yuan(2.5)));
        tr.add(new Zhui("Zhui3", 5.0, new Juxing(1.5, 2.5)));
        tr.add(new Zhui("Zhui2", 6, new Juxing(1, 2)));
        tr.add(new ChildZhui("Zhui2", 6, new Juxing(1, 2)));
        
        // LinkedList添加
        LinkedList<Zhui> li = new LinkedList<Zhui>();

        li.add(new Zhui("Zhui1", 5.0, new Juxing(1.5, 2.5)));
        li.add(new Zhui("Yuan1", 3.0, new Yuan(2.5)));
        li.add(new Zhui("Zhui3", 5.0, new Juxing(1.5, 2.5)));
        li.add(new Zhui("Zhui2", 6, new Juxing(1, 2)));
        li.add(new ChildZhui("Zhui2", 6, new Juxing(1, 2)));
        
        // 打印TreeSet集合，体会泛型
        System.out.println("TreeSet");
        GenericsDemo.printColl(tr);
        
        // 打印LinkedList集合，体会泛型
        System.out.println("LinkedList");
        GenericsDemo.printColl(li);
    }

    // 泛型接口：指定，参数或返回值接收T类型
    public static <T> void display(T t) {
        System.out.println(t.getClass());
    }

    // 静态泛型方法，可以打印某集合中的锥对象
    public static <T> void printColl(Collection<T> t) {
        Iterator<Zhui> it = (Iterator<Zhui>) t.iterator();
        while (it.hasNext()) {
            Zhui z = (Zhui) it.next();
            System.out.println(z.getName() + " " + "V:" + z.getArea());
        }
    }
}

// 泛型接口：定义比较器，传至TreeSet构造方法
class MyComp implements Comparator<Zhui> {

    @Override
    // public int compare(Object o1, Object o2) //默认本应该传入Object的
    public int compare(Zhui o1, Zhui o2) {
        // TODO Auto-generated method stub
        int temp = (int) (o1.getArea() - o2.getArea());

        return temp == 0 ? o1.getName().compareTo(o2.getName()) : temp;
    }

}

/**
 * 锥，1/3 底面积*高
 * 
 * @param <B>
 *            泛型锥底形状
 * @param height
 *            高
 * @param bottom
 *            底
 */
// 泛型类——上限
class Zhui<B extends Bottom> {
    private String Name;

    public String getName() {
        return Name;
    }

    private B bottom;
    double height;

    // 脑壳发热的想返回值也搞个泛型，那就不行了，泛型是针对引用型数据的
    double getArea() {
        return height * bottom.getArea() / 3;
    }

    // 构造
    Zhui(String name, double height, B bottom) {
        Name = name;
        this.bottom = bottom;
        this.height = height;
    }
}
class ChildZhui extends Zhui{

    ChildZhui(String name, double height, Bottom bottom) {
        super(name, height, bottom);
    }
    
}
/**
 * 抽象底部，有获取面积的抽象方法
 */
abstract class Bottom {
    abstract double getArea();
}

/**
 * 定义矩形
 * 
 * @param l
 *            长
 * @param h
 *            宽
 */
class Juxing extends Bottom {
    private double l;
    private double h;

    public Juxing(double l, double h) {
        this.l = l;
        this.h = h;
    }

    @Override
    double getArea() {
        // TODO Auto-generated method stub
        return l * h;
    }

}

/**
 * 定义圆，继承底部Bottom
 */
class Yuan extends Bottom {
    private double r;

    public Yuan(double r) {
        this.r = r;
    }

    @Override
    double getArea() {
        // TODO Auto-generated method stub
        return Math.PI * r * r;
    }

}

　

 13.需要比较相同总结