目录Java集合框架集合List接口ArrayListVectorLinkedList：泛型：Set接口HashSetTreeSetMap接口特点：遍历：HashMapHashtableTreeMap总结
Java集合框架
集合 概念：对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。 集合和数组的区别： 数组长度固定，集合长度不固定 数组可以存储基本类型和引用类型，集合只能存储引用类型。
测试
/* 1.添加 2.删除 3.遍历 4.判断 */ Collection col = new ArrayList(); col.add("张三"); col.add("李四"); col.add("王五");// col.add("张三"); System.out.println(col);// col.remove("张三");// System.out.println(col); for (Object o : col) { System.out.println(o); } System.out.println("------------------"); Iterator it = col.iterator(); while (it.hasNext()){ String next = (String) it.next(); System.out.println(next); } System.out.println(col.isEmpty()); System.out.println(col.contains("张三"));
List接口
特点：有序、有下标、元素可以重复。
可以通过角标在指定位置添加查询元素。
List list = new ArrayList(); list.add("java"); list.add("c++"); list.add(1,"python"); list.add(".net"); System.out.println(list.size()); System.out.println(list.toString()); //1.for each遍历 System.out.println("---------------"); for (Object o : list) { System.out.println(o); } //2.迭代器遍历 System.out.println("---------------"); Iterator iterator = list.iterator(); while (iterator.hasNext()){ System.out.println(iterator.next()); } //3.list迭代器遍历 System.out.println("--------正序-------"); ListIterator listIterator = list.listIterator(); while (listIterator.hasNext()){ System.out.println(listIterator.next()); } //逆序前必须先进行正序遍历，让指针指向列表最后一个元素，才能开发遍历 System.out.println("--------逆序-------"); while (listIterator.hasPrevious()){ System.out.println(listIterator.previousIndex() + ":" +listIterator.previous()); }
添加数字等基本类型数据时，会进行自动装箱的操作。
删除数字元素需要通过下标来删除，或者将需要删除的数字转成object类或者该类型对应的包装类。
subList:返回一个子集合，含头不含尾。
List实现类
ArrayList 数组存储结构，查询快、增删慢； JDK1.2版本出现，运行效率快，线程不安全。 源码分析： DEFAULT_CAPACITY = 10 默认容量 。注意：如果没有向集合中添加任何元素时，容量为0，添加一个元素之后，容量为10。每次扩容大小都是原来的1.5倍，如添加第11个元素时，容量由10变为了15。 add（）方法源码：为什么添加一个元素之后，容量为10。
public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!!增长修改个数 elementData[size++] = e; return true; }private void ensureCapacityInternal(int minCapacity) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); } ensureExplicitCapacity(minCapacity); }private void ensureExplicitCapacity(int minCapacity) { modCount++; // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity); }private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; int newCapacity = oldCapacity + (oldCapacity >> 1); if (newCapacity - minCapacity < 0) newCapacity = minCapacity; if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity); // minCapacity is usually close to size, so this is a win: elementData = Arrays.copyOf(elementData, newCapacity); }
elemetnData 存放元素的数组 size 实际元素个数
测试代码：
ArrayList arrayList = new ArrayList(); Student s1 = new Student("张三",18); Student s2 = new Student("李四",18); Student s3 = new Student("王五",18); arrayList.add(s1); arrayList.add(s2); arrayList.add(s3); System.out.println(arrayList.toString()); //删除元素（需要重写equals方法） arrayList.remove(new Student("李四",18)); System.out.println(arrayList.size()); public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Student student = (Student) o; return age == student.age && Objects.equals(name, student.name); }
Vector 数组存储结构，查询快，增删慢； JDK1.0版本出现，运行效率慢、线程安全； 枚举器遍历
Vector vector = new Vector(); vector.add("java"); vector.add("python"); vector.add(".net"); System.out.println(vector.toString()); //枚举器遍历 Enumeration elements = vector.elements(); while (elements.hasMoreElements()){ System.out.println(elements.nextElement()); }
LinkedList： 双向链表存储结构，增删快，查询慢。
泛型： 时JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递； 常见形式由泛型类、泛型接口、泛型方法； 好处： 提高代码的重用性 防止类型转换异常，提高代码的安全性
泛型集合：参数化类型、类型安全的集合，强制集合元素的类型必须一致。
特点：
编译时即可检查，而非运行时抛出异常。 访问时，不必类型转换。 不同泛型之间引用不能相互赋值，泛型不存在多态。
Set接口
特点：无序、无下标、元素不可重复
方法：全部继承自Collection中的方法。
Set实现类
HashSet 存储结构：哈希表（数组+链表+红黑树） 基于HashCode实现元素不重复 根据hashcode计算保存的位置，如果此位置为空，则直接保存。如果不为空，执行下一步。 当存入元素的哈希码相同时，会调用equals进行确认，如果为true，则拒绝后者存入。否则，则生成链表。
public HashSet(){ map = new HashMap<>();}
测试代码：
HashSet<Student> set = new HashSet<>(); Student s1 = new Student("张三",18); Student s2 = new Student("李四",18); Student s3 = new Student("王五",18); set.add(s1); set.add(s2); set.add(s3);// set.add(new Student("李四",18)); System.out.println(set.size()); System.out.println(set.toString());// set.remove(new Student("李四",18));// System.out.println(set.size());// System.out.println(set.toString()); for (Student student : set) { System.out.println(student); } System.out.println("===================="); Iterator<Student> iterator = set.iterator(); while (iterator.hasNext()){ System.out.println(iterator.next()); }public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Student student = (Student) o; return age == student.age && Objects.equals(name, student.name); }public int hashCode() { return Objects.hash(name, age); }
hashcode重写方法中加入31的原因
1.31是一个质数，减少散列冲突
2.31提高执行效率
TreeSet 存储结构：红黑树 基于排列顺序实现元素不重复 实现了SortedSet接口，对集合元素自动排序 元素对象的类型必须实现Comparable接口，指定排列规则 通过CompareTo方法确定是否为重复元素
测试代码：使用TreeSet集合实现字符串按照长度进行排序
TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() { @Override public int compare(String o1, String o2) { int n1 = o1.length() - o2.length(); int n2 = o1.compareTo(o2); return n1==0?n2:n1; } treeSet.add("zhangSan"); treeSet.add("wkf"); treeSet.add("asd"); treeSet.add("abc"); treeSet.add("ljCv"); treeSet.add("liSi"); treeSet.add("wanG"); System.out.println(treeSet.toString()); System.out.println(treeSet.size());
Map接口
特点：
1.用于储存任意键值对（Key，Value）
2.键：无序、无下标、不允许重复
3.值：无序、无下标、允许重复
遍历： keySet（）方法遍历：拿到key的set集合。 entrySet（）方法遍历：将map封装成entry键值对集合。
测试代码：
Map<String, String> map = new HashMap<>(); map.put("wkf","666"); map.put("qwe","678"); map.put("kfc","999"); map.put("asd","694"); Set<String> keySet = map.keySet(); for (String s : keySet) { System.out.println(s + "=" + map.get(s)); } System.out.println("==================="); Set<Map.Entry<String, String>> entries = map.entrySet(); for (Map.Entry<String, String> entry : entries) { System.out.println(entry.getKey() +"=" + entry.getValue() ); }
HashMap JDK1.2版本，线程不安全，运行效率快；允许用null作为key或是value。 构造一个具有默认初始容量16和默认加载因子0.75的空HashMap。 加载因子：比如当前集合容量为100，那么当数据存储到第75个位置是进行扩容操作。 源码分析
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // hashMap初始容量大小16static final int MAXIMUM_CAPACITY = 1 << 30;//hashMap的数组最大容量static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认加载因子static final int TREEIFY_THRESHOLD = 8;//jdk1.8开始，当链表长度大于8时，调整成红黑树static final int UNTREEIFY_THRESHOLD = 6;//jdk1.8开始，当链表长度小于6时，调整成链表static final int MIN_TREEIFY_CAPACITY = 64;//jdk1.8开始，当链表长度大于8时，并且集合元素个数大于等于64时调整成红黑树transient Node<K,V>[] table;//哈希表中的数组
总结：
HashMap刚创建时，table是null，为了节省空间，当添加第一个元素时，table容量调整为16 当元素个数大于阈值（16*0.75=12）时，会进行扩容，扩容后大小为原来的两倍。目的是减少调整元素的个数 jdk1.8开始，当链表长度大于8时，并且集合元素个数大于等于64时调整成红黑树，目的是提高执行效率 jdk1.8开始，当链表长度小于6时，调整成链表 jdk1.8以前，链表时头插入，jdk1.8以后是尾插入
Hashtable JDK1.0版本，线程安全，运行效率慢；不允许null作为key或是value Properties： Hashtable的子类，要求key和value都是String，通常用于配置文件的读取。
TreeMap 实现了SortedMap接口（是Map的子接口），可以对key自动排序。
Collections工具类
sort（）：升序排列 copy（）：复制 binarySearch（）：二分查找 Collections.binarySearch(list,需要查找的值); reverse（）：反转 shuffle（）：打乱集合中的元素 list转成数组： list.toArray(new Integer[0]); 数组转成集合 Arrays.asList(names); 集合是一个受限集合，不能添加 和
总结
本篇文章就到这里了，希望能给您带来帮助，也希望您能够多多关注的更多内容!
其实每一朵花，都有它自己的生命，
