java基础-3-集合

​​​​​​​​​​

1.Collection:

添加：add(Obj);
删除：remove(Obj);
判断：contains(Obj)
长度为0：isEmpty()
个数：size()
迭代器 ：iterator() 返回一个Iterator 用来遍历所有的元素

1.1 List:

有序，可以元素重复，元素都有索引。
添加：add(index,Obj) ；
删除：remove(index)
取出：get(index) ；
修改: set(index,Obj)
索引：indexOf(Obj)；
子列表：subList(start,end)

1.1.1 ArrayList：

数据结构是：数组，线程不安全的，查询速度快。

1.1.2 Vector：

数据结构：数组，线程安全。无论增删或者查询效率都很低。被ArrayList替代。

Vector是JDK1.0版本出现，里面有一种取出方式：枚举Enumeration。
该枚举中有两个方法： hasMoreElements() nextElement()
因为名称过长，被迭代器Iterator替代：
hasNext() next() 明确的是枚举和迭代的功能是一致的。

1.1.3 LinkedList：

数据结构：双链表。线程不安全的，增删速度很快。

1.2 Set:

无序，不可以元素重复，其中的方法和Collection一致。

1.2.1 HashSet：

底层是哈希表。自动去除重复项
如何保证元素唯一性的呢？ 元素的两个方法，
hashCode，对象的内存地址值
equals ，判断内容是否相同
通过这两个方法来完成元素唯一性。先判断hashCode是否想等，如果相等才会判断equals。

        // Set是接口,创建对象new 的是 实现类HashSet 是其中一个实现类
        Set<String> set = new HashSet<String>();
        //给集合  添加元素
        set.add("Hello1");
        set.add("Hello1");
        set.add("Hello2");
        set.add("Hello3");
        set.add("Hello4");
        //增强for遍历
        for (String string : set) {
            //不含有重复元素   Hello1
            //且存取顺序不一致
            System.out.println(string);
        }

1.2.2 TreeSet：

1.底层是二叉树。
2.当需要自定义排序使用它
排序需要进行比较。有两种方式

• 比较方式一：
  让元素自身具备比较性，需要实现Comparable，覆盖compareTo(obj)方法。

public class Student implements Comparable{
    int age;
    String name;

    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(age, name);
    }
    /**
    * 对象之间进行比较
    */
    @Override
    public int compareTo(Object o) {
        Student student = (Student) o;
        int ageIndex = this.age-student.age;
        if (ageIndex==0){
            ageIndex = this.name.compareTo(student.name);
        }
        return ageIndex;
    }
}

• 比较方式二：
  当元素自身不具备比较性，或者元素具备的比较性不是所需要，这时就必须用第二种方式。让容器具备比较性。定义一个类去实现Comparator接口，并覆盖compare(obj1,obj2)方法。并将Comparator接口的子类对象作为参数传递

    TreeSet<Student> set = new TreeSet<>(new MyComparetor());
     //给集合  添加元素
     set.add(new Student(15, "小李"));
     set.add(new Student(15, "小王"));
     set.add(new Student(16, "小王"));
     set.add(new Student(15, "小王"));
     set.add(new Student(17, "小王"));

	public class MyComparetor implements Comparator {
    @Override
    public int compare(Object o1, Object o2) {
        Student s1 = (Student) o1;
        Student s2 = (Student) o2;
        int value = s1.age-s2.age;
        if (value==0){
            value = s1.name.compareTo(s2.name);
        }
        return value;
    }
}

TreeSet集合的构造函数。
TreeSet集合如何保证元素唯一性的呢？通过return 0；
相对而言，第二种方式较为常用。

当看到Hash开头的对象，底层用的是哈希表。就要想到hashCode方法和equals方法。
当看到Tree开头，就要想到二叉树。就要想到两个接口，
一个是Comparable，一个是Comparator。

1.2.3 LinkedHashSet:

1.存取有序，
2.自动去除重复。
具有hashset的查询速度，内部使用链表来维护插入顺序。在迭代的时候，会按照插入顺序显示。

    public void testHashSet() {

        LinkedHashSet<Student> set = new LinkedHashSet<Student>();
        //给集合  添加元素
        set.add(new Student(15, "小王"));
        set.add(new Student(16, "小王"));
        set.add(new Student(15, "小王"));
        set.add(new Student(15, "小王"));
        set.add(new Student(15, "小李"));

        for (Student stu : set)
            System.out.println("--" + stu);
    }
结果：
--Student{age=15, name='小王'}
--Student{age=16, name='小王'}
--Student{age=15, name='小李'}

1.2.4 SortedSet:

保证元素处于排序状态。frist() last() subSet 生成set的子集。

2. Map:

2.1Hashmap:

可以null键值，基于散列表的实现，效率高，线程不安全，可以通过构造设置容量和负载因子，调整性能。

2.2Treemap:

基于红黑树的实现。查看数据的时候，会被排序。它的顺序有comparable or compartor决定，有subMap（）方法，返回一个子树。

2.3 LinkedHashmap:

基础自hashmap,获取元素的顺序是默认插入元素的顺序，可以通过构造设置（LRU）次序。没有被访问的出现队列的前面。

WeakHashmap:弱健映射，允许释放映射指向的对象。

concurrentHashMap:一种线程安全的map，不涉及同步锁。

2.4 迭代器（Iterator）：

其实就是一种取出方式，加上循环可以取出容器中所有元素。 相当于，大型游戏厅里的 抓娃娃的游戏。迭代器就是这个游戏中的夹子。 是一种规则，每一个容器都在内部实现了这个取出规则。 每一个容器都通过一个方法返回了一个符合规则的对象，这个方法就是iterator();该法方法在JDK1.5被抽取到了Iterable接口中，Iterable接口是Collection的父接口，它的出现提供了一个增强的for循环。

	ArrayList al = new ArrayList();
	al.add("abc");
	for(Iterator it = al.iterator(); it.hasNext(); ){
	            Object obj = it.next();
	            //只使用Object中的方法可以不用强转。
	            System.out.println(obj.toString());//打印的是abc。
	 
	            //如果想打印元素的长度。就必须要强转，
	            //因为用到了元素的特有方法。
	            String s = (String)obj;
	            System.out.println(s.length());
	}

因为容器可以存放不同类型的对象，在添加的时候，add方法必须通过参数Object来接收。
add(new Demo());//Object obj = new Demo();
通过add方法，元素都被提升成了object 。
所以取出的一定是Object,那么如果只使用Object类中的方法，可以不需要强转。
如果要使用元素的特有方法，必须要强转。代码如上。
在实际开发时，对于事物的描述。取出特有属性和行为外，
最好重写hashCode方法和equals方法，同时实现Comparable接口。定义该事物自然比较方式。

class Student implements Comparable
    {
        private String name;
        private int age;
        Student(String name,int age)
        {
            this.name = name;
            this.age = age;
        }
        public int compareTo(Object obj)
        {
            Student s = (Student)obj;
            if(this.age>s.age)
                return 1;
            if(this.age==s.age)
                return this.name.compareTo(s.name);
            return -1;
        }
        public boolean equals(Object obj)
        {
            if(!(obj instanceOf Student))
                return false;
            Student s = (Student)obj;
 
            return this.name.equals(s.name) && this.age == s.age;
                
        }
        public int hashCode()
        {
            return name.hashCode()+age*39;
        }
 
        public String getName()
        {
            return name;
        }
        public String toString()
        {
            return name+":::"+age;
        }
    }