Java集合框架
集合
- 概念:对象的容器,定义了对多个对象进行操作的常用方法。可实现数组的功能。
-
集合和数组的区别:
- 数组长度固定,集合长度不固定
- 数组可以存储基本类型和引用类型,集合只能存储引用类型。
测试
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
/* 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接口
特点:有序、有下标、元素可以重复。
可以通过角标在指定位置添加查询元素。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
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。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
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 实际元素个数
测试代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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版本出现,运行效率慢、线程安全;
- 枚举器遍历
1
2
3
4
5
6
7
8
9
10
|
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,则拒绝后者存入。否则,则生成链表。
1
2
3
|
public HashSet(){ map = new HashMap<>(); } |
测试代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
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集合实现字符串按照长度进行排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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键值对集合。
测试代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
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个位置是进行扩容操作。
- 源码分析
1
2
3
4
5
6
7
|
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4 ; // hashMap初始容量大小16 static 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);
- 集合是一个受限集合,不能添加 和
总结
本篇文章就到这里了,希望能给您带来帮助,也希望您能够多多关注服务器之家的更多内容!
原文链接:https://www.cnblogs.com/wkf123/p/14966681.html