java集合--（一）

参考：https://blog.csdn.net/feiyanaffection/article/details/81394745

常用集合的分类：

Collection 接口的接口 对象的集合（单列集合）
├——-List 接口：元素按进入先后有序保存，可重复
│—————-├ LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全
│—————-├ ArrayList 接口实现类， 数组， 随机访问， 没有同步， 线程不安全
│—————-└ Vector 接口实现类 数组， 同步， 线程安全
│ ———————-└ Stack 是Vector类的实现类
└——-Set 接口： 仅接收一次，不可重复，并做内部排序
├—————-└HashSet 使用hash表（数组）存储元素
│————————└ LinkedHashSet 链表维护元素的插入次序
└ —————-TreeSet 底层实现为二叉树，元素排好序

Map 接口 键值对的集合 （双列集合）
├———Hashtable 接口实现类， 同步， 线程安全
├———HashMap 接口实现类 ，没有同步， 线程不安全-
│—————–├ LinkedHashMap 双向链表和哈希表实现
│—————–└ WeakHashMap
├ ——–TreeMap 红黑树对所有的key进行排序
└———IdentifyHashMap

1.集合和数组的区别：

2.Collection集合的方法：

参考：https://blog.csdn.net/zhangqunshuai/article/details/80660974

概述:

List , Set, Map都是接口，前两个继承至Collection接口，Map为独立接口
Set下有HashSet，LinkedHashSet，TreeSet
List下有ArrayList，Vector，LinkedList
Map下有Hashtable，LinkedHashMap，HashMap，TreeMap
Collection接口下还有个Queue接口，有PriorityQueue类

注意:

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

Connection接口:

— List 有序,可重复

ArrayList
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程不安全，效率高
Vector
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程安全，效率低
LinkedList
优点: 底层数据结构是链表，查询慢，增删快。
缺点: 线程不安全，效率高

—Set 无序,唯一

HashSet

底层数据结构是哈希表。(无序,唯一)
如何来保证元素唯一性?
1.依赖两个方法：hashCode()和equals()

LinkedHashSet
底层数据结构是链表和哈希表。(FIFO插入有序,唯一)
1.由链表保证元素有序
2.由哈希表保证元素唯一

TreeSet
底层数据结构是红黑树。(唯一，有序)

1. 如何保证元素排序的呢?
   自然排序
   比较器排序
   2.如何保证元素唯一性的呢?
   根据比较的返回值是否是0来决定

针对Collection集合我们到底使用谁呢?(掌握)

-----------------------唯一吗?

----------------------是：Set

排序吗?

是：TreeSet或LinkedHashSet
否：HashSet
如果你知道是Set，但是不知道是哪个Set，就用HashSet。

---

---------------------否：List

要安全吗?

是：Vector
否：ArrayList或者LinkedList

查询多：ArrayList
增删多：LinkedList
如果你知道是List，但是不知道是哪个List，就用ArrayList。

Map接口:

Map接口有三个比较重要的实现类，分别是HashMap、TreeMap和HashTable。

TreeMap是有序的，HashMap和HashTable是无序的。
Hashtable的方法是同步的，HashMap的方法不是同步的。这是两者最主要的区别。
这就意味着:

Hashtable是线程安全的，HashMap不是线程安全的。

• HashMap效率较高，Hashtable效率较低。
• 如果对同步性或与遗留代码的兼容性没有任何要求，建议使用HashMap。
  查看Hashtable的源代码就可以发现，除构造函数外，Hashtable的所有 public 方法声明中都有
  synchronized关键字，而HashMap的源码中则没有。
• Hashtable不允许null值，HashMap允许null值（key和value都允许）
• 父类不同：Hashtable的父类是Dictionary，HashMap的父类是AbstractMap

List排序–ArrayList的排序

排序一：

package com.example.dtest.collection.list.test1;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class Person {

    private int id;
    private String name;
    private String address;

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

package com.example.dtest.collection.list.test1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class ListTest01 {

    public static void main(String[] args) {

        List<Person> list = new ArrayList<>();
//        产生10以内的随机数
        int num = (int)(Math.random()*100+1);

        for(int i = num; i > 0; i--){
            list.add(new Person(i,"张三","成都"));
        }
        for(Object o : list){
            System.out.println(o);
        }
        System.out.println("--------------------------------------------------");
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {

                if(o1.getId() > o2.getId()){
                    return 1;
                }else if(o1.getId() < o2.getId()){
                    return -1;
                }
                return 0;
            }
        });

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

    }

}

排序二：

package com.example.dtest.collection.list.test2;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class Person02 implements Comparable{

    private int id;
    private String name;
    private String address;

    @Override
    public String toString() {
        return "Person02{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }


    @Override
    public int compareTo(Object o) {
        if(o instanceof Person02){
            Person02 o1 = (Person02) o;
            return new Double(this.getId()).compareTo(new Double(o1.getId()));
        }
        throw new ClassCastException("不能转化为Person类型的对象...");
    }
}

package com.example.dtest.collection.list.test2;

import java.util.ArrayList;
import java.util.List;

public class ListTest02 {

    public static void main(String[] args) {
        List<Person02> list = new ArrayList<>();

//        产生10以内的随机数
        int num = (int) (Math.random()*100+1);
        for(int i = num; i > 0; i--){
            list.add(new Person02(i,"张三","成都"));
        }
        for(Object o : list){
            System.out.println(o);
        }
        System.out.println("---------------------------------------------");
        for(Object o : list){
            System.out.println(o);
        }


    }

}