学习日志day12（2021-07-20）（1、集合框架 2、ArrayList类 3、HashSet类和TreeSet类 4、HashMap类 5、泛型集合）

本文链接：https://blog.csdn.net/huzige_/article/details/119000114

学习内容：学习JavaSE（Day12）

1、集合框架
2、ArrayList类
3、HashSet类和TreeSet类
4、HashMap类
5、泛型集合

1、集合框架

（1）集合框架包含接口、实现类和算法。
接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象。List和Set是Collection的子接口。
实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

2、ArrayList类和LinkedList

ArrayList类：List是Collection的子接口，ArrayList是List的实现类，继承自 AbstractList类。
ArrayList 是有序的集合，有索引，允许重复元素，允许null值，可以自动扩容。但它不是线程安全的，迭代集合时不允许add remove。
Vector类的使用方法大致与ArrayList相同，但它是同步的（线程安全的）。存储的数据是单列的。
LinkedList类：LinkList是一个双链表,在添加和删除元素时具有比ArrayList更好的性能，但在get与set方面弱于ArrayList。
只要ArrayList的当前容足够大，add()操作向数组的尾部的效率非常高的，当向数组指定位置添加数据时，会进行大量的数组移动复制操作。而数组复制时，最终将调用System.arraycopy()方法，因此add()操作的效率还是相当高的。尽管这样当向指定位置添加数据时也还是比Linkedlist慢，后者添加数据只需要改变指针指向即可。Arraylist删除数组也需要移动数组，效率较慢。
Linkedlist基于链表的动态数组，数据添加删除效率高，只需要改变指针指向即可，但是访问数据的平均效率低，需要对链表进行遍历。

方法摘要：
（1）add(E e)：将指定的元素添加到此列表的尾部，返回值boolean。

ArrayList list1 = new ArrayList();
        list1.add(1);//添加集合元素时可以放入数字，此时数字是包装类
        list1.add(23.4);
        list1.add(true);
        list1.add(null);
        list1.add(new User());
        System.out.println(list1.size());//获取元素个数   5

add(int index, E element)：将指定的元素插入此列表中的指定位置，返回void。

list.add(1, 32.4);  //在第二个位置插入32.4

（2）addAll：按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部或指定位置。插入指定位置时索引值不能越界，否则会出现越界异常。

list1.addAll(3,list);

（3）clear：移除此列表中的所有元素。

（4）contains(Object o)：如果此列表中包含指定的元素，则返回 true，返回值boolean。

（5）get(int index)：返回此列表中指定位置上的元素。

（6）indexOf(Object o)：返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
lastIndexOf(Object o) ：返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。

（7）isEmpty() ：如果此列表中没有元素，则返回 true，返回值boolean。

（8）remove(int index)：移除此列表中指定位置上的元素，返回移除的元素。
remove(Object o) ：移除此列表中首次出现的指定元素（如果存在），返回值boolean。
注意：remove移除数字时，为了不让系统认为这是索引值，将数字转换为包装类。

list.remove(100)；//移除索引值为100的元素
list.remove((Integer) 100)；//移除元素“100”

removeRange(int fromIndex, int toIndex)：移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素，返回protect void。
这个方法不能直接调用，为了避免冗余，所以是protect的，如果需要调用可以创建一个类继承ArrayList类来调用。

List.removeRange(1, 3);

removeRange() 方法不常用，我们通常可以使用 ArrayList subList() 和 ArrayList clear() 方法来实现删除元素。subList()是父类AbstractList的方法，返回一个新的集合，它是此集合的一个子集合。

List.subList(1, 3).clear();

（9）set(int index, E element)：用指定的元素替代此列表中指定位置上的元素，返回被替换的元素。

（10）toArray()：按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。

转换成数组进行迭代：

Object[] objects = list.toArray();
for(int i = 0;i < objects.length;i++){
     System.out.println(objects[i]);
 }

迭代集合：

for(Object obj : list){
            System.out.println(obj);
}

for(int i = 0;i <list.size();i++){
            System.out.println(list.get(i));
}

Iterator iterator = list.iterator();//迭代器
        while(iterator.hasNext()){
            System.out.println(iterator.next());
}

list.forEach(e ->{
            if(e instanceof User){
                User user = (User)e;
                System.out.println(user.getUserName() + user.getAge());
            }else{
                System.out.println(e);
            }
});

3、HashSet类和TreeSet类

（1）HashSet类：Set是Collection的子接口，HashSet是Set的实现类，继承自 AbstractSet类。
HashSet是无序的集合，不允许重复值，允许null值，可以自动扩容，没有索引，不是线程安全的（此实现不是同步的），迭代集合时不允许add remove。存储的数据是单列的。
其他一些方法与ArrayList的方法一样。

（2）TreeSet类：Set是Collection的子接口，TreeSet是Set的实现类，继承自 AbstractSet类。
使用元素的自然顺序对元素进行排序（此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。），或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。
不允许重复值，允许null值，可以自动扩容，没有索引，不是线程安全的（此实现不是同步的），迭代集合时不允许add remove。存储的数据是二叉树类型的。

（3）TreeSet集合的一些方法：
ceiling(E e)：返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。

first()：返回此 set 中当前第一个（最低）元素。

floor(E e)：返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。

headSet(E toElement)：返回此 set 的部分视图，其元素严格小于 toElement。

headSet(E toElement, boolean inclusive)：返回此 set 的部分视图，其元素小于（或等于，如果 inclusive 为 true）toElement。

higher(E e)：返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。

last() ：返回此 set 中当前最后一个（最高）元素。

lower(E e)：返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。

pollFirst()：获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。

pollLast() ：获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。

tailSet(E fromElement)：返回此 set 的部分视图，其元素大于等于 fromElement。

tailSet(E fromElement, boolean inclusive)：返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement。

（4）HashSet集合中存入对象时，需要重写equals方法和hashCode方法，不然无法对自定义类进行去重。

在使用Set对象储存自定义对象的时候，每次都会调用自定义对象的hashCode ()方法，如果与已存入的对象相同时不会直接覆盖掉，而是再去调用equals()方法。如果equals()方法返回值相同，则会判断为是同一个对象，将其覆盖；如果equals()方法返回值不同，则判断是两个不同对象，在这个哈希地址产生一个偏移量，存入这个对象。
因此在hashSet集合中：hashCode()方法返回值相同时，equals()方法比较并不一定相等，但是equals()方法比较相等，hashCode()方法返回值是相同的。

重写equals方法和hashCode方法后，当在set集合中存入两个相同的对象时，会存储失败。因为这时判断两个对象哈希值不同，但equals相同。

@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age && Objects.equals(userName, user.userName);
    }
    @Override
    public int hashCode() {
        return Objects.hash(userName,age);
    }

User user = new User("Rose",12);
User user2 = new User("Rose",12);
System.out.println(user.equals(user2));//true
Set userSet = new HashSet();
userSet.add(user);
userSet.add(user2);
System.out.println(userSet.size());// 1

如果不重写hashCode方法，那么结果是false 2，无法去重。

4、HashMap类

（1）HashMap类：HashMap是Map的实现类，继承自 AbstractMap类。
HashMap是无序的集合，提供所有可选的映射操作，采用键值对的形式存储，允许null值和null键，可以自动扩容，没有索引，不是线程安全的（此实现不是同步的），迭代集合时不允许add remove。key 值不能重复，否则会覆盖掉，因为key存放在一个set集合中，value可以重复。存储的数据是双列的。

HashTable的操作几乎和HashMap一致，主要的区别在于HashTable为了实现多线程安全，在几乎所有的方法上都加上了synchronized锁，而加锁的结果就是HashTable操作的效率十分低下。Hashtable不允许键或值为null，继承自Dictionary类。不建议使用，已废弃。

（2）方法摘要：
put(K key, V value)：在此映射中关联指定值与指定键，返回被替换的value。

Map map = new HashMap();
System.out.println(map.put(1,"Alex"));// null
System.out.println(map.put(1,"Jerry"));// Jerry

get(Object key) ：返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。

putAll(Map<? extends K,? extends V> m) ：指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系。

remove(Object key) ：从此映射中移除指定键的映射关系（如果存在）。

entrySet() ：返回此映射所包含的映射关系的 Set 视图，Set集合中存放都是Entry对象。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

containsKey(Object key) ：如果此映射包含对于指定键的映射关系，则返回 true。

containsValue(Object value) ：如果此映射将一个或多个键映射到指定值，则返回 true。

（3）集合迭代：

for(Object obj : entrySet){
    Map.Entry en = (Map.Entry)obj;
    System.out.println(en.getKey() + "\t" + en.getValue());
}

Iterator iterator = entrySet.iterator();
while(iterator.hasNext()){
    Object obj = iterator.next();
    Map.Entry en = (Map.Entry)obj;
    System.out.println(en.getKey() + "\t" + en.getValue());
}

entrySet.forEach(e ->{
    Map.Entry en = (Map.Entry) e;
    System.out.println(en.getKey() + "\t" + en.getValue());
});

（4）hashTable类是Map的实现类，它不允许键或值为null值，是同步的（线程安全的），其它与hashMap使用方法相同。

5、泛型集合

（1）为了方便使用集合时取出数据，避免强制转换的麻烦，可以使用泛型集合。
定义泛型集合：

Map<String,User> userMap = new HashMap();
userMap.put("1",new User("Lucy",12));
Set<Map.Entry<String,User>> entry = userMap.entrySet();

迭代泛型集合

entry.forEach(e->{
    //  User user = (User) e.getValue();  不需要进行强制转换
    User user = e.getValue();
    System.out.println(e.getKey() + user.getAge() + user.getUserName());
});

Iterator<Map.Entry<String, User>> iterator = entry.iterator();
while(iterator.hasNext()){
    Map.Entry<String, User> en = iterator.next();
    System.out.println(en.getKey() + en.getValue());
}

for(Map.Entry<String,User> en : entry){
    User user = en.getValue();
    System.out.println(en.getKey() + user.getAge() + user.getUserName());
}

Set<String> keySet = userMap.keySet();
for(String key : keySet){
    User user = (User)userMap.get(key);
    System.out.println(key + user.getUserName() + user.getAge());
}