Set和Map

Set接口和Map接口

回顾

1 集合概念，用来存储一组数据的容器。和数组类似，
    数组是长度固定的，集合长度可以变化。
    数组能存储基本类型和引用类型，集合只能存储引用类型。
2 Collection接口，父接口， add()  remove()  clear()  contains()  iterator()
3 Collection有两个子接口 List和Set
    Collection:特点：一部分是有序的，有一部分是无序的，还有一部分可以重复，有一部分不能重复
4 泛型：本质使用数据类型作为参数传递：好处：1提高代码的重用性 2 防止类型转换异常，保证数据的安全
    4.1 定义泛型类  泛型方法 泛型接口
        <>表示泛型
        T是一个占位符，表示一个数据类型，只能是引用类型
        public class  Generic<T>{ 
            T t;
            pubic void show(T t){
                
            }
            public T getT(){
              return t;
            }
        }
        
        public class Generic2{
            public <T> void show(T t){
              
            }
        }
        public interface Usb<T>{
          
        }
        
    4.2 使用 创建类对象，指定泛型的实际类型
    4.3 泛型限制，<?> 表示任何类型  
                 <? extends T> 表示泛型上限， T类型或T的子类 
                 <? super T> 表示泛型下限，T类型或T的父类
5 Iterator迭代器
        hasNext();
        next();
        remove();
6 List接口 
     List接口的特点：有序的，可以重复
7 ArrayList实现类
     存储结构：数组
     适合遍历查找,不适合插入和删除
8 LinkedList实现
     存储结构：双向链表
     适合做添加，删除，不适合遍历和查找
9 Vector向量集合  Stack栈 （先进后出）  Queue队列(先进先出)

今天任务

1.Set接口
    1.1 Set接口的常用方法
    1.2 存储特点
    1.3 Set常用实现类
2.Map接口
    2.1 概述
    2.2 Map接口的常用方法
    2.3 Map常用实现类
    2.4 Map集合的遍历
3.Collections工具类
    3.1 Collections中的常用方法

教学目标

1.了解Set集合的特点
2.掌握Set集合下常用实现类的使用
3.了解Map集合的特点
4.掌握Map集合下常用实现类的使用
5.掌握Map集合的遍历方式
6.掌握Collections工具类

第一节 Set接口

1.1 Set接口常用方法

1.2 存储特点

相对无序存储，不可以存储相同的元素（排重），不能通过下标访问

package com.qf.day16;

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

/**
 * Set接口
 * 特点：无序，不可重复
 * @author wgy
 *
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建对象
        Set<String> set=new HashSet<String>();
        //1添加
        set.add("菊花");
        set.add("枸杞");
        set.add("红枣");
        set.add("人参");
        set.add("灵芝");
        set.add("枸杞");
        System.out.println("元素个数:"+set.size());
        System.out.println(set);
        //2删除
        //2.1删除一个
//      set.remove("灵芝");
//      System.out.println("删除之后:"+set);
//      //2.2清空
//      set.clear();
        //3遍历
        //3.1foreach
        System.out.println("--------增强for----------");
        for (String string : set) {
            System.out.println(string);
        }
        //3.2使用迭代器
        System.out.println("---------迭代器-------");
        Iterator<String> it=set.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
        //4判断
        System.out.println(set.contains("菊花"));
        System.out.println(set.contains("梅花"));
    }
}

1.3 Set常用实现类

1.3.1 HashSet

此类实现Set接口，由哈希表（实际上是一个HashMap实例）支持。它不保证set的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用null元素。

Hash：哈希——实际含义散列,就是一种算法，把任意长度的输入通过散列算法变换成固定长度的输出，该输出就是散列值。

哈希表:数组加链表,既有数组的优点也有链表的优点。

存储特点：
    相对无序存储，不可以存储相同元素（排重），通过哈希表实现的集合

1.3.2 重写hashCode()

hashCode()是Object中的方法，每个对象的hashCode值是唯一的，所以可以理解成hashCode值表示这个对象在内存中的位置

字符串String的hashCode(),是根据内容计算的。

HashSet集合排重时，需要判断两个对象是否相同，对象相同的判断可以通过hashCode值判断，所以需要重写hashCode()方法

案例：设计一个Animal类，重写hashCode方法，向一个HashSet集合中添加Animal对象，

    检验是否排重（若所有属性都相同，视为相同元素）

代码实现：

public class Animal {
    private String name;
    private int age;
    @Override
    public String toString() {
        return "Animal [name=" + name + ", age=" + 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;
    }
    public Animal() {
        super();
    }
    public Animal(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    /*重写hashCode()方法，单纯为了检查此方法是否可以实现排重效果，所以返回一个固定的值，使所有本类对象的hashCode值都是相同的*/
    public int hashCode() {
        return 1;
    }
}

向HashSet集合中添加多个Animal对象时，所有属性都相同时，并没有完成想要的排重效果；

所以只重写hashCode方法并不能实现我们想要的排重效果

1.3.3 重写equals()

equals()方法是Object类中的方法，表示比较两个对象是否相等，若不重写相当于比较对象的地址，

所以我们可以尝试重写equals方法，检查是否排重

案例：设计一个Animal类，重写equals方法，向一个HashSet集合中添加Animal对象，
    检验是否排重（若所有属性都相同，视为相同元素）

代码实现：

public class Animal {
    private String name;
    private int age;
    @Override
    public String toString() {
        return "Animal [name=" + name + ", age=" + 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;
    }
    public Animal() {
        super();
    }
    public Animal(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    /*重写hashCode()方法，单纯为了检查此方法是否可以实现排重效果，所以返回true，使得所有本类对象使用equals方法比较时，都是相等的*/
    public boolean equals(Object obj) {
        return true;
    }
}

向HashSet集合中添加多个Animal对象时，所有属性都相同时，并没有完成想要的排重效果；

所以只重写equals方法，也不能完全实现我们想要的排重效果。

1.3.4 HashSet集合实现排重

HashSet的重复依据：  hashCode和equals
需要同时重写hashCode和equals方法，实现排重。
案例：设计一个Student类，同时重写hashCode和equals方法，检查是否实现排重

代码实现：

public class Student {
    private String name;
    public Student(String name) {
        super();
        this.name = name;
    }
    public Student() {
        super();
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + "]";
    }
    @Override
    //重写equals
    public boolean equals(Object obj) {
        //先判断传入的参数对象是否是Student对象，若不是直接返回false
        if(obj instanceof Student) {
            //若是，强转成Student对象，并比较属性的值
            Student s = (Student) obj;
            if(this.name.equals(s.name)) {
                 //若属性的值相同，则返回true
                return true;
            }
        }
        return false;
    }
    @Override
    public int hashCode(){
        /*hashCode方法返回值是int类型，所以重写时需要找到int类型的数据返回，还要保证此方法的返回值与对象的所有属性都相关,所以返回姓名属性的字符串的长度*/
        return this.name.hashCode();
    }
}

同时重写hashCode和equals两个方法，可以实现元素的排重效果

1.3.5 LinkedHashSet

LinkedHashSet类是具有可预知迭代顺序(相对有序)的Set接口的哈希表和链接列表实现。是HashSet的子类。

存储特点：
    有序存储，不可以存储相同元素（排重），通过链表实现的集合的有序。
LinkedHashSet集合的元素排重与HashSet集合排重方法一致。

1.3.6 TreeSet集合

TreeSet集合是可以给元素进行重新排序的一个Set接口的实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的Comparator进行排序，具体取决于使用的构造方法。 
存储特点：
    无序存储，排重，通过红黑树实现的集合，可以给元素进行重新排序

1.3.7 SortedSet接口

TreeSet除了实现了Set接口外，还实现了SortedSet接口

SortedSet接口中常用的方法：

1.3.8 TreeSet集合的元素排序

自然排序

元素所属的类需要实现java.lang.Comparable接口，并重写compareTo方法。

compareTo方法除了可以进行排序外，还有排重的功能，但是必须在compareTo方法中对类中所有的属性值都进行判断，否则不比较那个属性，排重就会忽略哪个属性

案例：设计一个Person类，实现将Person对象添加到TreeSet集合中时，对所有的元素进行排序

代码实现：

public class Person implements Comparable<Person> {
    private String name;
    private 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 void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    //重写compareTo方法，按照年龄升序，若年龄相同按照姓名降序排序
    public int compareTo(Person o) {
        //Person中有两个属性，此方法中必须对name和age两个属性都进行比较，否则将无法正确排重
        if(this.age != o.age) {
            return this.age - o.age;
        }else {
            return o.name.compareTo(this.name);
        }
    }
}

定制排序

元素需要通过java.util.Comparator接口（比较器）中的compare方法进行比较大小，并排序。

compare方法除了可以进行排序外，还有排重的功能，但是必须在compare方法中对类中所有的属性值都进行判断，否则不比较那个属性，排重就会忽略哪个属性

TreeSet集合中的无参数构造方法默认使用自然排序的方式对元素进行排序，使用TreeSet集合的定制排序时，创建集合对象不可以直接使用无参数构造方法，需要使用传入一个Comparator比较器的构造方法创建集合对象。

代码实现：

public class Animal {
    private String name;
    private int age;
    @Override
    public String toString() {
        return "Animal [name=" + name + ", age=" + 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;
    }
    public Animal(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Animal() {
        super();
    }
}
public class AnimalDemo{
    public static void main(String[]args){
        //创建一个TreeSet集合，使用Comparator接口的匿名内部类的匿名对象作为比较器
        TreeSet<Animal> treeSet = new TreeSet<>(new Comparator() {
            @Override
            public int compare(Animal o1, Animal o2) {
                if(o1.age!=o2.age) {
                    return o2.age - o1.age;
                }else {
                    return o1.name.compareTo(o2.name);
                }
            }
        });
        //添加元素
        treeSet.add(new Animal("大黄", 1));
        treeSet.add(new Animal("旺财", 2));
        //遍历集合
        Iterator<Animal> it = treeSet.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

上机练习:按照字母的长度来排列字符串 ,如果长度一样 按照编码顺序排列

"dog" "hello" "beijing" "tianjin" "shanghai" "guangzhou"

package com.qf.day16_2;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * 上机练习:按照字母的长度来排列字符串  ,如果长度一样 按照编码顺序排列
 * @author wgy
 *"dog"   "hello"  "beijing"   "tianjin"   "shanghai"   "guangzhou"
 */
public class Demo1 {
    public static void main(String[] args) {
        TreeSet<String> treeSet=new TreeSet<String>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                
                int n=o1.length()-o2.length();
                int m=o1.compareTo(o2);
                
                return n!=0?n:m;
            }
        });
        
        treeSet.add("beijing");
        treeSet.add("guangzhou");
        treeSet.add("shanghai");
        treeSet.add("tianjin");
        treeSet.add("hello");
        treeSet.add("dog");
        treeSet.add("no");
        
        System.out.println(treeSet);
        
    }
}

第二节 Map接口

2.1 概述

Map接口是将键映射到值的对象。一个映射不能包含重复的键，每个键最多只能映射到一个值，值可以重复。
cn--->中国
usa--->美国
uk--->英国
us--->美国
cn--->中华人民共和国

2.2 Map接口的常用方法

案例：

package com.qf.day16_2;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * Map集合的使用
 * 1 存储的键值对，键不能重复，一个键对应一个值，值可以重复。
 * 2 无序
 * @author wgy
 *
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建集合
        Map<String, String> map=new HashMap<>();
        //1添加元素
        map.put("cn", "中国");
        map.put("usa", "美国");
        map.put("uk","英国");
        map.put("kor", "韩国");
        map.put("cn", "中华人民共和国");//会把原来的值覆盖掉
        //map.put("us", "美国");
        
        System.out.println("元素个数:"+map.size());
        System.out.println("打印："+map.toString());
        
        //2删除
        //map.remove("uk");
        //System.out.println("删除之后:"+map.toString());
        ///map.clear();
        //3遍历
        //3.1使用keySet遍历
        System.out.println("---------keySet()----------");
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            System.out.println(key+"..........."+map.get(key));
        }
        //3.2使用entrySet();
        System.out.println("---------entrySet()---------");
        Set<Entry<String, String>> entrySet = map.entrySet();//Entry（映射对）
        for (Entry<String, String> entry : entrySet) {
            System.out.println(entry.getKey()+"...."+entry.getValue());
        }
        
        //4判断
        //4.1isEmpty
        System.out.println("判断isEmpty():"+map.isEmpty());
        
        //4.2判断是否包含指定的key
        System.out.println("cn:"+map.containsKey("cn"));
        //4.3判断是否包含指定的value
        System.out.println("韩国:"+map.containsValue("韩国"));
        
        
    }
}

2.3 Map常用实现类

2.3.1 HashMap

基于哈希表的Map接口的实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序。

存储特点：
    相对无序存储，元素以键值对形式存在，键不可以重复，值可以重复，元素整体排重，可以快速的通过键查找到所对应的值，通过哈希表实现的集合。

HashMap集合的排重，只需要重写键所属的类的hashCode和equals方法即可。

代码实现：

//Person作为键
public class Person {
    private String name;
    private int age;
    public Person() {
        super();
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = 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;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    @Override
    public int hashCode() {
        return age + name.length();
    }
    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Person) {
            Person p = (Person) obj;
            if(p.name.equals(name)&&p.age==age) {
                return true;
            }
        }
        return false;
    }
}
//Dog类作为值
public class Dog {
    private String name;
    public Dog(String name) {
        super();
        this.name = name;
    }
    public Dog() {
        super();
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Dog [name=" + name + "]";
    }
}
//测试类
public class Demo {
    public static void main(String[] args) {
        HashMap<Person, Dog> map = new HashMap<>();
        map.put(new Person("zhangsan", 12), new Dog("大黄"));
        map.put(new Person("lisi", 12), new Dog("旺财"));
        map.put(new Person("zhangsan", 12), new Dog("二哈"));
      
    }
}

map集合中若向集合中添加相同键的键值对时，新的值会将旧的值覆盖。
上述代码中map集合中有两个键值对，分别为：张三-12---二哈，lisi-12---旺财

2.3.2 LinkedHashMap

LinkedHashMap集合是具有可预知迭代顺序的Set接口的哈希表和链接列表实现。此实现与HashSet的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。用法与HashSet类似。

存储特点：
    有序存储，元素排重，通过链表实现的集合。

2.3.3 Hashtable

此类实现一个哈希表，该哈希表将键映射到相应的值。任何非null对象都可以用作键或值。
Hashtable有一个子类Properties，Properties集合使用的比较频繁。

存储特点：
    相对无序存储，元素排重，通过哈希表实现的集合。

2.3.4 HashMap与Hashtable的区别

1）Hashtable线程安全的，而HashMap线程不安全的
2）Hashtable中不允许存在null的键和null值，但是HashMap中允许null的键和null值

2.4 Map集合的遍历

2.4.1 使用keySet方法与get方法结合

public class Demo {
    public static void main(String[] args){
        HashMap<String, Integer> map = new HashMap<>();
        map.put("aaa", 12);
        map.put("bbb", 13);
        map.put("ccc", 14);
        //通过keySet获取map中所有键
        Set<String> set = map.keySet();
        //获取set的迭代器
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            String s = it.next();
            //通过迭代的键，找到对应的值，一起输出
            System.out.println(s+"---"+map.get(s));
        }
    }
}

2.4.2 使用Map.Entry方法：

调用Map集合的entrySet方法，相当于将Map集合转成一个Set集合，再通过Set集合的遍历方式遍历即可。

代码实现：

public class Demo {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("aaa", 111);
        map.put("bbb", 222);
        map.put("ccc", 333);
        //将map转成一个Set集合
        Set<Map.Entry<String, Integer>> set = map.entrySet();
        //遍历set
        Iterator<Map.Entry<String, Integer>> it = set.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

TreeMap

存储结构：自平衡红黑二叉树

特点：1 存储键值对、键不能重复、一个键对应一个值、值可以重复
     2 无序，数据会进行排序。
排重依据：Comparable接口的compareTo()方法的返回值。如果返回0就认为是重复的元素。  

案例1:

/**
 * TreeMap的使用
 * 存储结构：自平衡红黑二叉树
 * @author wgy
 *
 */
public class Demo5 {
    public static void main(String[] args) {
        //创建集合
        TreeMap<Person, String> treeMap=new TreeMap<>();
        Person p1=new Person("马云", 50);
        Person p2=new Person("李彦宏", 45);
        Person p3=new Person("马化腾", 40);
        Person p4=new Person("马云", 50);
        
        //1添加数据
        treeMap.put(p1, "杭州");
        treeMap.put(p2, "北京");
        treeMap.put(p3, "深圳");
        treeMap.put(p4, "shanghai");
        
        System.out.println("元素个数:"+treeMap.size());
        System.out.println(treeMap.toString());
        
        System.out.println("---------------------比较器--------------------");
        TreeMap<Person, String> treeMap2=new TreeMap<>(new Comparator<Person>() {

            @Override
            public int compare(Person o1, Person o2) {
                int n=o1.getAge()-o2.getAge();
                int n2=o1.getName().compareTo(o2.getName());
                return n==0?n2:n;
                
            }
        });
        treeMap2.put(p1, "杭州");
        treeMap2.put(p2, "北京");
        treeMap2.put(p3, "深圳");
        treeMap2.put(p4, "shanghai");
        
        System.out.println(treeMap2.toString());
        
    }
}

小结：

Collection 父接口 集合中常用方法 add() remove() contains() size() clear() iterator()

? -----List：特点：有序，可以重复

? ----ArrayList: 存储结构 数组 适合遍历查找

? ----LinkedList: 存储结构 链表 适合插入 删除

? ----Vector 向量

? ----Stack 栈 (特点先进后出)

? -----Set: 特点：无序 ，不能重复

? ----HashSet:存储结构: 哈希表 无序 ，不能重复:重复依据： hashCode() equals()

? ----LinkedHashSet: 存储结构: 哈希表 有序

? ----TreeSet:存储结构：红黑自平衡二叉树 无序 ，排序 ; 不能重复:重复依据：Comparable接口 compareTo(); 返回值为0就是重复的。

? Comparator:比较器，compare( o1, o2){ } 如果返回值为0 重复元素

Map 特点：1存储键值对 ，键不能重复，一个键对应一个值，值可以重复 2 无序

? ----HashMap:存储结构：哈希表 ，无序 ，键不能重复： 键重复依据： hashCode() equals()

? ----LinkeHashMap:存储结构：哈希表 ，有序

? ----Hashtable: jdk1.0的出现的集合，不能存储null键和null值，线程安全的。

? ---Properties:没讲

? ----TreeMap:存储结构：红黑自平衡二叉树

? Hash开头的存储结构哈希表 hashCode和equals

? Tree开头的存储二叉树 排序 比较 Comparable Comparator

? Link开头都是有序的

第三节 Collections工具类

此类完全由在 Collection 上进行操作或返回 Collection 的静态方法组成。对集合进行操作时，可以使用这个类中的静态方法。

3.1 Collections中常用方法

1.排序

/*
        static <T extends Comparable<? super T>> 
void sort(List<T> list) 
          根据元素的自然顺序 对指定列表按升序进行排序。 
        */
        ArrayList<Integer> list = new ArrayList<>();
        list.add(-10);
        list.add(5);
        list.add(3);
        list.add(7);

        System.out.println(list);
        Collections.sort(list);//默认升序
        System.out.println(list);

2.将集合中的元素进行反转

        /*
        static void reverse(List<?> list) 
          反转指定列表中元素的顺序。 
        */
        Collections.reverse();

3.将集合元素打乱

        /*
        static void shuffle(List<?> list) 
          使用默认随机源对指定列表进行置换。 
        */

4.获取集合中的最大值、最小值

        /*
        static T max(Collection coll) 
          根据元素的自然顺序，返回给定 collection 的最大元素。
          
          static <T extends Object & Comparable<? super T>> 
        T min(Collection<? extends T> coll) 
          根据元素的自然顺序 返回给定 collection 的最小元素。 
        */
        int n1 = Collections.max(list);

5.替换

        /*
        static <T> boolean 
 replaceAll(List<T> list, T oldVal, T newVal) 
          使用另一个值替换列表中出现的所有某一指定值 
        */
        //原因：List集合是不排重的，使用新的元素将集合中出现的所有的旧的元素替换掉
        Collections.replaceAll(list,5,100);

6.统计指定元素在集合中出现的次数

        /*
        static int frequency(Collection<?> c, Object o) 
          返回指定 collection 中等于指定对象的元素数。 
        */
        int num = Collections.frequency(list,5);

7.二分法查找

        /*
        static <T> int 
 binarySearch(List<? extends Comparable<? super T>> list, T key) 
          使用二分搜索法搜索指定列表，以获得指定对象。 
        */
        //前提：必须是排好序的集合
        int index = Collections.binarySearch(list,-10);

        //注意：Collections工具类中的方法只操作Collection接口，主要操作的是List接口 

8.集合和数组的转换

//1 数组转成集合
    package com.qf.day16;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Demo2 {
    public static void main(String[] args) {
        //arrayToList();
        //listToArray();
         arrayToList2();
    }
    //1数组转成集合，集合不能做添加、删除操作
    public static void arrayToList() {
        String[] names= {"张三","李四","王五"};
        List<String> list=Arrays.asList(names);
        
        System.out.println("list："+list);
        //添加
        //list.add("赵六");
        //删除
        //list.remove(0);
        //System.out.println("添加或删除之后list："+list);
        list.set(0, "本伟");
        System.out.println("替换之后:"+list);
        
    }
    //2 集合转成数组
    public static void listToArray() {
        ArrayList<String> arrayList=new ArrayList<>();
        arrayList.add("苹果");
        arrayList.add("小米");
        arrayList.add("华为");
        arrayList.add("三星");
        
        //数组
        String[] arr=arrayList.toArray(new String[0]);
        System.out.println("--------遍历数组-------");
        for (String string : arr) {
            System.out.println(string);
        }
    }
    
    //3特殊
    public static void arrayToList2() {
        Integer[] nums= {10,20,5,8,9};
        List<Integer> arraylist=Arrays.asList(nums);
        for (Integer integer : arraylist) {
            System.out.println(integer);
        }
        
    }
    
}

    

总结

Collection 父接口
    |_____List （特点：有序的，可以重复）
           |___ArrayList （存储结构:数组，适合遍历查找）
            |___LinkedList  （链表，适合添加和删除）
            |___Vector      数组 
            |___Stack       数组（栈）先进后出
    |
    |_____Set（特点:无序的，不能重复）
           |_____HashSet  哈希表(数组+链表+二叉树)  
                 重复依据：1 执行hashCode()来计算存储的位置 2 执行equals比较结果
           |_____LinkedHashSet 哈希表 可以保证顺序 
           |_____TreeSet  自平衡红黑二叉树 
            1 元素要实现Comparable接口 2 定制比较器 Comparator  
                 重复依据：Comparable接口的compareTo方法的返回值0，或比较器的返回为0
Map(特点：1存储键值对，一个键对应一个值，键不能重复，值可以重复 2 无序)  
  |______ HashMap  哈希表 1 执行hashCode()来计算存储的位置 ，2 执行equals比较结果
  |______ Hashtable 哈希表  不能存储null键和null值，线程安全的  jdk1.0
           --Properties
  |_______LinkedHashMap  哈希表  可以保证顺序
  |_______TreeMap  自平衡红黑二叉树  1 key 要实现Comparable接口 ，2 定制比较器 Comparator
 
 Collections工具类的使用。
 

课前默写

1.实例化一个ArrayList对象  ArrayList<String> list = new ArrayList<>()
2.简述ArrayList和LinkedList之间的区别

作业

1.按照要求完成下面的题目
      1>创建一个List，在List中增加三个工人，基本信息如下： 
          姓名 年龄 工资 
          zhang3 18 3000 
          li4 25 3500 
          wang5 22 3200 
      2> 在li4之前插入一个工人，信息为：姓名：zhao6，年龄：24，工资3300 
      3> 删除wang5 的信息 
      4> 利用for 循环遍历，打印List 中所有工人的信息 
      5> 利用迭代遍历，对List中所有的工人调用work 方法。 
      6> 为工人类Worker重写equals方法，当姓名、年龄、工资全部相等时候才返回true  
2>.创建一个Student类，有成员变量name和cardId。如果两个学生对象的姓名和学号一样视为同一个学生，在HashSet中添加学生对象 并遍历打印学生信息。

3>.向TreeSet集合中加入5个员工的对象，根据员工的年龄（升序）进行排序，若年龄相同，再根据
 工龄（降序）来排序，若工龄相同，根据薪水（降序）排序

面试题

1.简述HashSet和LinkedHashSet之间的区别

Set和Map

原文：https://www.cnblogs.com/Zzzxb/p/11397140.html