Java的集合类定义在java.util包中，支持泛型，主要提供了3种集合类，包括List，Set和Map。Java集合使用统一的Iterator遍历。
1、List遍历
实现了Iterator接口的集合类都可以直接用for each循环来遍历，Java编译器本身并不知道如何遍历集合对象，但它会自动把for each循环变成Iterator的调用
public class Main {
public static void main(String[] args) {
List
for (String s : list) {
System.out.println(s);
}
}
}
2、List和Array转换
把List变为Array有三种方法
第一种是调用toArray()方法直接返回一个Object[]数组 Object[] array = list.toArray();
第二种方式是给toArray(T[])传入一个类型相同的Array，List内部自动把元素复制到传入的Array中 Integer[] array = list.toArray(new Integer[3]);
第三种方式是通过List接口定义的T[] toArray(IntFunction<T[]> generator)方法 Integer[] array = list.toArray(Integer[]::new);
3、List是一种有序链表：List内部按照放入元素的先后顺序存放，并且每个元素都可以通过索引确定自己的位置
List提供了boolean contains(Object o)方法来判断List是否包含某个指定元素。此外，int indexOf(Object o)方法可以返回某个元素的索引，如果元素不存在，就返回-1。
往List中添加的"C"和调用contains("C")传入的"C"不是同一个实例，但是取到了元素和索引，因为List内部并不是通过==判断两个元素是否相等，而是使用equals()方法判断两个元素是否相等
public static void main(String[] args) {
List
list.add(“A”);
list.add(“B”);
list.add(“C”);
System.out.println(list.contains(“B”)); // true
System.out.println(list.indexOf(“B”)); // 1
System.out.println(list.contains(new String(“C”))); // true
System.out.println(list.indexOf(new String(“C”))); // 2
}
要正确使用List的contains()、indexOf()这些方法，放入的实例必须正确覆写equals()方法，否则，放进去的实例，查找不到。我们之所以能正常放入String、Integer这些对象，是因为Java标准库定义的这些类已经正确实现了equals()方法。
equals()方法的正确编写方法：
1、 先确定实例“相等”的逻辑，即哪些字段相等，就认为实例相等；
2、 用instanceof判断传入的待比较的Object是不是当前类型，如果是，继续比较，否则，返回false；
3、 对引用类型用Objects.equals()比较，对基本类型直接用==比较。
使用Objects.equals()比较两个引用类型是否相等的目的是省去了判断null的麻烦。两个引用类型都是null时它们也是相等的。
如果不调用List的contains()、indexOf()这些方法，那么放入的元素就不需要实现equals()方法。
public class TestList {
public static void main(String[] args) {
List
list.add(new Person(“小王”, “男”, 18));
list.add(new Person(“小明”, “男”, 25));
list.add(new Person(“小李”, “女”, 20));
boolean exist = list.contains(new Person(“小明”, “男”, 25));
System.out.println(exist ? “查询成功!” : “查询失败!”);//查询成功;没有重写equals方法结果返回：查询失败
}
}
class Person {
String name;
String sex;
int age;
public Person(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public boolean equals(Object o){
if(o instanceof Person){
Person p = (Person) o;
return this.name.equals(p.name) && Objects.equals(this.sex,p.sex) && this.age==p.age;
}
return false;
}
}
4、Map这种键值（key-value）映射表的数据结构，作用就是能高效通过key快速查找value（元素）。
如果只是想查询某个key是否存在，可以调用boolean containsKey(K key)方法。
Map中不存在重复的key，因为放入相同的key，只会把原有的key-value对应的value给替换掉。
对Map来说，要遍历key可以使用for each循环遍历Map实例的keySet()方法返回的Set集合，它包含不重复的key的集合。
同时遍历key和value可以使用for each循环遍历Map对象的entrySet()集合，它包含每一个key-value映射。
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<String, Integer>();
map.put(“A”, 1);
map.put(“B”, 2);
map.put(“C”, 3);
for(String key : map.keySet()){
Integer num = map.get(key);
System.out.println(num);// 1 2 3
}
for(Map.Entry<String,Integer> en :map.entrySet()){
String aa = en.getKey();
Integer bb = en.getValue();
System.out.println(aa+”: “+bb);//A:1 B:2 C:3
}
}
5、编写equals和hashCode
HashMap之所以能根据key直接拿到value，原因是它内部通过空间换时间的方法，用一个大数组存储所有value，并根据key直接计算出value应该存储在哪个索引
正确使用Map必须保证：
1、 作为key的对象必须正确覆写equals()方法，相等的两个key实例调用equals()必须返回true；
2、 作为key的对象还必须正确覆写hashCode()方法，且hashCode()方法要严格遵循以下规范：
- 如果两个对象相等，则两个对象的
hashCode()必须相等； - 如果两个对象不相等，则两个对象的
hashCode()尽量不要相等。
HashMap初始化时默认的数组大小只有16
添加超过一定数量的key-value时，HashMap会在内部自动扩容，每次扩容一倍，即长度为16的数组扩展为长度32，相应地，需要重新确定hashCode()计算的索引位置
HashMap内部的数组长度总是2的n次方
不同的key具有相同的hashCode()的情况称之为哈希冲突
要正确使用HashMap，作为key的类必须正确覆写equals()和hashCode()方法；
一个类如果覆写了equals()，就必须覆写hashCode()，并且覆写规则是：
如果equals()返回true，则hashCode()返回值必须相等；
如果equals()返回false，则hashCode()返回值尽量不要相等。
6、TreeMap
还有一种Map，它在内部会对Key进行排序，这种Map就是SortedMap。注意到SortedMap是接口，它的实现类是TreeMap。
使用TreeMap时，放入的Key必须实现Comparable接口。String、Integer这些类已经实现了Comparable接口，因此可以直接作为Key使用。作为Value的对象则没有任何要求。
public static void main(String[] args) {
//SortedMap内部会对Key进行排序。注意到SortedMap是接口，它的实现类是TreeMap。
Map<String, String> map = new TreeMap<String, String>();
map.put(“aa”, “11”);
map.put(“bb”, “22”);
map.put(“cc”, “33”);
map.put(“dd”, “44”);
//打印结果： 11 22 33 44
for(String name : map.keySet()){
String value = map.get(name);
System.out.print(value+” “);
}
}
7、Set
最常用的Set实现类是HashSet，实际上，HashSet仅仅是对HashMap的一个简单封装;经常用Set用于去除重复元素
Set接口并不保证有序，而SortedSet接口则保证元素是有序的：
HashSet是无序的，因为它实现了Set接口，并没有实现SortedSet接口；TreeSet是有序的，因为它实现了SortedSet接口。
8、Queue
队列（Queue）是一种经常使用的集合。Queue实际上是实现了一个先进先出（FIFO：First In First Out）的有序表。它和List的区别在于，List可以在任意位置添加和删除元素，而Queue只有两个操作：
- 把元素添加到队列末尾；
- 从队列头部取出元素。
队列接口Queue定义了以下几个方法：
int size()：获取队列长度；
boolean add(E)/boolean offer(E)：添加元素到队尾；
E remove()/E poll()：获取队首元素并从队列中删除；
E element()/E peek()：获取队首元素但并不从队列中删除。
9、栈（Stack）是一种后进先出（LIFO：Last In First Out）的数据结构。
Stack只有入栈和出栈的操作：
- 把元素压栈：
push(E)； - 把栈顶的元素“弹出”：
pop(E)； - 取栈顶元素但不弹出：
peek(E)。
Stack的作用
Stack在计算机中使用非常广泛，
JVM在处理Java方法调用的时候就会通过栈这种数据结构维护方法调用的层次。
JVM会创建方法调用栈，每调用一个方法时，先将参数压栈，然后执行对应的方法；当方法返回时，返回值压栈，调用方法通过出栈操作获得方法返回值。
因为方法调用栈有容量限制，嵌套调用过多会造成栈溢出，即引发StackOverflowError
对整数进行进制的转换就可以利用栈