Java（day15）List、set、Map

list：

Arraylist

底层结构是数组，内存空间是连续的，可以根据下标进行操作，且下标有序，可重复；

增删操作比较慢，查询操作较快

底层会自动创建数组存放对象，并且数组的初始容量为10，扩容以1.5倍扩容

ArrayList<Integer> list=new ArrayList<>();

主体代码：

package cn.tedu.collection;

import java.util.ArrayList;

//本类用于ArrayList的测试
public class TestArrayList {
    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<>();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(400);
        list.add(300);
        System.out.println(list);
       }
}

删除元素：

以下代码会报错，list有两个remove方法，需要进行手动装箱，将int转化为integer

System.out.println(list.remove(300));

正确删除代码 ：1.删除指定元素

2.用指定下标删除

System.out.println(list.remove(Integer.valueOf(300)));
System.out.println(list);
运行结果：
[100, 200, 400, 400, 300]

list.remove(3)
System.out.println(list);
运行结果：
[100, 200, 400, 300]

LinkedList

元素有下标，有序，可重复

底层的数据结构是列表，内存空间不连续

进行首尾节点的操作比较多

增删操作比较快，查找操作比较慢

主体元素：

package cn.tedu.collection;

import java.util.LinkedList;

public class TestLinkList {
    public static void main(String[] args) {
        LinkedList<String> list=new LinkedList<>();
        list.add("孙悟空");
        list.add("猪八戒");
        list.add("唐三藏");
        list.add("沙师弟");
        list.add("白龙马");
        System.out.println(list);
        
    }
}
运行结果：

 添加首尾元素

list.addFirst("蜘蛛精");
list.addLast("玉兔");
System.out.println(list);

System.out.println(list.offer("海绵"));
System.out.println(list.offerFirst("派大星"));
System.out.println(list.offerLast("蟹老板"));
System.out.println(list);

 获取首尾元素

System.out.println(list.getFirst());

System.out.println(list.element());

System.out.println(list.peek());

System.out.println(list.peekFirst());

删除首尾元素

list.removeFirst();
System.out.println(list);
list.removeLast();
System.out.println(list);

set：

set集合中的元素都是没有顺序的

set集合中的元素不能重复

set集合可以存null值，并且null最多有一个

package cn.tedu.collection;

import java.util.HashSet;
import java.util.Set;

//本类用于测试set
public class TestSet {
    public static void main(String[] args) {
        Set<String> set=new HashSet<>();
        set.add("紫霞仙子");
        set.add("至尊宝");
        set.add("蜘蛛精");
        set.add("紫霞仙子");
        System.out.println(set);
    }
}
运行结果：
[蜘蛛精, 至尊宝, 紫霞仙子]

判断是否为空

System.out.println(set.isEmpty());

 判断是否包含该元素

System.out.println(set.contains("唐僧"));

 转化为数组

System.out.println(Arrays.toString(set.toArray()));

set的去重

package cn.tedu.collection;

import java.util.Objects;

//测试set集合中存放自定义的引用类型
public class Student {
    String name;
    int id;

    public Student(String name, int id) {
        this.name = name;
        this.id = id;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return id == student.id &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }
}
package cn.tedu.collection;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

//测试set存放自定义的引用类型对象的去重问题
public class TestSet2 {
    public static void main(String[] args) {
        //创建set集合对象
        Set<Student> set=new HashSet();
        //创建student类的对象
        Student s1=new Student("张三",3);
        Student s2=new Student("李四",4);
        Student s3=new Student("王五",5);
        Student s4=new Student("王五",5);
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        //添加重写的equals（）与hashcode（）可以实现去重的效果
        System.out.println(set);
    }
}
运行结果：
[Student{name='张三', id=3}, Student{name='李四', id=4}, Student{name='王五', id=5}]

Map

特点：

map<k,v>中的k不允许重复，如果重复，后有的k会把前面的k的value覆盖

map<k,v>中的v可以重复

map中的映射关系是无序的

创建方式

Map<Integer,String> map=new HashMap<>();

元素的添加

map.put(9527,"白骨精");
map.put(9528,"黑熊精");
map.put(9529,"鲤鱼精");
map.put(9530,"黄毛怪");
System.out.println(map);
运行结果：
{9527=白骨精, 9528=黑熊精, 9529=鲤鱼精, 9530=黄毛怪}

清空集合

map.clear();
System.out.println(map);
运行结果：
{}

判断集合是否为空

System.out.println(map.isEmpty());

判断键值对的数量

System.out.println(map.size());
运行结果：
4

 判断集合是否包含指定的值

System.out.println(map.containsKey(9527));
System.out.println(map.containsValue("白骨精"));
运行结果：
true
true

删除指定的值

map.remove(9527);
System.out.println(map);
运行结果：
{9528=黑熊精, 9529=鲤鱼精, 9530=黄毛怪}

 将map中所有的value取出，存入collection集合

Collection<String> values = map.values();
System.out.println(values);
运行结果：
[黑熊精, 鲤鱼精, 黄毛怪]

map的迭代方式：

方式一：map本身没有迭代器，所以需要用keySet()将map中的所有key值存入set集合中set<key>，转化为set集合

Set<Integer> set = map.keySet();
Iterator<Integer> it = set.iterator();
while (it.hasNext()){
    Integer key = it.next();
    String value = map.get(key);
    System.out.println("{"+key+","+value+"}");
}
运行结果：
{9528,黑熊精}
{9529,鲤鱼精}
{9530,黄毛怪}

方式二：把map中的一对键值对key&value作为一个Entry<k,v>整体放入set

Set<Map.Entry<Integer, String>> set2 = map.entrySet();
Iterator<Map.Entry<Integer, String>> it2 = set2.iterator();
while(it2.hasNext()){
         Map.Entry<Integer, String> entry = it2.next();
         System.out.println(entry);

  }
运行结果：
9528=黑熊精
9529=鲤鱼精
9530=黄毛怪