List、Set和Map的区别
| List | Set | Map | |
|---|---|---|---|
| 元素顺序 | 有序 | 无序 | key无序、value无序 |
| 元素是否可重复 | 可重复 | 不可重复 | key不可重复、value可重复 |
List
注意：List中存储的元素有序，指的是读出的顺序与存入的顺序是一致的，这叫做有序。比如说List添加了元素1,3,2，那么循环遍历List读出的元素顺序也是1,3,2，而不是1,2,3，这才叫List的存储元素有序。
public class Demo {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
// 读入的顺序是：1，3，2
list.add(1);
list.add(3);
list.add(2);
// 取出的顺序也是：1，3，2
System.out.println(list);
}
}
/**
* 打印结果：
* [1, 3, 2]
*/而元素可重复，指添加到List集合中的元素可以是重复的元素，重复的元素可以是值相等的基本数据类型数据，也可以是重写equals和hashCode方法的对象。
class Person {
private String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return name != null ? name.equals(person.name) : person.name == null;
}
@Override
public int hashCode() {
return name != null ? name.hashCode() : 0;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
public class Demo {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
// 添加重复元素
list.add(1);
list.add(1);
list.add(2);
System.out.println(list);
// 添加重复对象
List<Person> personList = new ArrayList<>();
Person p1 = new Person("张三");
Person p2 = new Person("张三");
personList.add(p1);
personList.add(p2);
System.out.println(personList);
}
}
/**
* 打印结果：
* [1, 1, 2]
* [Person{name='张三'}, Person{name='张三'}]
*/Set
注意：Set存储的元素是无序的，这里的无序指的是存入的顺序与输出的顺序可能是不一致的。例如存入的元素顺序是1,3,2，那么输出的元素顺序可能是1,2,3或者其他，这取决于hashCode值。因为元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的，所以输出顺序是按照hashCode值来的。
public class Demo {
public static void main(String[] args) {
Set<Integer> set = new HashSet<>();
// 输入元素的顺序是：1,3,2
set.add(1);
set.add(3);
set.add(2);
// 输出元素的顺序是：1,2,3
System.out.println(set);
}
}
/**
* 打印结果：
* [1, 2, 3]
*/Set存储的元素是不允许重复的，无论是基本数据类型的元素还是对象。
class Person {
private String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return name != null ? name.equals(person.name) : person.name == null;
}
@Override
public int hashCode() {
return name != null ? name.hashCode() : 0;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
public class Demo {
public static void main(String[] args) {
// 存入基本数据类型的重复元素
Set<Integer> set = new HashSet<>();
set.add(1);
set.add(1);
set.add(2);
System.out.println(set);
// 存入重写了equals和hashCode方法的对象
Set<Person> personSet = new HashSet<>();
personSet.add(new Person("张三"));
personSet.add(new Person("张三"));
personSet.add(new Person("李四"));
System.out.println(personSet);
}
}
/**
* 打印结果：
* [1, 2]
* [Person{name='李四'}, Person{name='张三'}]
*/Map
Map存储的元素是键值对（key-value），键和值都是无序的，即存入顺序与输出顺序可能都不一样。
public class Demo {
public static void main(String[] args) {
// key可能是无序的，value也可能是无序的
/*
键key输入顺序是：3,2,1
值value输入顺序是：a,b,c
*/
Map<Integer,String> map=new HashMap<>();
map.put(3,"a");
map.put(2,"b");
map.put(1,"c");
System.out.println(map.keySet());// 打印键
System.out.println(map.values());// 打印值
}
}
/**
* 打印结果：
* [1, 2, 3]
* [c, b, a]
*/Map中要求键（key）不重复，但允许值（value）重复。
public class Demo {
public static void main(String[] args) {
// 如果键名重复，那么只会保存一个，即会去重
Map<Integer,Integer> map=new HashMap<>();
map.put(1,1);
map.put(1,2);
map.put(1,3);
System.out.println(map);
// 如果键值重复，那么是可以的
Map<Integer,Integer> map2=new HashMap<>();
map2.put(1,1);
map2.put(2,1);
map2.put(3,1);
System.out.println(map2);
}
}
/**
* 打印结果：
* {1=3}
* {1=1, 2=1, 3=1}
*/