集合collection listmapset

collection 无序无下标不能重复，和set的方法基本一样

只有list 有序有下标可以重复

collection接口没有直接的实现子类，通过list和set来实现：collection s=new Arraylist

想看继承关系图，左键+Ctrl 

传入集合，并对价格进行冒泡排序，遍历输出tostring

 

linkedlist，双向链表

 

 

 

迭代器迭代过程中不能使用其他方法改变集合元素

 iterator迭代里用collection.remove，报错并发修改异常

迭代器提供的remove可以用，it.remove()

 

 

 列表迭代器listIterator,有next还有previous，所以可以逆序遍历

 list.indexof（元素） 返回位置下标，LIst newlist=list.sublist(1,4)截取部分列表2,3,4，

 添加的数字是int列表会自动装箱成Integer

进入源码：点住+ctrl

 list.remove(20)报错数组越界，要让他识别出20是Integer不是index

list.remove((Object)20)   list.remove(new Integer(20))

遍历也可以用增强for，每次取出的是Obiect

for（Object o:list）{}

对于LIst接口，可以出现一模样的元素。想要让它认为只要student的所有属性一样就是同一个对象，那就要重写下equals方法，元素是student,在student类里面重写了equals方法，

public class Student {
    private String name;
 
    @Override
    public String toString() {
        return "name"+name+" age"+age;
    }
 
    private int age;
    public Student(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
 
    @Override//如果把两者当成同一个就return true
    public boolean equals(Object obj) {
        if(obj==this){return true;}
        if(obj instanceof Student)
        {
            Student o=(Student)obj;
            if(o.age==this.age&&o.name.equals(this.name))
            {
                return true;
            }
        }
        return false;
    }
}

import java.util.*;
public class test01 {
    public static void main(String[] args) {
        ArrayList students = new ArrayList<>();
        students.add(new Student("a", 1));
        students.add(new Student("b", 2));
        students.add(new Student("c", 3));
        System.out.println(students.size());//3个
        students.add(new Student("a", 1));//用new了就开辟新空间存，位置都不一样了，即使重写equals也没用
        System.out.println(students.size());//4个  因为开辟新空间，两个元素存放的位置不同
        //我想要它认为两元素的student属性一模一样就看成同一元素，就要去Students类重写下equals方法
        students.remove(new Student("a", 1));//remove会用到equals方法,重写改成如果属性一样返回true,
        System.out.println(students.size());//3
        Student s = new Student("s", 8);
        students.add(s);
        students.add(s);//5个
        System.out.println(students.size());
        System.out.println("-----------------------------");
        TreeSet p = new TreeSet<>();//Treeset的元素的类必须实现comparable接口，因为要有排序功能
        p.add(new Person("a", 9));
        p.add(new Person("b", 9));
        p.add(new Person("c", 9));
        p.add(new Person("a", 9));//不能加入
        System.out.println(p.size());//3个
        System.out.println("--------------------");
        HashSet people = new HashSet<>();
        //存储过程（重复依据）
        //根据hashCode计算保存的位置，如果位置为空，直接保存，若不为空，进行第二步(如果hashcode不一样直接加入)
        //再执行equals方法，如果equals为true(元素属性一样)，则认为是重复，否则形成链表
        people.add(new Person("a", 9));
        people.add(new Person("b", 9));
        people.add(new Person("c", 9));
        people.add(new Person("a", 9));//没改equals和hashcode之前可以加，改后不能加
        System.out.println(people.size());
 
        System.out.println("--------------------------------------------------------");
        Map integerStudentMap = new HashMap<>();
        integerStudentMap.put(1, new Student("a", 1));
        integerStudentMap.put(2, new Student("b", 2));
        integerStudentMap.put(1, new Student("c", 5));//键一样值覆盖
        //keyset遍历
        Set ks = integerStudentMap.keySet();
        for (Integer i : integerStudentMap.keySet())//i的类型是Set后面尖括号里的泛型
        {
            System.out.println("key" + i + " value" + integerStudentMap.get(i));
            //key1 valuenamec age5
            //key2 valuenameb age2
        }
        //entryset遍历
        Set> entries = integerStudentMap.entrySet();
        for (Map.Entry e : integerStudentMap.entrySet())//e的类型是set后面尖括号里的泛型，直接照抄
        {
            System.out.println(e.getKey() + " " + e.getValue());
            //1 namec age5
            //2 nameb age2
 
        }
        ArrayList students1 = new ArrayList<>();
        students1.add(new Student("moday",1));
        students1.add(new Student("tuesday",2));
        Student[]students2= (Student[]) students1.toArray();
        Student[] emptyarry=students1.toArray(new Student[10]);
        //数组转列表,不能增删
        Integer[]a={1,2,3};
        Listas=Arrays.asList(a);
 
        // 把基本类型数组转为集合时，需要修改为包装类
        Integer[] nums = {100, 200, 300, 400, 500};
        List list3 = Arrays.asList(nums);
    }

public class Person implements Comparable<Person>{
    private String name;
    private int age;
    public Person(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
 
    @Override
    public boolean equals(Object obj) {
        if(obj==this){return true;}
        if(obj instanceof Person)
        {
            if(((Person) obj).age==this.age&&((Person) obj).name.equals(this.name))
            {
                return true;
            }
        }
        return false;
    }
 
    @Override
    public int hashCode() {
        int n1=this.age;
        int n2=this.name.hashCode();
        return n1+n2;
    }
 
    @Override
    public int compareTo(Person o) {
        int n1=o.age-this.age;
        int n2=o.name.compareTo(this.name);
        return (n1==0?n2:n1);
    }
}
 
 
 
 
HashMap刚创建时，table是null，节省空间，当添加第一个元素时，table容量调整为16
当元素个数大于阈值（16*0.75 = 12）时，会进行扩容，扩容后的大小为原来的两倍，目的是减少调整元素的个数
jdk1.8 当每个链表长度 >8 ，并且数组元素个数 ≥64时，会调整成红黑树，目的是提高效率
jdk1.8 当链表长度 <6 时 调整成链表