java集合

摘要：本篇文章主要讲解java集合框架

右移一位相当于除2？，关于移位运算！ 枚举？！

接口的意义？

重写equals可以直接影响remove方法？（看源码）

零、一些注意点

1、打印集合没必要加上 .toString 方法，println会自动给你加

2、自定义类中如果重写了equals和toString方法，在集合中是被默认调用的，但目前看源码看不懂（！？？？），主要影响的是 加、删、判断存在 三个方法

3、

一、集合的概念

1.1、概念：

对象的容器（放对象的地方），实现了对对象常用的操作，类似数组的功能

1.2、和数组区别：

  • 数组长度固定，集合长度不固定

  • 数组可以存储基本类型和引用类型，集合只能存储引用类型（可以通过装拆箱来存储基本类型）

1.3、位置：java.util.*;（需要导入）

1.4、位置：堆中

二、Collection体系集合

Col

  • 有序：添加顺序=遍历顺序

  • 有下标：可以通过下标访问

  • Vector已经不用了

Collection父接口

特点：代表一组任意类型的对象，无序，无下标

!!方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
add();//添加元素
addAll(Collection<?> c);//把另一个集合中所有元素添加到此集合
clear();//清空集合
contains(Object o);//判断是否包含 → 地址判断
equals(Object o);//判断对象是否相等 → 地址判断
hashCode();//返回此集合的哈希码值 → 对地址进行哈希方法得到的
isEmpty();//判断此集合是否是空集合
iterator();//返回此集合中的元素的迭代器 → 由集合实现
remove(Object o);//从该集合中删除指定元素的单个实例
removeAll(Collection<?> c);//删除调用集合中包含的所有此集合的元素
retainAll(Collection<?> c);//使调用集合中只保留与参数集合相同的元素
size();//返回集合中的元素个数
toArray();//返回一个包含此集合中所有元素的数组	？
toArray(T[] a);//返回包含此集合中所有元素的数组	？

注：

1、remove方法：当数据类型是基本类型的包装类和String类时，remove根据内容来比对删除。当数据类型是自定义类型时，则比对地址。

  • 此方法不能重写，因为方法是集合固定好的：remove是不能重写，equals可以啊！

  • contains方法完全一致

2、迭代：循环or遍历

3、关于迭代器的指针问题

先贴上源码，不看源码都是扯淡！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    // prevent creating a synthetic constructor
    Itr() {}

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }
}

分析：

1、迭代器相当于有两个指针，一个叫做cursor，一个叫做lastRet，lastRet指针指向的初始位置都是-1，cursor指向的则是0

2、next方法本质是把cursor指针指向的东西给返回（如果cursor已经>=size，就抛异常，结束），然后把cursor+1（cursor加1后的值只会用于下一次next，不会用于任何其他用处）

3、remove方法用的是lastRet指针，在next方法中最后会把cursor原来的值赋给lastRet。移出成功后重新将lastRet设为-1

1
2
3
4
5
6
while(it.hasNext()) {
    Student s=(Student)it.next();
    System.out.println(s.toString());
    it.remove();
//上述代码能把集合清空的原因是，每次next完将cursor指针移动到下一个位置后，remove的指针刚好指向cursor指针的前一个位置
}

iter

实际就四个步骤：

1、has判cur

（i = cur）

2、next取cur

3、cur++

4、lastRet=i

Other：

1
2
3
4
5
6
7
8
9
10
11
12
13
//两种遍历的实现方法
//增强for，因为Collection是没有下标的，不能用普通for循环
for (Object object : collection) {
    Student s=(Student)object;
    System.out.println(s.toString());
}
//迭代器: hasNext()  next();  remove(); 迭代过程中不能使用使用collection的删除方法
Iterator it=collection.iterator();
while(it.hasNext()) {
    Student s=(Student)it.next();
    System.out.println(s.toString());
//    it.remove();
}
1
2
//collection.remove(new Student("王二", 22));
//注意：这里是没法删除的，因为对于自定义类而言，比较的是地址

三、List接口与实现类

实现了list接口，就间接实现了Collection接口

3.0 List接口的特点：

有序、有下标、元素可以重复

因为有了下标，所以删除元素时，既可以通过对象删除，又可以通过下标来删除

1
2
3
4
5
6
7
//相比于集合，所有涉及脚标的方法都是新方法
void add(int index, Object o);//在index位置插入
boolean addAll(int index, Collection c);//把另一个集合中的所有元素插入到index位置
Object get(int index);//返回集合中给定下标的元素
int indexOf(Object c); //返回第一次出现的位置
List<E> subList(int FromIndex, int toIndex);//返回从from到to的集合元素
E set(int index, E element);//修改值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
    public static void main(String[] args) {
        //创建集合
        List list = new ArrayList<>();
//      一、添加元素
        list.add("a");
        list.add("b");
        list.add(0,"c");
        System.out.println(list.size());
        System.out.println(list.toString());
//      二、删除元素
        list.remove("a");
//      list.remove(0);
        System.out.println(list.toString());
//      三、遍历元素
//        1、普通for
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
            //注意：get方法返回的是Object，要用子类型就要强制转换
        }
//        2、增强for
        for (Object o : list) {
            System.out.println(o);
        }
//        3、迭代器
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
//        普通iterator的功能仍是只有三个
//        ListIterator和普通iterator的区别是，前者还可以向前遍历，添加、删除、修改元素
//        4、列表迭代器
        ListIterator listIterator = list.listIterator();
//        从前向后遍历
        while(listIterator.hasNext()){
            System.out.println(listIterator.nextIndex() + ":" + listIterator.next());
        }
//        指针已经移动到末尾了，否则还需要移动指针
//        从后向前遍历
        while(listIterator.hasPrevious()){
            System.out.println(listIterator.previousIndex() + ":" + listIterator.previous());
        }
//      四、获取元素 根据对象返回位置
        System.out.println(list.indexOf("b"));

    }
1
2
3
4
//对于Integer类型的List
//list的remove默认参数是index，可以强转为对象来删,或者用indexOf获取下标来删
        list.remove((Object) 2);
        list.remove(list.indexOf(2));

3.1、List的实现类

  1. ArrayList：

基于数组结构（元素连续存放）实现，查询快，增删慢

运行效率快、线程不安全

  1. Vector：

基于数组结构实现，查询快，增删慢

运行效率慢，线程安全

  1. LinkedList：

链表结构实现，增删快，查询慢

java中链表的删除比起c、c++更为方便，只需要将被删元素前一个元素的指针指向被删元素的后一个元素即可，JVM自动回收垃圾（无人指向的就成了垃圾）

3.2、ArrayList类

注意一点：如果在类中重写了equals方法，则ArrayList的remove方法中可以通过新建对象的方式来删除

1
2
3
4
5
6
7
8
9
public static void main(String[] args) {
    ArrayList arrayList = new ArrayList<>();
    //1、添加元素
    Student student = new Student("liudehua",18);
    arrayList.add(student);
    //2、删除元素
    arrayList.remove(new Student("liudehua",18));
    System.out.println(arrayList.size());
}

重写Object.equals五步走！！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@override
public boolean equals(Object obj){
    //1、判断是否为空
    if(obj==null) return false;
    //2、判断是否是同一个元素
    if(this==obj) return true;
    //3、判断是否为同一类型
    if(obj instanceof Student){
        //如果是同一类型，强转
        Student student = (Student) obj;
        //4、比较属性		
        		if(this.name.equals(student.getName())&&this.age==student.getAge())
            return true;
    }
    //5、不是同一类型，或者属性不相等，就返回false
    return false;
}

源码分析：

1、默认容量：DEFAULT_CAPACITY=10

如果没有向集合中添加任何元素时，容量为0

添加第一个元素后，容量变成默认容量：10

每次扩容为原来的1.5倍

2、存放元素的数组：Object[] elementData

3、实际元素个数：size（小于容量！）

4、添加元素：add方法

先加容量后赋值

add第一句话是扩容，第二句话是赋值（add是用size来赋值的，size表示实际元素数量，用size做下标正好比元素个数多一个，赋值后size++）；

！！

3.3 Vector类

注意遍历用的是枚举器即可

3.4 LinkedList类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//遍历
//普通for、增强for略
//迭代器
Iterator iterator = linkedList.iterator();
while(iterator.hasNext()){
    Student s = (Student) iterator.next();//不强转返回的是Object
    System.out.println(s.toString());
}
//
ListIterator listIterator = linkedList.listIterator();
while(listIterator.hasNext()){
    Object s = listIterator.next();
    System.out.println(s.toString());//但是toString已经被重写了，所以即使不强转也会调用重写的方法，但是不强转，有些Student独有方法用不了
}

源码分析

size：表示集合长度

first：集合头结点

last：集合尾结点

关于java中链表结点的理解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

//Node<E> 是一个引用，就相当于C中的地址，所以，Node类中保存了指向指向下一个和前一个结点的引用，注意不是下一个和前一个结点本身！
//这个类的实例存储在堆中，也有引用指向这个实例，实例中才保存着结点的引用！

手撕LinkedList！

LinkLast方法和结点的定义

3.5 ArrayList与LinkedList

A：开辟连续空间、查询快、增删慢

L：无需开辟连续空间、查询慢、增删快

四、泛型

4.1、简介：

  • java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递

  • 常见形式有泛型类、泛型接口、泛型方法

    意思就是：使用泛型的类、使用泛型的接口、使用泛型的方法

  • 语法

    <T,…> T称为类型占位符，表示一种引用类型（总不能是基本类型吧）

    <T,E,F>多个使用逗号隔开

  • 好处：

    提高代码重用性

    防止类型转换异常，提高代码安全性

  • 注意：

    你就考虑创建泛型对象！泛型对象可以被当作参数传过来，自己创建却是不可的！

4.2 泛型类：

？？？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//所谓泛型类，即把类作为参数传递
public class GenericDemo<T>{
    //创建泛型引用
    T t;
    
    public void NEW(){
        T t1 = new T();
        //错，不能实例化！（万一构造方法私有怎么办，万一没有无参构造怎么办）
    }

    //泛型作为方法的参数
    public void show(T m){
        System.out.println(m);
    }
    //泛型作为方法的返回值
    public T getT(){
        //这里实际上是return this.t 只不过方法和变量都是成员，就可以省略this
        return t;？？？
    }
    
    public void prinT(){
        System.out.println("没有泛型老子就不能活了吗？！！");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
public class Test {
    public static void main(String[] args) {
        //泛型类当作普通类使用
        GenericDemo genericClassDemo = new GenericDemo();
        genericClassDemo.prinT();
	    //泛型类的使用
        GenericDemo<String> genericClassDemo1 = new GenericDemo<>();
        genericClassDemo1.t = "我将作为genericDemo1的成员啦！";
        genericClassDemo.show("大家好，你直接传递给我T类型的参数我就能用");
        System.out.println(genericClassDemo1.t);
    }
}

注：

  1. 泛型类不能直接实例化

    1
    2
    3
    4
    public void NEW(){
        T t1 = new T();
        //错，不能实例化！（万一构造方法私有怎么办，万一没有无参构造怎么办）
    }

  2. 泛型类实例化的时候，后面尖括号中的内容可以不写

  3. （1）泛型只能使用引用类型 （2）不同泛型对象之间不能相互赋值（总不能把Integer的实例赋给String的泛型类吧）

    1
    2
    3
    GenericDemo<String> genericClassDemo1 = new GenericDemo<>();
    GenericDemo<Integer> genericDemo2 = genericClassDemo1;
    //想屁吃呢！

  4. 不传递泛型也可，因为本质是传递了Object类（？？？）

4.3 泛型接口

1
2
3
4
5
6
7
8
9
10
11
12
/**
 * 泛型接口
 * 语法：接口名<T>
 * 注意：不能定义泛型的静态常量
 * @param <T>
 */

public interface GenericInterface <T>{
    String name = "我是接口内的静态常量成员";
//    T t = new T(); 不可以初始化你怎么定义静态常量
    T server(T t);
}
泛型接口的实现方法

一、在实现的时候确定泛型，要不同的泛型，就创建不同的实现类

1
2
3
4
5
6
7
public class GenericImpl implements GenericInterface<String>{
    @Override
    public String server(String s) {
        System.out.println(s);
        return s;
    }
}

二、实现类仍然采用泛型形式，到泛型类实例化的时候再确定泛型

1
2
3
4
5
6
7
8
9
10
11
public class GenericImpl2<T> implements GenericInterface<T> {
    @Override
    public T server(T t) {
        System.out.println(t);
        return null;
    }
	//退化使用
    public void printT(){
        System.out.println("就算老子继承了泛型接口，老子不要泛型参数也能活！");
    }
}

Test：

1
2
3
4
5
6
7
8
9
10
//泛型接口
GenericImpl generic = new GenericImpl();
generic.server("类实现接口的时候就传入泛型哦！");

GenericImpl2<String> genericImpl2 = new GenericImpl2<>();
genericImpl2.server("我是通过泛型类的方法实现的");

//退化：
GenericImpl2 genericImpl21 = new GenericImpl2();
genericImpl21.printT();

注：

即使继承了泛型接口，泛型类仍可以退化为一个正常的类。

深层原因是默认传递了Object类

4.4 泛型方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * 泛型方法
 * 语法：<T> 返回值类型 ：将泛型放在返回值类型前
 */

public class GenericMethod {
    //泛型作为参数
    public <T> void show(T t) {
        System.out.println("泛型方法"+ t);
    }
    //泛型作为返回值
    public <T> T showw(T t) {
        return t;
    }
}
1
2
3
GenericMethod genericMethod = new GenericMethod();
genericMethod.show("String");
System.out.println(genericMethod.showw("String"));

注：

  1. 注意使用范围，只能在当前方法中使用

  2. 泛型方法的调用，不用传递类型：方法直接根据传递的对象确定类型

4.5 泛型的好处

提高代码的重用性，一套代码，适用于不同的传入对象类型，以前只能通过方法重载

1
2
3
4
5
6
7
8
//不同类型对象作参数
genericMethod.show("String");
genericMethod.show(123);
genericMethod.show(3.131);
//不同类型对象作为返回值
String str = genericMethod.showw("String");
Integer in = genericMethod.showw(112);
Double dd = genericMethod.showw(3.13);

4.6 泛型集合

  • 概念：java集合都是泛型集合，在创建集合的时候传递类型，强制集合元素的类型必须一致

  • 特点：

    • 编译时即可检查，而非运行时抛出异常。
    • 访问时，不必类型转换（自动类型转换，Object → 泛型）
    • 不同泛型之间的引用不能相互赋值，泛型不存在多态（相同当然可以赋值）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
ArrayList<String> objects = new ArrayList<>();
objects.add("aaa");
objects.add("bbb");

for (String object : objects) {
    String s = object;
    System.out.println(s);
}

ListIterator<String> listIterator = objects.listIterator();
while(listIterator.hasNext()){
    String ss = listIterator.next();
    System.out.println(ss);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
ArrayList object = new ArrayList<>();
object.add("a");
object.add("d");
object.add(1);
object.add(2);
for (Object o : object) {
    if(o instanceof String){
        String s = (String) o;
        System.out.println(s);
    }
    if(o instanceof Integer){
        Integer integer = (Integer) o;
        System.out.println(integer);
    }
}
//LinkedList不指明类型的话，默认Object，什么都可以加，但是用的时候要强转，还要判断类型，费事且不安全（instanceof测试）

五、Set接口与实现类

  • 无序、无下标、不重复

Set接口：模仿了数学上的Set（集合）

Set接口的方法全部继承自Collection接口，没有新的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
 * 测试Set接口
 * 特点：无序：添加顺序不一定等于访问顺序 无下标：不可执行下标有关操作 不重复
 */

public class SetDemo {
    public static void main(String[] args) {
        //创建集合
        Set<String> set = new HashSet<>();
        //1、添加数据
        set.add("cc");
        set.add("bb");
        set.add("aa");
        set.add("aa");//
        System.out.println(set.toString());
        //2 移除，只能通过对象移出，没有下标
        set.remove("aa");
        System.out.println(set.toString());
        //3 遍历，由于没有下标，只有如下两种方法
        //3.1 foreach（不需要下标）
        //3.2 Iterator
        Iterator<String> iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //4 判断、判空
        System.out.println(set.contains("bb"));
        System.out.println(set.isEmpty());
    }
}

注：添加重复的元素不会报错，什么都不会做

Set实现类

1、HashSet
  • hashSet的方法和Set完全一样，不再演示
  • 简单理解，HashSet比的是hashcode和equals（需要比的操作：加、删、包含）

hashSet存储过程：

1）维护一个数组，新来一个对象，根据hashcode算在数组中的位置，如果该位置为空则直接插入，如果该位置不空，第二步

2）执行对应类下的equals方法，如果为true，则重复，拒绝添加；否则，形成链表。

  • JDK1.8之后增加红黑树的实现

？？？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static void main(String[] args) {
    HashSet<Person> hashSet = new HashSet<>();
    hashSet.add(new Person("a",10));
    hashSet.add(new Person("b",10));
    hashSet.add(new Person("c",10));
    //hashcode相同，equals为true，则加不进去
    hashSet.add(new Person("c",10));

    System.out.println(hashSet.size());
    hashSet.remove(new Person("c",10));
    System.out.println(hashSet.size());
    // ？？？
    //正是因为重写了hashcode和equals方法，使得我们可以通过字段值来删除
    //没重写的时候，除非地址一样，否则是删不掉的，因为地址不一样，
    //HashSet通过hashcode和equals方法判断是否有

    ArrayList<Person> people = new ArrayList<>();
    people.add(new Person("aa",15));
    people.add(new Person("bb",16));
    people.add(new Person("cc",17));
    people.remove(new Person("aa",15));
    System.out.println(people.size());
    //List接口的实现类没有hashcode字段，所以仅重写equals方法就可根据内容删除了
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//重写hashcode保证name，age相同的元素，hashcode一定相同
//如果不重写，即使字段一样，hashcode也不一样
@Override
public int hashCode() {
    int n1 = age;//age是int基本类型的，存在栈中，哪来的hashcode
    int n2 = name.hashCode();
    return n1+n2;
}
//重写equals，保证相同内容的对象加不进来
@Override
public boolean equals(Object o) {
    if(o==null)
        return false;
    if(o==this)
        return true;
    if(o instanceof Person){
        Person person = (Person) o;
        if(person.name==name&&person.age==age){
            return true;
        }
    }
    return false;
}

注：

  • 自定义类默认的equals是比地址，可以重写

  • HashSet集合在添加自定义类型时，在自定义类型对象的类中不重写equals方法和hashCode方法时，每一个新的对象都对应新的地址

  • hashcode()中的31：（1）质数，减少散列冲突 （2）提高执行效率，可以用位运算解决

    $$
    31*i=(i<<5)-i
    $$

  • 关于remove方法的比较流程考究 ？？？

还有一个LinkedHashSet，其内部元素有序，用法同HashSet

2、TreeSet

用红黑树（特殊的二叉树）实现，二叉查找树就是二叉搜索树

那些年，面试被虐过的红黑树 - SegmentFault 思否

？？？

简单理解，TreeSet比的是CompareTo方法（需要比的操作：加、删、包含）

特点：

  • 基于排列顺序实现元素不重复
  • 实现了SortedSet接口，对集合自动排序（插入的时候）
  • 元素对象的类型必须实现Comparable接口，指定排序规则
  • 通过CompareTo方法确定是否为重复元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/**
 * TreeSet的使用
 * 存储结构：红黑树
 * 判断方法：如果compareTo结果为0，就认为是重复、存在、删除目标
 */

//接口还要导入:因为构造了接口的引用，所以要导入

public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet<Person> treeSet = new TreeSet<>();
        treeSet.add(new Person("xyz",10));
        treeSet.add(new Person("abc",9));
        treeSet.add(new Person("hij",12));
        treeSet.add(new Person("hij",12));//重复
        //直接添加会导致：ClassCastException
        //原因是：没有实现Comparable接口，即没有实现CompareTo方法，不能加入TreeSet中，因为加入过程中不知道怎么比较
        //让Person类实现Comparable接口即可

        System.out.println("元素个数" + treeSet.size());
        treeSet.remove(new Person("hij",12));
        System.out.println("元素个数" + treeSet.size());

        //在重写之前，只能通过引用来删除？
    }
}
1
2
3
4
5
6
7
8
9
10
    @Override
    public int compareTo(Person person) {
        int n1 = this.getName().compareTo(person.getName());
        int n2 = this.getAge()- person.getAge();
        return n1 == 0 ? n2 : n1;
        //先按姓名比，再按年龄比
    }
//    注1：comparable接口在继承的时候传入Person泛型，就不用强转了
//    注2：String自带compareTo方法，返回字典序差值
//    注3：int不带compareTo方法，返回差值即可

Comparator接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * TreeSet集合的使用
 * Comparator接口实现定制比较
 * 实现了Comparator就不用实现Comparable
 */
public class ComparatorDemo {
    public static void main(String[] args) {
        TreeSet<Person> personTreeSet = new TreeSet<>(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                int n1 = o1.getAge()-o2.getAge();
                int n2 = o1.getName().compareTo(o2.getName());
                return n1==0?n2:n1;
            }
        });
        personTreeSet.add(new Person("xyz",5));
        personTreeSet.add(new Person("abc",10));
        personTreeSet.add(new Person("hij",12));
        personTreeSet.add(new Person("eij",12));
        System.out.println(personTreeSet);
        //直接打印集合，集合会调用集合内类型的toString方法
    }
}

使用TreeSet的Comparator排序真的很牛逼

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * 要求：使用TreeSet集合实现按字符串长度排序
 * Comparator接口实现定制
 * Comparable只能到对应的类内部去改，字符串写好了，你怎么改
 */
public class TreeSetDemo2 {
    public static void main(String[] args) {
        TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length()==0?o1.compareTo(o2):o1.length()-o2.length();
                //都是前面减后面、前减后
            }
        });
        treeSet.add("helloworld");
        treeSet.add("zhang");
        treeSet.add("list");
        treeSet.add("wangwu");
        treeSet.add("beijing");
        treeSet.add("xian");
        System.out.println(treeSet);
    }
}

六、Map接口与实现类（Map没有继承Collection接口）

Map接口的特点：

  • 用于存储任意键值对（Key—Value）
  • 键：无序、无下标、不允许重复（唯一）
  • 值：无序、无下标、允许重复
1
2
3
4
5
6
7
8
9
10
11
12
13
14
//Map接口的方法
void clear();
boolean containsKey();
boolean containsValue();
Set<Map,Entry<K,V>> entrySet();
boolean equals();
V get(Object Key);
boolean isEmpty();
Set<E> KeySet();// 从这里就看出来，Key不能重复
V put(K key, V value);
V putAll(Map<>);
v remove(Object key);
int size();
Collection<V> values();// 从这里看出来，Value可以重复

Map接口示范

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/**
 * 存储的是键值对
 * 键不能重复，值可以重复
 * 无序
 */
public class MapDemo {
    public static void main(String[] args) {
        //创建集合
        Map<String, String> map = new HashMap<>();
        map.put("cn","中国");
        map.put("uk","英国");
        map.put("usa","美国");
        map.put("usa","meiguo");//相同的键会覆盖

        System.out.println(map.size());
        System.out.println(map.toString());

        //直接删掉键值对
        map.remove("usa");
        System.out.println(map.toString());

        //遍历Map
        //1 键集合：keySet()  Set类型就可以迭代器or foreach
        //通过键集合遍历+根据键获取值
        /* 迭代器方式
        Set<String> keySet = map.keySet();
        Iterator<String> iterator = keySet.iterator();
        while(iterator.hasNext()){
            String key = iterator.next();
            System.out.println(key+":"+map.get(key));
        }
        */
        //增强for方式
        for (String s : map.keySet()) {
            System.out.println(s+":"+map.get(s));
        }

        //2 键值对封装类型：（效率更高，1还要查找）
        //把键值对封装在一起，叫做entry。它的类型是Map.Entry<T,E>
        //通过entry键值对直接获得键和值
        Set<Map.Entry<String,String>> entries= map.entrySet();
        //Entry也是一个接口，即Map接口中的接口
        for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
        System.out.println(map.containsKey("cn"));
        System.out.println(map.containsValue("taiguo"));
    }
}

Map集合的实现类

Map重复的会覆盖，Set重复的直接加不进来

1、HashMap实现

JDK1.8之后增加红黑树的实现

  • 当数组长度>=64，且数组某个位置的链表长度大于8的话，会把链表调整成红黑树！
  • 当链表长度<=6之后，就取消红黑树，恢复成链表

  • 线程不安全、运行效率快；允许用null作为key或者value

  • 默认容量：16 默认加载因子0.75：元素超过75%后就扩容

hashMap基本实现如上，下面补充一些问题

1
2
3
4
5
6
7
8
9
10
//hashMap存在的问题: 自定义类不满足“去重” 要求。究其原因是hashmap底层实现是哈希表——哈希表在存储自定义类的时候，如果自定义类中没有重写关于hashcode和equals方法的话，会调用默认的方法，而新对象地址不同，就会被认为不同。
//可以认为hashcode和equal都与对象地址有关
hashMap.put(new Student("张馨予",12),"xx");
hashMap.put(new Student("张馨予",12),"xx");
System.out.println(hashMap.size());
//可以看到，通过修改Student的hashcode和equals方法，达到目的

hashMap.remove(new Student("张馨予",12));
//通过key来删除
System.out.println(hashMap.size());

源码分析：

Node<K,V>结点

Node<K,V>[] table 数组

刚创建Map的时候，table=null，size=0

类似ArrayList，刚开始为空，为了节省空间，加入一个元素以后，数组变为默认大小（HashMap为16）

当元素比例超过因子时，就扩容为原来的两倍

JDK1.8之前为头插入，JDK1.8之后为尾插入

HashSet内部就是由Hashmap实现的

2、HashTable

  • 数组+链表：现在用的少

  • 线程安全、运行效率慢；不允许用null作为key或者value

Properties：HashTable子类，要求key和value都是String，通常用于配置文件的读取

3、TreeMap

实现了SortedMap接口（是Map的子接口），可以实现对key的自动排序

注：要么在类中实现Comparable接口，要么实例化的时候实现Comparator接口

TreeSet内部是由TreeMap实现的

七、工具类

Collections工具类提供静态方法

集合工具类，定义了除了存取以外的集合的常用方法，可以用来操作集合

1
2
3
void reverse(List<?> list);//反转元素顺序
void shuffle(List<?> list);//随机重置顺序(打乱)
void sort(List<?> list);//升序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Integer[] nums={1,100,11,21,28};
List<Integer> list = new ArrayList<>(Arrays.asList(nums));
//
Collections.sort(list);
//
int i = Collections.binarySearch(list,21);
System.out.println(i);
//二分查找返回下标，负数表示找不到

//
List<Integer> des = new ArrayList<>();
des.add(0);
des.add(0);
des.add(0);
des.add(0);
des.add(0);
Collections.copy(des,list);
System.out.println(des);
//copy方法存在的问题：目标数组大小必须大于等于原数组大小，不会自动扩容
//而且会从头开始赋值，覆盖目标数组
Collections.reverse(list);
Collections.shuffle(list);

1
2
3
//初始化问题
List<Integer> list = new ArrayList<>(10);
//这样是没用的！？？

八、注意事项（数组、集合互转）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//补充：List转数组
Integer[] arr= list.toArray(new Integer[0]);
Integer[] arr1= list.toArray(new Integer[10]);
//后面必须加个参数，因为需要由参数来知晓类型
//如果参数数组长度小于list，长度会变成list的长度
//如果参数数组长度大于list，则结果长度等于参数数组的长度
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(arr1));

//补充：数组转List
String [] names = {"a","b","c"};
List<String> list2 = Arrays.asList(names);
System.out.println(list2);
//注意：！！由数组转成的List不能删、不能增。即不可改变
//基本类型的数组转为集合时，应当先转换为包装类
Integer[] nums = {1,2,4,5,6,223,41,23};
List<Integer> numlist = Arrays.asList(nums);

asList的结果不能改变的解决办法

1
2
3
4
5
6
7
8
//初始化
String[] strs = {"a","b","c"};
List<String> str = new ArrayList<>(Arrays.asList(strs));
//addAll()
String[] strs = {"a","b","c"};
List<String> str = Arrays.asList(strs);
List<String> str1 = new ArrayList<>();
str1.addAll(str);

九：常用集合补充

1、Stack类：(继承Vector，基于数组实现)

1
2
3
4
5
6
7
8
9
10
Stack<Integer> stack = new Stack<>();
Boolean bool = stack.isEmpty();//判空
Integer res = stack.pop();//弹出
Integer inValue = stack.push(10);//压入
int searchAns = stack.search(10);//搜索
Integer top = stack.peek();//获取栈顶元素而不删除
Integer num = stack.get(2);//根据下标获取栈中元素

//search方法：返回目标元素第一次出现的位置，从栈顶往下数，栈顶是1。即如果出现多次，算最上面那次
//get方法：根据下标返回栈中元素，从栈底（最下面）向栈顶数（最上面），栈底是1

补充Queue接口

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家