集合框架JCF

集合框架（Java collections Framework）

• 接口

  • Collections

    • List ​

      • 线性

      • 元素可重复

    • Set

      • 元素不重复

  • Map 映射（Key-Value 键值对，一个元素包含两个对象、键对象不重复）

• 实现类

• 算法

List

List集合可以存储一列数据

• 数据内容可重复

• 以元素安插的次序来放置元素，不会重新排列

常用方法

add(Object)

• 插入指定元素，将当前位于该位置的元素 （ 如果有 ） 和任何后续元素向右移动 （ 将其索引加一 ）

remove(int)

• 移除此列表中指定位置的元素（可选操作）。 将任何后续元素向左移动（从它们的索引中减去 1）。 返回从列表中删除的元素

get(int)

• 返回此列表中指定位置的元素

size()

• 返回此列表中的元素数

indexOf(Object)

• 返回此列表中指定元素第一次出现的索引，如果此列表不包含该元素，则返回 -1

List接口实现类的选择

• ArrayList

  • 底层采用数组实现

  • 遍历元素，追加元素速度快

  • 中间插入和删除元素速度慢

  • 线程不安全

• Vector

  • 底层采用数组实现

  • 线程安全

  • 性能低于ArrayList

• LinkedList

  • 采用双向链表实现

  • 元素空间不连续

  • 遍历元素速度慢

  • 中间插入和删除元素速度快

  • 一般用于需要在集合的中间位置，频繁增加删除元素时使用

ArrayList 实现类

 List list = new ArrayList();
​
        //添加数据 add(Object)
        list.add(111); //索引为0
        list.add("112"); //索引为1
        list.add(new ClassTest()); //索引为2
        list.add(true); //索引为3
​
        System.out.println(list.get(3)); //得到索引为3的数据
​
        list.remove(3); //去掉索引为3的数据
        //查看集合长度的方法 size()
        System.out.println(list.size()); //得到集合的长度
​
​
        //遍历方式1
        for (int i = 0; i <list.size() ; i++) {
            System.out.println(list.get(i));
        }
​
        //遍历方式2 集合迭代器进行便利
        Iterator iterator= list.iterator();
        //hasNext() 判断迭代器中是否还有元素，没有则返回false，有则返回true
        //next() 获取迭代器中的元素
        while (iterator.hasNext()){
            Object o = iterator.next();
            System.out.println(o);
        }
​
        //for-each 遍历
        for (Object o :list) {
            System.out.println(o);
        }

       
​

集合排序

在排序之前，需要定义排序的规则

例子

//员工类
public class EmployeeBean {
​
​
    private String name;
    private int age;
    private int money;
​
    public EmployeeBean() {
    }
​
    public EmployeeBean(String name, int age, int money) {
        this.name = name;
        this.age = age;
        this.money = money;
    }
​
    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 getMoney() {
        return money;
    }
​
    public void setMoney(int money) {
        this.money = money;
    }
​
    @Override
    public String toString() {
        return "EmployeeBean{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", money=" + money +
                '}';
    }
  }
//main方法
public static void main(String[] args) {
​
        List <EmployeeBean> list = new ArrayList<>();
        list.add(new EmployeeBean( "你",30,4000 ));
        list.add(new EmployeeBean( "我",18,9000 ));
        list.add(new EmployeeBean( "他",41,8000 ));
​
        list.sort(new Comparator<EmployeeBean>() {
            @Override
            public int compare(EmployeeBean o1, EmployeeBean o2) {
                return o2.getMoney()-o1.getMoney(); //按工资从高到低
            }
        });
​
        for (EmployeeBean e:list) {
            System.out.println(e);
        }
​
​
    }

Set

操作一列无重复的数据时，使用set接口的实现类

Set接口实现类，利用元素的hashCode和equals方法判断元素是否重复

如要按元素的属性值去除重复值，则重写方法

常用方法

add（Object）

• 向集合中添加元素

remove(Object)

• 将元素从集合中移除

size()

• 返回此列表中的元素数

Set接口实现类的选择

//set集合基本使用
​
 Set set = new HashSet();
        set.add("Tom");
        set.add("Tom");
        set.add("Tom");
        set.add("Tom");
        set.add("Tom");
        set.add("To");
        set.add("To");
        set.add("To");
        set.add("T");
        set.add("T");
        set.add("T");
        set.add("T");
​
        for (Object o:set) {
            System.out.println(o);
        }
/*
    结果为Tom，T，To
*/
​
        System.out.println(set.size());
        set.remove("Tom");
        System.out.println(set.size());
        for (Object o:set) {
            System.out.println(o);
        }
/*
    结果为3，2，T，To
*/
​


/*
    重写方法去重
*/
​
//main方法
Set<EmployeeBean> employeeBeanSet = new HashSet<>();
​
        employeeBeanSet.add(new EmployeeBean("Tom",18,2000) );
        employeeBeanSet.add(new EmployeeBean("Tom",18,2000) );
        employeeBeanSet.add(new EmployeeBean("Tom",18,2000) );
        employeeBeanSet.add(new EmployeeBean("Tom",18,2000) );
        employeeBeanSet.add(new EmployeeBean("Rose",21,4000) );
        employeeBeanSet.add(new EmployeeBean("Rose",21,4000) );
        employeeBeanSet.add(new EmployeeBean("Rose",21,4000) );
        employeeBeanSet.add(new EmployeeBean("Wang",11,11000) );
​
        for (EmployeeBean e:employeeBeanSet) {
            System.out.println(e);
        }
​
​
//员工类
public class EmployeeBean {
​
​
    private String name;
    private int age;
    private int money;
​
    public EmployeeBean() {
    }
​
    public EmployeeBean(String name, int age, int money) {
        this.name = name;
        this.age = age;
        this.money = money;
    }
​
    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 getMoney() {
        return money;
    }
​
    public void setMoney(int money) {
        this.money = money;
    }
​
    @Override
    public String toString() {
        return "EmployeeBean{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", money=" + money +
                '}';
    }
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        EmployeeBean that = (EmployeeBean) o;
        return age == that.age && money == that.money && Objects.equals(name, that.name);
    }
​
    @Override
    public int hashCode() {
        return Objects.hash(name, age, money);
        //此时表示需要name，age，money全部一样才去重
    }
}

//TreeSet
//第一种，运用Comparable接口 重写compareTo方法
​
/*
main方法
*/
Set<EmployeeBean> employeeBeanSet = new TreeSet<>();
​
        employeeBeanSet.add(new EmployeeBean("Tom",18,2000) );
        employeeBeanSet.add(new EmployeeBean("Tom",18,2000) );
        employeeBeanSet.add(new EmployeeBean("Tom",18,2000) );
        employeeBeanSet.add(new EmployeeBean("Tom",18,2000) );
        employeeBeanSet.add(new EmployeeBean("Rose",21,4000) );
        employeeBeanSet.add(new EmployeeBean("Rose",21,4000) );
        employeeBeanSet.add(new EmployeeBean("Rose",21,4000) );
        employeeBeanSet.add(new EmployeeBean("Wang",11,11000) );
​
        for (EmployeeBean e:employeeBeanSet) {
            System.out.println(e);
        }
​
/*
    员工类
*/
​
public class EmployeeBean implements Comparable{
    //调用Comparable接口
​
    private String name;
    private int age;
    private int money;
​
    public EmployeeBean() {
    }
​
    public EmployeeBean(String name, int age, int money) {
        this.name = name;
        this.age = age;
        this.money = money;
    }
​
    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 getMoney() {
        return money;
    }
​
    public void setMoney(int money) {
        this.money = money;
    }
​
    @Override
    public String toString() {
        return "EmployeeBean{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", money=" + money +
                '}';
    }
​
    /*
        重写compareTo方法
        未重写时，默认return 0 意为重复
    */
    @Override
    public int compareTo(Object o) {
        EmployeeBean that = (EmployeeBean) o;
        return this.getMoney()-that.getMoney();
        /* 此时按低到高排序
            this和that互换则相反
        */
       
    }
}
​
​
/*
    第二种
    直接new出Comparator比较器
    不需要在员工类里重写
*/
​
Set<EmployeeBean> employeeBeanSet = new TreeSet<>(new Comparator<EmployeeBean>() {
            @Override
            public int compare(EmployeeBean o1, EmployeeBean o2) {
                /*返回0则表示重复，去重，并排序
                  返回不为0，则按照规则排序
                  同样默认return 0
                */
                return o2.getMoney()-o1.getMoney();
            }
        });
​
        employeeBeanSet.add(new EmployeeBean("Tom",18,2000) );
        employeeBeanSet.add(new EmployeeBean("Tom",18,2000) );
        employeeBeanSet.add(new EmployeeBean("Tom",18,2000) );
        employeeBeanSet.add(new EmployeeBean("Tom",18,2000) );
        employeeBeanSet.add(new EmployeeBean("Rose",21,4000) );
        employeeBeanSet.add(new EmployeeBean("Rose",21,4000) );
        employeeBeanSet.add(new EmployeeBean("Rose",21,4000) );
        employeeBeanSet.add(new EmployeeBean("Wang",11,11000) );
​
        for (EmployeeBean e:employeeBeanSet) {
            System.out.println(e);
        }

Map

Map接口实现类中，一个元素包含两个对象

• 键对象（key）

  • 不能重复

• 值对象（value）

如果Map接口中要使用泛型，应对键和值分别定义

Map<String,Student>map;

Map接口实现类常用方法

Map接口实现类的方法都是关于键值对的操作

put(key,value)	向集合中添加元素
get	根据键对象找到值对象
keyset	得到键对象的集合
values	得到值对象的集合
remove	根据键对象移除整个元素
containsKey	判断键对象在集合中是否存在

/*
    示例
*/
​
 Map<String,EmployeeBean> map = new HashMap<>();
        /*
            put(key,value)
            当键不同时，是做添加
            当键相同时，是做修改（覆盖）
        */
        map.put("Tony",new EmployeeBean("tony",19,30000));
        map.put("Tom",new EmployeeBean("tom",29,40000));
​
        //get(key)得到value
        System.out.println(map.get("Tony"));
​
        //containsKey(key) 判断key在集合中是否存在
        System.out.println(map.containsKey("Tony"));
​
        //remove(key) 根据key移除整个元素
        map.remove("Tony");
​
​
        //keySet() 得到键对象集合
        //map.keySet();
        Set <String> keySet = map.keySet();
​
        //values() 得到值对象集合,返回Collection集合
        //map.values();
        Collection<EmployeeBean> collection = map.values();
​
​
​
//Map的遍历方式
​
        /*
            通过键集合进行遍历
        */
        for (String key:keySet) {
            System.out.println(key + " " + map.get(key));
        }
        
        /*
            通过值集合进行遍历
         */
​
        for (EmployeeBean e:collection) {
            System.out.println(e);
        }
​