目录
List
List是一个接口，它继承于Collection接口，代表有序的队列。
ArrayList
ArrayList是List的实现类，是一个数组队列，相当于动态数组，随机访问效率高，随机增删效率低。
LinkedList
LinkedList是List的实现类，是一个双向链表，随机访问效率低，随机增删效率高。
public class Test02 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
System.out.println("for循环遍历：");
//for循环遍历
for(int i = 0; i < list.size(); i++){
System.out.print(list.get(i)+"\t");
}
//迭代器遍历
System.out.println("\n迭代器遍历：");
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next()+"\t");
}
//foreach遍历
System.out.println("\nforeach遍历：");
for(String s : list){
System.out.print(s+"\t");
}
//lambda遍历(jdk1.8及以上)
System.out.println("\nLambda表达式：");
list.forEach((s)->System.out.print(s+"\t"));
//双冒号操作符
System.out.println("\n双冒号操作符：");
list.forEach(System.out::println);
}
}
小结：（1）ArrayList：底层结构是数组，查询快，增删慢，线程不安全，效率高。
（2）LinkedList：底层结构是链表，查询慢，增删块，线程不安全，效率高。
Set
Set是一个不包含重复元素的Collection，特点是无序且唯一。
HashSet
HashSet使用了哈希表，元素是无序的。它的add、remove、contains方法的时间复杂度为O(1)。
LinkedHashSet
LinkedHashSet是基于链表实现的哈希表，保留了元素的插入顺序。
TreeSet
TreeSet使用了树形结构，其中的元素是可排序的。可以自然排序或者通过自定义比较器（comparator）进行排序
public class SetTest {
public static void main(String[] args) {
//hashSet不保证set的迭代顺序，且支持null元素
Set<String> set1 = new HashSet<>();
set1.add("1");
set1.add("5");
set1.add("5");
set1.add("1");
set1.add("2");
set1.add("3");
set1.add("4");
System.out.println(set1);
//LinkedHashSet中保持了元素的插入顺序
Set<String> set2 = new LinkedHashSet<>();
set2.add("1");
set2.add("5");
set2.add("5");
set2.add("1");
set2.add("2");
set2.add("3");
set2.add("4");
set2.add(null);
System.out.println(set2);
//TreeSet可以使元素进行自然排序，或者通过比较器进行排序（对象的排序）
Set<String> set3 = new TreeSet<>(set1);
System.out.println(set3);
//实现Comparable接口正序排序
Set<Person> set4 = new TreeSet<>();
set4.add(new Person("Daniel",22));
set4.add(new Person("Eddie",21));
set4.add(new Person("Jesska",20));
System.out.println(set4);
//匿名内部类方式逆序排序
Set<Person> set5 = new TreeSet<>(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o2.getAge() - o1.getAge();
}
});
set5.addAll(set4);
System.out.println(set5);
}
}
class Person implements Comparable<Person>{
String name;
int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public int compareTo(Person arg0) {
return this.age - arg0.getAge();
}
}
小结：（1）HashSet：不保证元素的顺序，不可重复，线程不安全，集合元素可以为null。
（2）LinkedHashSet：底层采用链表和哈希表算法，保证元素的添加顺序。
（3）TreeSet：底层采用红黑树算法，不可重复，可以对元素进行自然排序或者自定义比较器排序。
Map
Map存储的数据都是以键值对的形式存在的，键不可重复，值可以重复。
HashMap
HashMap根据键的hashCode值进行存储数据，通过key可以很快的访问到数据，但是顺序不确定。HashMap是线程不安全的，如果有线程安全要求，可以使用ConcurrentHashMap。
public class MapTest {
public static void main(String[] args) {
Map<String,String> map = new HashMap<String,String>();
map.put("男1", "Daniel");
map.put("男2", "Peter");
map.put("女1", "Herry");
System.out.println("使用迭代器：");
//keySet遍历map
Iterator<String> iterator = map.keySet().iterator();
System.out.println("keyset遍历");
while(iterator.hasNext()){
String key = iterator.next();
System.out.println(key+"---"+map.get(key));
}
//Entry遍历
Iterator<Entry<String,String>> iterator2 = map.entrySet().iterator();
System.out.println("entryset遍历");
while(iterator2.hasNext()){
Entry<String, String> entry = iterator2.next();
System.out.println(entry.getKey()+"---"+entry.getValue());
}
System.out.println("不使用迭代器：");
System.out.println("keySet遍历：");
//keySet遍历
Set<String> set = map.keySet();
for(String i : set){
String p = map.get(i);
System.out.println(i+"---"+p);
}
//entrySet遍历
System.out.println("entrySet遍历：");
Set<Entry<String, String>> set2 = map.entrySet();
for(Entry<String, String> e : set2){
System.out.println(e.getKey()+"---"+e.getValue());
}
}
}
LinkedHashMap
LinkedHashMap是HashMap的一个子类，可以保证插入元素顺序，在用Iterator遍历时，先得到的记录肯定是先插入的。
public class MapTest {
public static void main(String[] args) {
Map<String,String> map = new LinkedHashMap<String,String>();
map.put("男1", "Daniel");
map.put("男2", "Peter");
map.put("女1", "Herry");
System.out.println("keySet遍历：");
//keySet遍历
Set<String> set = map.keySet();
for(String i : set){
String p = map.get(i);
System.out.println(i+"---"+p);
}
//entrySet遍历
System.out.println("entrySet遍历：");
Set<Entry<String, String>> set2 = map.entrySet();
for(Entry<String, String> e : set2){
System.out.println(e.getKey()+"---"+e.getValue());
}
}
}
TreeMap
TreeMap实现SortedMap接口，能够把它保存的记录根据键排序，默认是按键值的自然排序，也可以指定排序的比较器，要求key值实现Comparable接口或者在构造TreeMap传入自定义的Comparator（使用匿名内部类）。
public class MapTest2 {
public static void main(String[] args) {
Map<Person,String> map2 = new TreeMap<>(new Comparator<Person>(){
@Override
public int compare(Person o1, Person o2) {
return o2.getAge() - o1.getAge();
}
});
map2.put(new Person("Daniel",25),"1");
map2.put(new Person("Jessica",22),"2");
map2.put(new Person("Eddie",23),"3");
System.out.println(map2);
Map<Person,String> map4 = new TreeMap<>();
map4.putAll(map2);
System.out.println(map4);
}
}
class Person implements Comparable<Person>{
String name;
int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public int compareTo(Person arg0) {
return this.age - arg0.getAge();
}
}