java集合

Collection的基础#

Collection是java里最基础的集合，所有的集合都继承自Collection接口，所有集合的实现类都实现了Collection接口。

Collection接口定义了集合的基本操作，包括添加、删除、判断、清空等。

通用方法#

特别说明#

1，add小细节：添加返回值，对于list而言，是允许插入的，永远返回true；对于set而言，由于set不允许重复，若添加的重复元素会不成功，返回false

2，remove小细节：由于Collection定义共性的方法，所以不能通过索引来删除数据，只能用元素的对象。remove也有返回值，成功删除返回true，反之false

3，contains小细节，当我们要用自己写的类存在集合里面的话，想用contains，必须要在类内实现equals的重写。因为contains的底层有用到equals

关于collection的遍历方式（这里讨论通用的，即list和set都可以用的）#

1
构造：Iterator<E> 迭代器名称=集合名.Iterator();//意为创建一个这个集合的一个迭代器指针，默认指向0

1
//遍历方式的写法
2
Iterator<Integer> i = arr.iterator();
3
while (i.hasNext()) {
4
System.out.println(i.next());
5
}

1
//遍历方式的写法
2
for (Integer i : arr) {
3
System.out.println(i);
4
}

1
//遍历方式的写法
2
arr.forEach(new Consumer<Integer>() {//匿名类的写法，重写accept方法
3
@Override
4
public void accept(Integer A) {//这里传递的相当于增强for里的那个参数名，与数组的元素对应
5
System.out.println(A);
6
}
7
});

1
arr.forEach(integer -> {System.out.println(integer);});

List方法#

对应上面那个图，它继承于Collection接口，所以能用collection的方法，此外它也有一些独特的方法，总的来说对应，增，删，改，查。

小细节#

• remove（），我们注意到，这里有remove的重载，而在调用的时候，会优先调用参数数据类型一致的方法。
• 所以这里如果是integer类型的集合，使用remove（1）；的话，他是删除1索引上的元素。
• 如果想删除指定元素的话，要手动装箱Integer i=integer.valueOf(1),才能删除“1”这个数字

List遍历方式#

使用列表迭代器ListIterator（）

1
ListIterator<Integer> listIterator = list.listIterator();
2
while (listIterator.hasNext()) {
3
System.out.println(listIterator.next());
4
}

基础的使用方式和正常迭代器的方式基本一样，但是它允许在遍历的时候用add和remove方法对集合作改动，具体可搜索API：ListIterator查找方法

方法#

Set介绍#

Set是一个无序的不可重复的集合，常用实现类有HashSet、TreeSet等。

它没有额外的方法，常用的都继承于collection

遍历方式

-1，迭代器（Iterator）

1
Iterator<Integer> iterator = set.iterator();
2
while (iterator.hasNext()) {
3
System.out.println(iterator.next());
4
}

-2，增强for

1
for (Integer i : set) {
2
System.out.println(i);
3
}

-3，Lambda（forEach）

1
set.forEach(integer -> {System.out.println(integer);});

因为下面的实现类继承于set，所以Hashset，linkedHashSet，treeSet都能用这三种遍历方式

HashSet介绍#

set集合的实现方法之一

无额外方法，这里讲讲底层

-它底层上用哈希表存数据，而哈希表是数组+链表+红黑树 -哈希表里有一重要的东西：哈希值 -哈希值是对象的整数表达形式，通过哈希值才能确定元素在哈希表的位置

哈希值#

• 根据 hashCode 方法算出来的 int 类型的整数
• 该方法定义在 Object 类中，所有对象都可以调用，默认使用地址值进行计算
• 一般情况下，会重写 hashCode 方法，利用对象内部的属性值计算哈希值

对象的哈希值特点#

• 如果没有重写 hashCode 方法，不同对象计算出的哈希值是不同的
• 如果已经重写 hashcode 方法，不同的对象只要属性值相同，计算出的哈希值就是一样的
• 在小部分情况下，不同的属性值或者不同的地址值计算出来的哈希值也有可能一样。（哈希碰撞）
• HashSet插入数据的位置是根据”index=（数组长度-1）&哈希值“计算的

HashSet插入数据的方式#

• ① 创建一个默认长度 16，默认加载因为 0.75 的数组，数组名 table

• ② 根据元素的哈希值跟数组的长度计算出应存入的位置

• ③ 判断当前位置是否为 null，如果是 null 直接存入

• ④ 如果位置不为 null，表示有元素，则调用 equals 方法比较属性值

• ⑤ 一样：不存  不一样：存入数组，形成链表

• JDK8 以前：新元素存入数组，老元素挂在新元素下面

• JDK8 以后：新元素直接挂在老元素下面，另外，当链表长度超过8，而且数组长度大于等于64的时候，这个链表自动转为红黑树

小细节#

如果在集合存的是自定义对象，那么一定要在类内重写hashCode方法和equals方法。否则哈希值会用地址值来计算，这没有意义。

遍历#

他会从数据的0索引开始，一条链表一条链表的去遍历元素，和插入的顺序不一样，所以无序

总结#

总的来说，HashSet是一个在数组里放链表的一种数据结构，并且在数据多了以后还会改用红黑树来存储。

LinkedHashSet介绍#

• 无新方法，使用collection继承方法
• 它同样也是哈希表：数组里存链表，但是是在每个添加的元素上多了个双链表机制，前后两个元素可以相互记录，用以遍历，因此有序

具体如图

TreeSet介绍#

• 特点：不重复，无索引，可排序：默认从小到大
• 它的底层是基于红黑树的结构实现排序的

排序规则#

• 1，对于数值类型，都是从小到大的默认升值排序
• 2，对于字符，字符串类型，是按照字符在ASCII码表中的数字升序排序。而字符串这种不只一个字符的，他会从第一个字符开始比，如果一样就往后找一个看，直到有任何一次能比出区别，就不再看了，所以它与长度无关
• 3，如果我们使用自定义类型，那就需要设定比较规则，这有两种方式

1
public class Student implements Comparable<Student>{
2
    //成员内容省略
3
    ......
4

5
    @Override
6
    public int compareTo(Student o) {
7
        //首先我们要知道，treeset的排序是依靠红黑树实现的，这个方法就是内部做红黑树排序时会调用的比大小方法
8
        //this是当前要插入的元素，o是原来就存在的数，这里表示按年龄升序排
9
        //3. 方法返回值的特点
10
        //- 负数：表示当前要添加的元素是小的，存左边
11
        //- 正数：表示当前要添加的元素是大的，存右边
12
        //- 0 : 表示当前要添加的元素已经存在，舍弃
13
        return this.getAge()-o.getAge();
14
    }
15
}

1
TreeSet<String> Sset2=new TreeSet<>(new Comparator<String>() {
2
            //o1：表示要添加的元素
3
            //o2：表示在红黑树存在的元素
4
            @Override
5
            public int compare(String o1, String o2) {
6
                int i=o1.length()-o2.length();//优先比长度
7
                if(i==0){
8
                    i=o1.compareTo(o2);//长度一致再比ARCII码
9
                }
10
                return i;
11
            }
12
        });
13
        Sset2.add("yi");
14
        Sset2.add("abd");
15
        Sset2.add("abc");
16
        Sset2.add("abde");
17

18
        System.out.println(Sset2);

1. 如果想要集合中的元素可重复#

用 ArrayList 集合，基于数组的。（用的最多）

2. 如果想要集合中的元素可重复，而且当前的增删操作明显多于查询#

用 LinkedList 集合，基于链表的。

3. 如果想对集合中的元素去重#

用 HashSet 集合，基于哈希表的。（用的最多）

4. 如果想对集合中的元素去重，而且保证存取顺序#

用 LinkedHashSet 集合，基于哈希表和双链表，效率低于 HashSet。

5. 如果想对集合中的元素进行排序#

用 TreeSet 集合，基于红黑树。后续也可以用 List 集合实现排序。

Map介绍#

它是一个键值对（Entry）的集合，每个键值对之间用逗号隔开，键值对之间用大括号隔开。所以内部其实是存在一个Entry对象的，每个Entry对象里存着键和值。

格式： Map<键类型,值类型>

它也像collection一样，有自己的体系图

Map的常见方法#

小细节

put()方法： 如果键不存在，就添加键值对，如果键存在，就用新的值替换旧的值，并且会返回被替换的值

Map的遍历#

• 1，通过键找值：先用keyset（）方法，在一个set集合里存放所有的键对象，再遍历这个set集合，然后用get（key）方法获取对应的值。

1
Map<String,Integer> map = new HashMap();
2
        map.put("a",1);
3
        map.put("b",2);
4
        map.put("c",3);
5

6
        System.out.println(map);
7
        Set<String> set=map.keySet();//获取所有的键对象，存进set集合里
8
        for(String ch:set){//遍历
9
            System.out.println(map.get(ch));//这里要注意，.get()还是由Map对象调用的，传入的值是key，返回的值是value。
10
        }

• 2，通过键值对找：先用entryset（）方法，在一个set集合里存放所有的键值对对象，再遍历这个set集合，然后用getkey（）方法获取键对象，用getvalue（）方法获取值对象。

1
Map<String,Integer> map2 = new HashMap<>();
2
        map2.put("a",1);
3
        map2.put("b",2);
4
        map2.put("c",3);
5

6
        Set<Map.Entry<String,Integer>> entries = map2.entrySet();
7
        for(Map.Entry<String,Integer> entry:entries){
8
            System.out.println(entry.getKey()+":"+entry.getValue());
9
        }

• 这里补充一下entry对象的两个常用方法

• 3,lambda表达式(forEach使用)

格式： map.forEach((key,value)->{…});

1
Map<String,Integer> map3 = new HashMap<>();
2
        map3.put("a",1);
3
        map3.put("b",2);
4
        map3.put("c",3);
5

6
        // map3.forEach(new BiConsumer<String, Integer>() {
7
        //     @Override
8
        //     public void accept(String s, Integer integer) {
9
        //         System.out.println(s+":"+integer);
10
        //     }
11
        // });
12

13
        map3.forEach((key,value)->{
14
            System.out.println(key+":"+value);
15
        });

• 4,补充说明,这里的几种遍历方式均适用于Map的实现类，例如HashMap，LinkedHashMap，Hashtable，HashrTree等。

HashMap介绍#

HashMap是一个基于哈希表的双列集合。

无额外方法，用Map的继承

特点由键决定：无序，不重复，无索引。

HashMap底层#

• 本质也是哈希表的基础结构（在数组里存链表，初始16长度，0.75加载因子）
• 元素是Entry对象。
• 用键来计算哈希值，根据哈希值来确定元素在数组里的位置。
• 同样用hashCode()和equals（）方法来保证键的唯一性。因此如果键是自定义的类，那么必须重写这两个方法。
• 另外，虽然HashMap里面存在红黑树，但是与一般的依靠大小来排序的红黑树不同，HashMap的红黑树是根据键来排序的，因此它不用实现comparable。

LinkedHashMap介绍#

LinkedHashMap是一个基于哈希表的双列集合。

无新方法

特点由键决定：有序，不重复，无索引。

LinkedHashMap底层#

• 底层也是哈希表，与HashMap基本一致，只是多了双链表的属性机制，能记录存储的顺序，因此是有序的

HashrTree介绍#

HashrTree是一个基于哈希表的双列集合。

无新方法

特点由键决定：不重复，无索引，可排序。

HashrTree底层#

• 底层是红黑树，能对数据的按一定的规则排序，但一般默认是从小到大的升序排序

HashrTree的排序规则#

首先，与treeset类似，一般会用默认的升序排序，此外，它由两种能定义排序规则的方式

• 1，实现comparable接口，然后在类内重写compareTo（）方法。

1
public class Student implements Comparable<Student> {//引用接口，泛型使用这个类
2
    String name;
3
    int age;
4

5
    @Override
6
    public int compareTo(Student o) {
7
        //这里要注意，compareTo()方法的返回值是int类型，如果返回0，就表示两个对象相等，如果返回正数，就表示当前对象大于o，如果返回负数，就表示当前对象小于o。
8
        //this表示要添加的元素，o表示存在在集合的元素
9
        return this.name.compareTo(o.name);
10
    }
11
}

• 2，创建集合的时候，传入一个Comparator对象（用匿名类），来定义排序规则。（这个方法一般不用，因为实现comparable接口更方便，但是这个方法的优先级更高，能用于重写那些系统给了默认排序的类的排序方式）

1
Set<Student> set = new HashSet<>(new Comparator<Student>() {//传入一个Comparator对象，来定义排序规则
2
    @Override
3
    public int compare(Student o1, Student o2) {//重写compare()方法，来定义排序规则，o1表示要添加的元素，o2表示存在在集合的元素
4
        return o1.name.compareTo(o2.name);
5
    }
6
});

可以看出来，这是函数式接口，所以可以用lambda表达式来实现。

1
Set<Student> set = new HashSet<>((o1, o2) -> o1.name.compareTo(o2.name));

1,HashMap（无序，不重复，无索引。）#

一般默认都会用这个实现类，因为它相对之下效率是最高的

2,LinkedHashMap（有序，不重复，无索引）#

在使用的场景中，需要根据元素的顺序来访问元素，例如在缓存中，需要根据元素的顺序来访问元素，那么就可以用LinkedHashMap。

3,HashrTree可排序，不重复，无索引。#

在使用的时候，如果有要对数据排序的需求，不论是默认的还是自定义的，都可以用HashrTree。

1，实现类给出具体类型#

在类内引用泛型接口的时候，在接口后面直接确定

例如

1
public class MyArrayList2 implements List<String> {.......}

2，实现类不给出具体类型#

实现类延续泛型，在创建对象的时候再确定

在实现类依然原样的继承接口，创建对象时在确定就行

例如

1
public class MyArrayList2 implements List<E> {
2
@Override
3
public boolean add(E e){....}
4
....
5
}
6
//创建对象
7
 MyArrayList2<String> A=new  MyArrayList2<>()
8
//此时，这个数据类型就会被确定为String