android List,Set,Map区别和介绍

List

元素存放有序，元素可重复

1.LinkedList

链表，插入删除，非线性安全，插入和删除操作是双向链表操作，增加删除快，查找慢

add(E e)//添加元素
addFirst(E e)//向集合头部添加元素
addList(E e)//向集合尾部添加元素
getLast() //获取集合最后一个元素
removeFirst()//移除集合中第一个元素
pop()//移除集合中第一个元素
removeLast()//移除集合中最后一个元素
clear() //清除列表
isEmpty()//判断集合是否为空

2.ArrayList

数组，随机访问，非线性安全，效率高，增加删除慢，查找快
添加

add(E e)
add(int index,E e)//指定位置添加

set(int index,E e)//替换某个有毒，返回被替换的因素

List<String> list = new ArrayList<>();//多态写法
list.add("1");
list.add("2");
list.add("3");
System.out.println(list);
//替换某个元素，并返回被替换的元素
String a = list.set(1, "A");
System.out.println("被替换的元素为：" + a);
System.out.println(list);
 
打印结果：
[1, 2, 3]
被替换的元素为：2
[1, A, 3]
//迭代遍历
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

删除

remove(int index)//移除指定索引元素
remove(Object o)
//建议采用遍历器进行删除
Iterator<String> iter = aList.iterator();  
        while(iter.hasNext()){  
            if(iter.next().equals("abc")){  
                iter.remove();   
            }  

  val list: MutableList<SpinnerBean> = java.util.ArrayList()
        for (i in 1..10)
        list.add(SpinnerBean(id=i, spinnerItem = "sd$i"))
        val iter: MutableIterator<SpinnerBean> = list.iterator()
        while (iter.hasNext()) {
            val title: Int = iter.next().id
            if (title % 3==0) {
                println("aaa--------notes remove-$title")
                iter.remove()
            }
        }
        println(list)
//输出
// [SpinnerBean(id=1, spinnerItem=sd1), SpinnerBean(id=2, spinnerItem=sd2), SpinnerBean(id=4, spinnerItem=sd4), SpinnerBean(id=5, spinnerItem=sd5), SpinnerBean(id=7, spinnerItem=sd7), SpinnerBean(id=8, spinnerItem=sd8), SpinnerBean(id=10, spinnerItem=sd10)]

3.Vector

数组，线程安全，效率低，支持添加，移除，替换，允许null的因素存在。

Set

元素存放无序（存放元素和取出的顺序可能不一样），元素不重复，但是对象需要重写hasCode和equals进行去重，没有索引所以不能使用普通for循环遍历

1.HashSet

不安特定方式排列，没有重复元素会对添加的元素进行去重，采用哈希算法来存取集合元素，存取速度比较快。

add(E e)//添加元素，自动去重

Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
set.add(2);
//使用功能迭代器遍历，不能使用普通for遍历
Iterator<Integer> iterator = set.iterator();
while (iterator.hasNext()){
   System.out.println(iterator.next());
}
打印结果：
1
2

如果是HashSet存储自定义类型的元素，比如bean对象，需要重写hasCode和equals进行去重

public class Person {
   private String name;
   private int age;
   public Person() {
   }
   public Person(String name, int age) {
       this.name = name;
       this.age = age;
   }

   @Override
   public String toString() {
       return "Person{" +
               "name='" + name + '\'' +
               ", age=" + age +
               '}';
   }
   @Override
   public boolean equals(Object o) {
       if (this == o) return true;
       if (o == null || getClass() != o.getClass()) return false;
       Person person = (Person) o;
       return age == person.age &&
               Objects.equals(name, person.name);
   }
   @Override
   public int hashCode() {
       return Objects.hash(name, age);
   }
   public String getName() {
       return name;
   }
   public void setName(String name) {
       this.name = name;
   }
   public int getAge() {
       return age;
   }
   public void setAge(int age) {
       this.age = age;
   }
}

//创建HashSet集合存储Person
       HashSet<Person> people = new HashSet<>();
       Person person1 = new Person("aa", 15);
       Person person2 = new Person("ww",16);
       Person person3 = new Person("ww",16);
       people.add(person1);
       people.add(person2);
       people.add(person3);
       System.out.println(people);
       输出：[Person{name='aa', age=15}, Person{name='ww', age=16}]

2.LinkedHashSet

具有HashSet的查询速度，底层是一个哈希表，数组+链表/红黑树+链表，多了一条链表记录元素存储顺序，
存储数据的方式和HashSet一样，包括去重的方式，唯一的不一样点就是LinkedHashSet内部是有序的

Map

元素按键值对存储，无序 ；
key和value一一对应关系；
key和value的数据类型可以相同也可以不同；
key不允许重复，value可以重复；

1.HashMap

非线程安全，无序，支持存储键值均为null，没有contains方法，改成containsValue和containsKey，内存初始大小16

2.LinkedHashMap

有序，支持存储键值均为null

HashTable

线程安全，存储键值不能为null,有contains方法，内存初始大小11