集合（容器）,collection,泛型，comparable接口

本章内容：已经有数组了为什么有集合；集合的子类特性以及实现；泛型是什么；comparable接口的简单使用

泛型：帮助我们建立类型安全的集合。本质是“数据类型的参数化”，可以理解为是形参。
 *  需要集合的原因：因为数组不灵活的特性，比如长度要先定好，但是实际上写的时候不知道有多少数据。
 * 容器(集合)collection:interface修饰，下面有set和list两个子类，也是interface修饰
 *    list:值允许重复，有序：
 *       arraylist:快速随机访问，但插入和移除速度慢。线程不安全，底层实现是数组，多数使用这个。
 *       vector:线程安全，底层实现是数组，但效率慢。
 *       linkedList:插入，删除速度快。访问就比较慢了。底层实现是链表
 *    set:值不允许重复，无序，因为没有索引，所以只能通过遍历来查找；新元素需要通过equals()方法来
 *     比较，如果为true,则不能加入，set也只能放一个null元素。有hashset,treeset等：
 *        hashset:方法基本和arraylist类似；是采用的哈希算法，底层使用hashmap来实现的，就是hashmap
 *        的key值，这也是为什么不能重复原因。
 *        treeset:实际是用treemap实现的，所以也会按照递增的方式排序
 *  map(键值对)：interface修饰，下面有hashMap实现类(常用的，还有其他)
 *
 *  comparable接口

要导的包

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

 

arrayList类的常用方法：

 //ArrayList常用方法
        List<String> list = new ArrayList<>();
        list.add("你");
        list.add("好");
        System.out.println(list.size());
        boolean b = list.contains("你");//是否包含指定字符
        list.toArray();//转成一个object数组
        list.remove(0);//移除，“你”对象还在，但是被移除出list了
        list.clear();//移除所有的
 List<String> list = new ArrayList<>();
        list.add("a");
        list.add("c");
        list.add("b");
        list.add("d");
        System.out.println(list);
        list.add(1,"插入的");//指定位置插入数据
        System.out.println(list);
        list.remove(1);//移除指定位置元素
        System.out.println(list );
        list.set(2,"替换的");//指定位置元素被替换
        System.out.println(list );
        System.out.println(list.get(2) );//获取指定位置的元素

关于两个arrayList集合的方法

 List<String> listS = new ArrayList<>();
         listS.add("aa");
         listS.add("bb");
         listS.add("cc");
         List<String> listS1 = new ArrayList<>();
         listS1.add("aa");
         listS1.add("dd");
         listS1.add("ee");

    //   listS.addAll(listS1);//把listS1全部添加到listS
    //   listS.removeAll(listS1);把和listS1所有相同的都移除了
         listS.retainAll(listS1);//取交集
         System.out.println(listS);
         System.out.println(listS.containsAll(listS1));//listS是否包含listS1全部

 泛型：定义一个类，参数是个泛型，到时传什么类型的都可以

class MyCollection<E>{
    Object[] objs = new Object[3];

    public void set(E e,int num){
        objs[num] = e;
    }

    public E get(int  num){
        return (E)objs[num];
    }
}

 调用：

 MyCollection<String> mc = new MyCollection<String>();
        mc.set("haha",0);
        String s = mc.get(0);
        System.out.println(s);

定义一个雇员类，set,get方法省略

class Employee{
    private int id ;
    private String name;
    private double salary;

    public Employee(int id,String name,double salary){
        this.id = id;
        this.name = name;
        this.salary = salary;
    }
}

我们以salary的属性对雇员进行排序，写一个类来实现comparable接口，写个排序的类

class Emp implements Comparable<Emp>{
    int id ;
    String name;
    double salary;

    public Emp(int id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", salary=" + salary +
                '}';
    }

    @Override
    public int compareTo(Emp o) {//正数：大于；负数：小于；0：等于
        if(this.salary > o.salary){
            return 1;
        }else if(this.salary < o.salary){
            return -1;
        }else{
            if(this.id > o.id){
                return 1;
            }else if(this.id<o.id){
                return -1;
            }else{
                return 0 ;
            }
        }
    }
}

写个方法调用上面那个类

  Set<Emp> empSet = new TreeSet<>();
        empSet.add(new Emp(001,"小白",9000));
        empSet.add(new Emp(100,"小黑",90000));
        empSet.add(new Emp(21,"小明",5000));

        for(Emp m:empSet){
            System.out.println(m);
        }

结果：

       Emp{id=21, name='小明', salary=5000.0}
       Emp{id=1, name='小白', salary=9000.0}
       Emp{id=100, name='小黑', salary=90000.0}