Java_集合框架

集合框架概念

集合框架是一个用来代表和操作集合的统一架构.所有的集合框架都包含以下内容:
1.接口:是代表集合的抽象数据类型.接口允许集合独立操纵其代表细节.在面向对象语言.接口通常形成一个层次.
2.实现(类):是集合接口的具体实现.
1. 算法:是实现集合接口的对象里的方法执行的一些有用的计算.
特点
1.集合的长度是可变的.
2.集合只用于存储对象.
3.集合可以存储不同类型的对象.

Collection接口

*定义了存取一组对象的方法,其子接口Set和 List分别定义了存储方法.
*Set中的数据对象没有顺序且不可以重复.
*List中的数据对象有顺序且可以重复.

1.PNG

在上图中 Collection是一个超级接口 Set和List继承与它.Set和list也是接口.
hashSet是Set的实现类,ArrayList和LinkedList是List的实现类.

LIst

ArrayList的一些方法

ArrayList采用数组实现,适合查找,更新

ArrayList list =  new ArrayList();
        list.add("one");
        list.add("two");
        list.add("thre");
        System.out.println(list);
        //删除元素
        list.remove(1);//根据下标
        list.remove("thre");//根据元素
        System.out.println(list);
        //跟新
        list.set(0,"跟新元素");
        System.out.println(list);
        //查找元素
        Object obj =list.get(0);
        System.out.println(obj);
        
        //是否包含某元素
        boolean isContain = list.contains("跟新元素");
        System.out.println(isContain);
        //元素个数
        int size = list.size();
        System.out.println(size);

Lindedlist的一些方法

LinkedList 采用双向链表实现,适合添加,删除.

LinkedList list = new LinkedList();
        
        list.add("one");
        list.add("two");
        list.add("thre");
        System.out.println(list);
        //删除元素
        list.remove(1);//根据下标
        list.remove("thre");//根据元素
        System.out.println(list);
        //跟新
        list.set(0, "跟新元素");
        System.out.println(list);
        //查找元素
        Object obj =list.get(0);
        System.out.println(obj);
        
        //是否包含某元素
        boolean isContain = list.contains("跟新元素");
        System.out.println(isContain);
        //元素个数
        int size = list.size();
        System.out.println(size);

这些都是list的两个实现类,上面的方法都是一些常用的方法要熟练应用.

Set

HashSet一些方法

创建HashSet对象 (因为是无序的,所以不可以用get来获取元素)
*HashSet基于HastMap实现的,利用了键不能重复的特点.
重复元素的判断机制
1.只要obj == obj1 认为 obj和obj1是相等的元素
2.hashCode和 equals相等就认为元素相等.

HashSet set = new HashSet();
        set.add("1");//添加元素
        set.add("2");
        set.add("1");
        System.out.println(set);
        //遍历set
        for (Object object : set) {
            System.out.println(object);
        }
        //是否包含元素
        boolean iscon = set.contains("1");
        System.out.println(iscon);
        
        //删除元素
        set.remove("1");

TreeSet

可以排序 1.自然排序 2.自定义排序
TerrSet可以对数字和字符串排序因为都实现了comparable接口
如果在comparable接口中返回0 认为是同一元素.

public static void main(String[] args) {
        TreeSet set = new TreeSet();
//      set.add("2");
//      set.add("1");
//      set.add("4");
//      set.add("6");
//      set.add("8");
        Person1 p = new Person1();
        p.name = "nana";
        p.age = 11;
        Person1 p1 = new Person1();
        p1.name = "momo";
        p1.age = 10;
        Person1 p2 = new Person1();
        p2.name = "lala";
        p2.age = 8;
        set.add(p);
        set.add(p1);
        set.add(p2);
        System.out.println(set);
    }
}
class Person1 implements Comparable{
    String name;
    int age;
@Override  // 自定义相等的规则
    public boolean equals(Object obj) {
    // 如果类型不相等，返回false
    if (!(obj instanceof Person)) {
            return false;
        }
    // 如果名字相同， 返回true
    if (((Person)obj).name.equals(this.name)) {
        return true;
    }
        // 如果名字不相同，返回false
    return false;
    }
    
    // hashCode
    @Override    // 计算一个对象的hash值
    public int hashCode() {
        return this.name.hashCode();
    }
    @Override
    public int compareTo(Object o) {
        if (!(o instanceof Person1)) {
            Person1 p = (Person1)o;
            if (this.age >p.age) {
                return 1;
                }else if(this.age == p.age){
                return 0;
            }else {
                return -1;
            }
        }
        return 0;
    }
    @Override  //自定义输出
    public String toString() {
        return "name:"+this.name+" age:"+age;
    }

Map接口

Map接口定义了存储"键(key)-值(value)映射对"的方法.
键不能重复 value可以重复.

HashMap map = new HashMap();
    //保存数据
    map.put("键", "值");
    map.put("键1", "值1");
    map.put("键2", "值2");
    //读取数据
    Object obj = map.get("键");
    System.out.println(obj);
    
    //遍历
    for (Object item : map.keySet()) {
        System.out.println(map.get(item));
    }
    //跟新
    map.put("键", "跟新的值");
    System.out.println(map);
    //删除
    map.remove("键");
    System.out.println(map);
    //包含
    map.containsKey("键1");
    //map.containsValue("值1");
    //System.out.println(map);
    //清空
    map.clear();
    //System.out.println(map);

TreeMap

根据key进行排序

public static void main(String[] args) {
        Stu stu = new Stu();
        stu.age = 12;
        stu.name = "杨少锋";
        
        Stu stu1 = new Stu();
        stu1.age = 17;
        stu1.name = "阿墩";
        
        Stu stu2 = new Stu();
        stu2.age = 11;
        stu2.name = "eerdun";
        
        Stu stu3 = new Stu();
        stu3.age = 11;
        stu3.name = "张三";
    
        TreeMap map = new TreeMap();
        map.put("12", stu);
        map.put("2", stu1);
        map.put("15", stu2);
        map.put("3", stu3);
        System.out.println(map);
    }
}


class Stu  implements Comparable{
    @Override
    public String toString() {
        return "Stu [age=" + age + ", name=" + name + "]";
    }
    int age;
    String name;
    @Override
    public int compareTo(Object o) {
        Stu stu = (Stu)o;
        if (this.age > stu.age) {
            return 1;
        } else if (this.age == stu.age) {
            
            // 年龄一样我们可以按照名字进行排序
            return 0;
        } else {
            return -1;
        }
    }
}