Java基础复习：集合

 

目前只有知识点，不会深入了解源码之类的

集合之间的关系图

集合介绍

Set

TreeSet：继承SortedSet，底层数据结构是红黑树（保证唯一、有序性），不允许null

保证排序的两种方式：

自然排序（元素具备比较性）：实现Comparable接口

比较器排序（集合具备比较性）：实现Comparator接口

保证元素的唯一性：

根据比较的返回值是否为0来决定

HashSet:继承Set，底层数据结构是哈希表（无序，唯一性）,允许null

保证元素的唯一性：

通过hashCode()方法和equals()方法：首先通过hashCode判断哈希值是否相同，如果相同，再执行equals方法判断对象地址是否相同，如果true则已存在对象，如果false则不存在

性能：hashCode方法优于equals，所以在插入时，一般先用hashCode判断是否重复，再用equals方法判断，hashCode确定元素插入位置

LinkedHashSet：继承Ser，底层结构是链表和哈希表(插入有序，唯一性)

 由链表保证元素的有序

 由哈希保证元素的唯一性

List

ArrayList:底层结构是数组，有下标，有序，可存放相同数据

优点：底层数据是数组，查询快，增删慢，效率高

缺点：线程不安全

ArrayList与数组的相互装换

数组——>集合

Arrays.asList() 

坑：数组转集合后

无法再修改，因为新的ArrayList是Arrays.ArrayList，而不是util.ArrayList

集合——>数组

to.Array

相关方法：

add()添加

get(index)获取

remove(index)删除 

三种遍历方式

for循环：

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

增强for: 

  for(Object i:ints)
        {
            System.out.println(i);
        }

迭代器：

        Iterator iterator = ints.iterator();
        while (iterator.hasNext()){
            Object o = iterator.next();
            System.out.println(o);
        }

三种排序方式：

直接排序：

    List<String> names=new ArrayList<String>();
    List<Integer> ages=new ArrayList<Integer>();
      Collections.sort(names);
      Collections.sort(ages);

实现Comparable接口：

 //User类
public class User implements Comparable<User>  {
    @Override
    public int compareTo(User user) {
        //return this.getName().compareTo(user.getName()); //升序
        return user.getName().compareTo(this.getName());  //降序
    }

    //main方法
   Collections.sort(users);

比较器的匿名内部类：

// 在main方法中：
  Collections.sort(users, new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                if (o1.getName().length() > o2.getName().length())
                {
                    return 1;//名字长度升序
                }
                 else if(o1.getName().length() ==o2.getName().length())
                {        
                    if(o1.getAge()>o2.getAge())
                    {
                        return 1;//年龄升序
                    }
                    else
                    { 
                        return -1;
                    }
                }
                 else 
                {
                    return -1;
                }
            }
        });

Vector:底层结构是数组，查询快，增删慢，效率低，但线程安全

LinkedList:底层结构是链表，查询慢，增删快，效率高，但线程不安全

Map

HashMap:底层结构是哈希表（包括数组、链表、红黑树这三种数据结构）,没有迭代器

采用数组+链表的存储方式，即数组中的每一个元素都是链表

key值：不可重复，支持null

相关方法：

• put()：添加
• putAll():添加一个map集合
• remove():删除
• get():获取
• isEmpy():判断是否为空
• clear():清空
• size():长度
• containsKey():是否包含Key
• containsValue():是否包含value
• replace():替换
• keySet():map集合中的key值的集合，返回Set集合
• values():map集合中的value值的集合，返回Collection集合
• entrySet():将所有的key-value包装成Entry节点，存储在Set几何中返回，此集合的类型为Map.Entry。Map.Entry是Map声明的一个内部接口，此接口为泛型，定义为Entry<K,V>,表示map中的一个实体（一个key-value对），接口中有getKey(),getValue()方法

map集合遍历的三种方式

1、迭代器：

 Set<Object> key = hashMap.keySet();
Iterator<Object>iterator=key.iterator();
while (iterator.hasNext())
{
Object next=iterator.next();
//（该语句必须有，不然sout只能next.一次，如果next.了多次，会报：NoSuchElementException）  
System.out.println(next+"-->"+hashMap.get(next));
}

 2、foreach:

Set<Object> key = hashMap.keySet();
for(Object o : key){
System.out.println(o+"——>"+hashMa.get(0));
}

3、专属:

Set<Map.Entry<Object,String>>entrySet=hashMap.entrySet();
        //获取迭代器
        Iterator<Map.Entry<Object,String>>iterator=entrySet.iterator();
        while (iterator.hasNext())
        {
        Map.Entry<Object,String>next=iterator.next();
//（该语句必须有，不然sout只能next.一次，如果next.了多次，会报：NoSuchElementException）
        System.out.println(next.getKey()+"-->"+next.getValue());
        }