集合体系:

集合:

接口:

Collection Map List Set

实现类:

ArrayList LinkedList HashSet TreeSet HashMap

通过创建实现类指向接口对象,去创建接口

注意:
Queue接口与List、Set同一级别，都是继承了Collection接口。
看图你会发现,LinkedList既可以实现Queue接口,也可以实现List接口.只不过呢, LinkedList实现了Queue接口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果 是Queue时，就完全只能访问Queue接口所定义的方法 了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。

SortedSet是个接口，它里面的（只有TreeSet这一个实现可用）中的元素一定是有序的。

Collection

概述:

	是单列集合的顶层接口，表示一组对象，这些对象也称为了Collection的元素

	JDK不提供此接口的直接实现类，提供了更具体的子接口(List和Set)实现

使用:

	通过多态的方式

	集合的实现类ArrayList和LinkedList

常用方法:

迭代器:

Iterator:迭代器,集合的专用遍历方式

Iterator<E> iterator():返回此集合中的元素,通过集合中的iterator()方法得到

Iterator中的常用方法:

为什么要使用迭代器？

for循环遍历ArrayList,如果我换一个集合Map,就不能进行遍历,而Iterator模式总是用同一种逻辑来遍历集合。

List:

概述:

	有序集合(序列):可以精准的控制元素的插入位置，可以通过索引来访问元素

特点:

	有序:存储和取出的元素顺序一样

	可重复:存储的元素可以重复

特有方法

增强for

简化数组和集合的遍历

内部原理是一个Iterator迭代器

增强for格式:

for(元素数据类型 变量名:数组或Collection对象){
		//代码体直接使用变量即可

	}

范例:

int[] arr={1,2,3}

	for(int i:arr){

		System.out.print(i)

	}

ArrayList数组结构

数组是一种查询快，增删慢的模型

查询快:查询数据通过索引定位，查询任意数据耗时相同

删除慢:删除元素时,要讲原始数据删除,同时元素进行前移

添加慢:添加元素时,要在添加位置的每一个数据进行后移,再添加元素

LinkedList链表结构

链表是一种增删快，查询慢的模型

增删快:增加和删除时,只需要修改下一个地址指向，耗时相同

查询慢:查询数据时,都需要从头开始查询

Set:（没有独有的方法,在学习完Collection,set就已经学完了）

特点:

	元素不重复

	无序(插入和取出的顺序不能保证一致)

	无下标

HashSet:

特点:

	元素不重复

	无序(插入和取出的顺序不能保证一致)

	无下标

哈希值

概述:

	根据对象的地址值或者字符串或者数字计算得到的int类型的数值

Obeject中可以通过方法来获取哈希值

哈希值特点:

	同一个对象多次调用hasCode()方法返回的哈希值是相同的

	默认情况下，不同对象的的哈希值是不同的，通过重写hasCode(),可以实现让不同对象的哈希值相同

注意:通话和重地的哈希值相同

HashSet的存储机制

结构:元素为链表的数组

1.获取存储对象的哈希值

2.计算哈希值得到存储位置

3.如果存储的位置链表没有数据直接插入

4.1.如果位置相同:判断哈希值,在判断equals

4.2.不相同直接插入

注意:

覆盖
本质上还是使用equals判断

TressSet

特点:

不重复
没有下标
无序(因为元素有序,所以插入和取出的顺序不能保证一致)
元素有序(自然排序:按数字进行排序)

元素有序,不是存储或取出有序,而是按照一定的规则进行排序,排序方式取决于构造方法

使用无参构造:

自定的类需要实现Comparable

使用有参的构造:

自定的类不需要实现Comparable,比较方式通过创建一个新的类继承Comparable接口（或者匿名类）实现

Comparable:

用TreeSet存储对象,无参构造方法使用自然排序

自然排序的实现，就是元素实现Comparable接口，重写compareTo方法

重写方法时,排序规则要按需求的主次条件来写

compareTo:返回值分类三类

	正整:插入的数据比原来的大
	负数:插入的数据比原来的小

	零:表示相同数据,去重

注意:

	this:插入的数据
	o:已存在的数据

Comparator:

用TreeSet存储对象,有参构造方法使用比较器进行排序
比较器的实现，就是让集合构造接收Comparator接口的实现类，重写compare方法
重写方法时,排序规则要按需求的主次条件来写

1.排序的引入（以基本数据类型的排序为例）
由于TreeSet可以实现对元素按照某种规则进行排序，例如：

import java.util.TreeSet;

public class myClass {
    public static void main(String[] args) {
        TreeSet<Integer> integers = new TreeSet<>();
        integers.add(10);
        integers.add(15);
        integers.add(30);
        integers.add(20);
        integers.add(40);
        integers.add(44);
        for (Integer integer : integers) {
            System.out.println(integer);
        }


    }
}

2.如果是引用数据类型，自定义对象，该如何排序？
student类

public class Student {
    private int age;

    public Student(int age) {
        this.age = age;
    }

    public Student() {

    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

myclass

import java.util.TreeSet;

public class myClass {
    public static void main(String[] args) {
        TreeSet<Student> students = new TreeSet<>();
        Student zs = new Student(10);
        Student ww = new Student(20);
        Student student = new Student(12);
        students.add(zs);
        students.add(ww);
        students.add(student);
        for (Student student1 : students) {
            System.out.println(student1);
        }


    }
}

结果报错：Exception in thread “main” XXXXXXXXcannot be cast to java.lang.Comparable
（原因：由于不知道要使用哪一种排序方式排序，所以报错，反正就是没实现Comparable）

一、自然排序
①Student类中实现Comparable接口
②重写Comparable接口中的Compare to方法

compareTo（T o） 比较当前对象与指定对象的顺序

import java.util.TreeSet;

public class Class {
    public static void main(String[] args) {
        TreeSet<Student> students = new TreeSet<>();
        Student zs = new Student("zs",18);
        Student ls = new Student("ls", 20);
        Student ww = new Student("ww", 20);
        students.add(zs);
        students.add(ls);
        students.add(ww);

        for(Student s:students){
            System.out.println(s.getName()+s.getAge());
        }
    }
}

public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public int compareTo(Student o) {
        int i = this.age - o.age;
    	int i1=(i==0)?this.name.compareTo(o.name):i;
        return i1;
    }
}

二、比较器排序
比较器排序步骤：
①单独创建一个比较类（可以单独搞个类，不过我懒，直接使用匿名内部类O(∩_∩)O），并且要让其继承Comparator接口
②重写Comparator接口中的Compare方法

compare（T O1,T O2）  比较用来排序的两个参数

Student
    public class Student  {

        private int age;

        public Student(int age) {
            this.age = age;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }

Class

import java.util.Comparator;
import java.util.TreeSet;

public class Class {public static void main(String[] args) {
    TreeSet<Student> students = new TreeSet<Student>(new Comparator<Student>() {
        @Override
        public int compare(Student o1, Student o2) {
            int i = o1.getAge() - o2.getAge();
            return i;
        }
    });
    Student zs = new Student(18);
    Student ls = new Student( 20);
    students.add(zs);
    students.add(ls);

    for(Student s:students){
        System.out.println(s.getAge());
    }
}
}

|
|
|
|
|
上一章–DAY16.1面对对象思维导图（粉丝可见分享）
下一章-随缘更新
天天更新不容易，随手点个小赞