JAVA集合框架
Collection是所有Java集合框架的父接口；Collections操作集合的工具类
这里简单介绍三类集合，List、Set、Map
List：
List表示的是一个有序的集合，可以存放重复的元素，因为有序，所以可以根据下标访问每一个元素，实现增删改查
ArrayList：
1.ArrayList是动态数组，是线程不安全的
2.由于是类似与数组的存储方式，所以随机访问的速度很快，但相对于添加删除效率要低一点
3.ArrayList有个默认的内存大小（10），以后每次扩充标准是：(原始容量*3)/2+1
下面通过实例见一些基础操作：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class demo5 {
public static void main(String[] args) {
List list=new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add(1, "a"); //在指定位置添加元素
/**第一种遍历方式，通过toArray()方法转化为数组遍历*/
System.out.print("第一次遍历：");
String str[]=new String[list.size()];
list.toArray(str);
for(int i=0;i<list.size();i++) {
System.out.print(str[i]+"\t");
}
System.out.print("\n"+"删除后：");
list.remove(1); //删除指定索引位置的元素
list.remove("b"); //删除指定元素
list.remove("u"); //如果不存在，则不影响
/**第二种遍历方法，通过get()方法，获取指定索引下的元素，注意返回类型是Object*/
for(int i=0;i<list.size();i++) {
System.out.print(list.get(i)+"\t");
}
for(int i=0;i<5;i++) {
list.add(i);
}
/*第三种遍历方式，通过迭代器iterator遍历*/
System.out.print("\n"+"添加后输出：");
Iterator it=list.iterator();
while(it.hasNext()) {
System.out.print(it.next()+"\t");
}
List list3=new ArrayList<>();
list3.add(3);
list3.add(2);
System.out.println("\n"+list.isEmpty()); //判断集合是否为空
System.out.println(list.contains("3")); //判断集合是否存在指定元素
System.out.println(list.containsAll(list3)); //判断集合是否存在指定集合中的元素，顺序无关
List list2=list.subList(0, 2); //返回的是父list的一个视图，包含开头，不包含结尾，也就是包含0，不包含2
System.out.println("第一次操作："+list);
list2.add("e"); //子list改变会影响父list
System.out.println("改变过后操作："+list);
list.add("r"); //如果父list被改变，子list也被销毁
System.out.println(list2); //程序不会报错，然而最后会出现java.util.ConcurrentModificationException
/*最后一种遍历方式，增强for循环*/
System.out.print("foreach循环：");
for (Object object : list) {
System.out.print(object+"\t");
}
}
}
LinkedList：
1.LinkedList是基于双向链表实现的，也是线程不安全
2.LinkedList的增加和删除是很快的，因为是类似与C语言的指针
3.LinkedList的随机访问很慢，只有一个元素一个元素的找
4.linkedList除了有ArrayList的方法，还有一些特有方法
下面通过实例了解：
import java.util.LinkedList;
public class demo5 {
public static void main(String[] args) {
LinkedList list=new LinkedList<>();
//这里注意，必须这样定义才能使用LinkedList特有方法，定义成List list=new LinkedList<>();是不能使用的
for(int i=0;i<5;i++) {
list.add(i);
}
System.out.println(list);
list.addFirst(8); //在第一个位置添加元素
list.addLast(7); //在最后一个位置添加元素
System.out.println(list);
list.removeLast(); //删除最后位置
list.removeFirst(); //删除开头
System.out.println(list);
System.out.println(list.getFirst()+""+list.getLast()); //返回第一个元素以及最后一个元素
/*由于没有使用泛型，所以返回类型都是Object，所以中间加了个空字符串*/
}
}
Set
Set是一个无序的集合，不能存放重复元素，里面的元素都是不一样的
HashSet：
1.HashSet允许存放null
2.HashSet不允许放重复元素
3.插入顺序与输出顺序不一样
4.存放元素的位置是固定的，位置是由HashCode值决定的
下面通过具体实例了解：
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class demo4 {
public static void main(String[] args) {
Set set = new HashSet();
String str[]= {"a","dwer","bc","cfg"};
set.add(str[0]);
set.add(str[1]);
set.add(str[2]);
set.add(str[3]);
set.add(str[3]); //因为是重复元素，所以添加不进去
set.add(null);
System.out.println("HashCode值如下：");
for(int i=0;i<str.length;i++) {
System.out.println(str[i]+":"+str[i].hashCode());
}
/*插入顺序*/
System.out.print("\n"+"插入顺序如下：");
for (String string : str) {
System.out.print(string+" ");
}
System.out.print("null");
/*第一种遍历方式，通过迭代器Iterator*/
Iterator it = set.iterator();
System.out.print("\n"+"Iterator打印如下：");
while (it.hasNext())
System.out.print(it.next() + " ");
/*第二种遍历方式通过foreach*/
System.out.print("\n"+"foreach打印如下：");
for (Object obj : set) {
System.out.print(obj + " ");
}
/*第三种遍历方式*/
Object obj[]=new Object[set.size()];
set.toArray(obj);
System.out.print("\n"+"转换数组打印如下：");
for(int i=0;i<set.size();i++) {
System.out.print(obj[i]+" ");
}
}
}
TreeSet：
1.有序集合，可以自己定义排序规则，也可以使用默认的
2.不允许重复元素
3.线程不安全
下面通过具体代码了解下：
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class demo5 {
public static void main(String[] args) {
Set set=new TreeSet();
String str[]= {"aedc","dwer","fc","cfg"};
set.add(str[0]);
set.add(str[1]);
set.add(str[2]);
set.add(str[3]);
set.add(str[3]); //因为是重复元素，所以添加不进去
/*插入顺序*/
System.out.print("插入顺序如下：");
for (String string : str) {
System.out.print(string+" ");
}
/*第一种遍历方式，通过迭代器Iterator*/
Iterator it = set.iterator();
System.out.print("\n"+"Iterator打印如下：");
while (it.hasNext())
System.out.print(it.next() + " ");
}
}
/**
* TreeSet默认排序规则是按字典顺序排序
* 如果自定义类，就需要实现Comparerable<T>接口 ，并且重写compareTo方法
* 重写方法，通过this引用当前对象和传入的对象进行比较
* */
Map:
Map主要用于存储健值对，根据键得到值，因此不允许键重复,但允许值重复。
HashMap:
1.根据键的HashCode 值存储数据,根据键可以直接获取它的值，具有很快的访问速度
2.HashMap最多只允许一条记录的键为Null,允许多条记录的值为 NullHashMap
3.不支持线程的同步
下面通过实例代码了解一下：
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class demo5 {
public static void main(String[] args) {
Map map=new HashMap<>();
String str[]= {"帅帅哒","帅气","美美哒","还是帅","帅","美"};
String str1[]= {"好玩","好吃","好看","好玩","安逸"};
map.put(null, 5);
for(int i=0;i<str1.length;i++) {
map.put(str[i], str1[i]);
}
map.put(str[str.length-1], null);
System.out.println("直接打印："+map+"\n");
/*第一次遍历map*/
System.out.println("通过key值获取存放的值");
for (Object obj : map.keySet()) {
//KeySet()方法是获取map中键的集合
System.out.println("key："+obj+"\t"+"值："+map.get(obj));
}
map.remove(str[3]); //删除指定key对应的键值
/*第二次遍历*/
System.out.println("\n"+"通过Iterator遍历：");
Iterator<Map.Entry<Object,Object>> iterator=map.entrySet().iterator();
//map.entrySet() 就是拿到所有map的键值对集合
while(iterator.hasNext()) {
Map.Entry<Object, Object> entry=iterator.next();
System.out.println("key："+entry.getKey()+"\t"+"值："+entry.getValue());
}
/*第三种遍历*/
System.out.println("\n"+"通过values遍历："); //只能遍历值，不能遍历键
for (Object obj : map.values()) {
System.out.println("值为："+obj);
}
System.out.println(map.size()); //打印存放的对数
System.out.println(map.containsKey("帅")); //判断是否存在这个建
System.out.println(map.containsValue("美")); //判断是否存在这个值
}
}
TreeMap:
1.基础和HashMap差不多，不过多累赘代码
2.键和值都不能存放null
3.会更具键进行默认排序，也可以自己定义排序规则
Collections
Collections是集合中自带的一些算法，下面直接见代码：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class demo5 {
public static void main(String[] args) {
List list=new ArrayList<>();
list.add(5);
list.add(500);
list.add(1);
list.add(1);
list.add(502);
list.add(521);
list.add(520);
list.add(1314);
list.add(2333);
System.out.println(list);
Collections.sort(list); //对集合进行升序排序
System.out.println(list);
System.out.println(Collections.binarySearch(list, 502)); //查找指定元素的下标
Collections.reverse(list); //对集合进行反转
System.out.println(list);
System.out.println(Collections.max(list)); //求集合的最大值
Collections.replaceAll(list, 1, 2); //对集合元素进行全部更换，第二个参数表示需要更改，第三个参数表示更改过后的
System.out.println(list);
}
}
总结
以上就是一些集合框架的知识了，更多的知识还是建议直接看官方文档，上述所列出的只是经常使用以及一些面试的问题。想要掌握，还是需要多看看文档、多练习练习