集合、数组都是对多个数据进行存储操作(主要是内存层面存储)的结构，简称Java容器。
数组的特点
1.数组初始化以后，长度确定不可变
2.数组定义好，其元素的类型确定不可变(可能有多态性)
3.数组中提供的方法有限，对于添加、删除、插入数据等操作不方便。
4.获取数组中实际元素的个数是没有办法的。
5.数组存储数据的特点是有序、可重复的。
Java集合可分为Collection和Map两种体系,集合存储的优点是解决数组存储数据方面的弊端。
-
Collection接口：单列数据，用来存储一个一个的对象
- List接口:元素有序，可重复的集合 --> '动态'数组
- Set接口 :元素无序、不可重复的集合
- Map接口：双列数据，保存有映射关系(键值对)的集合
Collection接口
向collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals方法。
Abstract Methods
add(Object e):将元素e添加到集合中
size():获取添加的元素个数
addAll(Collection coll):将形参coll集合的元素添加到当前集合中
clear():清空集合元素,集合仍然存在，只是集合里没有元素
isEmpty():判断当前集合是否为空
contains(Object obj):判断当前集合中是否包含obj，是否包含是通过调用obj的equals判断
containsAll(Collection coll):判断形参coll中的所有元素是否都存在当前集合中。
remove(Object obj):移除某个元素，同样通过equals寻找移除的元素
removeAll(Collection coll):从当前集合中移除coll集合中所有的元素，需要调用equals函数
retainAll(Collection coll):求两个集合的交集,结果为修改当前集合后的集合。
equals(Collection coll):比较两个集合是否一样。
hashCode():返回当前对象的哈希值
集合的遍历:iterator 接口
集合元素的遍历操作:Iterator迭代器接口。只能遍历集合Collection,map不行
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
Iterator <E> iterator = coll.iterator();//方式一：通过iterator.next()获得集合元素iterator.next();//方式二：循环,不推荐for(int i =0;i<coll.size;i++){ iterator.next();}//方式三：推荐!//hasNext():判断是否还有下一个元素while(iterator.hasNext()){ //next():①指针下移 ②将下移以后集合位置上的元素返回 Object obj = iterator.next(); if("Tom".equals(obj)){ //iterator中的remove(),删除集合中的元素 iterator.remove() }}//方法引用，Java8新特性coll.forEach(System.out::println) |
集合的遍历:增强for循环
增强for循环用于遍历数组和集合(colleciton)
格式:集合元素的类型 局部变量:集合
|
1
2
3
4
|
//第一个位置，是当前的元素//第二个位置，是遍历的对象//集合元素的类型 局部变量 ：集合for(Object obj : coll){} |
面试题
知识点：增强for只能遍历不能赋值
集合元素的类型 局部变量:集合
相当于从集合中取出赋值给局部变量，集合本身是没有修改的。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
String [] arr = new String[]{"ranan","ranan"}//普通for循环for(int i=0;i<arr.length;i++){ arr[i] = "xx"}for(int i=0;i<arr.length;i++){ System.out.println(arr[i]); //输出"xx"}//增强for循环for(String s:arr){ //这里的s是局部变量，相当与取出arr[i]的值赋值给了变量s，改变的是s的值 s = "xx";}for(int i=0;i<arr.length;i++){ System.out.println(arr[i]); //输出"ranan"} |
List接口
比较ArrayList、LinkedList、Vector的异同
同：三各类都实现了List接口，存储数据的特点相同：存储有序的、可重复异：
- ArrayList:List接口的主要实现类，线程不安全、效率高，底层使用Object[]存储，默认扩容为原数组的1.5倍
- LinkedList:底层使用双向链表存储，对于频繁的插入、删除操作效率更高
- Vector:List接口的古老实现类，线程安全、效率低，底层使用Object[]存储，默认长度为10。默认扩容为原数组的2倍
ArrayList
JDK7
|
1
2
3
4
|
//底层创建了长度是10的object[]数组ArrayList <Integer> list = new ArrayList<Integer>();//一般扩容原来的一半，将原数组元素复制到新数组List add(123) //底层使用Object[]数组存储，elementData[0]= new Integer(123)ArrayList list = new ArrayList(数字) |
结论：建议开发中使用带参的构造器
JDK8
|
1
|
ArrayList list = new ArrayList() //底层的object[] elementData初始化为{},并没有创建长度为10的数组 |
懒汉式，底层的object[] elementData初始化为{},并没有创建长度为10的数组,第一次调用add方法时才new创建好数组。后续的添加和扩容操作与jdk7中一样。
区别:JDK7中的ArrayList对象的创建类似于单例的饿汉式，而JDK8中的类似于单例的懒汉式，延迟了数组的创建，节省内存
LinkedList
|
1
|
LinkedList = new LinkedList()//内部声明了Node类型的first与last，值为null |
removeLast():移除最后一个元素
List的常用方法
List集合添加了一些根据索引来操作集合元素的方法，因为List是有序的
void add(int index,Object ele):在index位置插入ele元素
boolean addAll(int index,Collection eles):从index位置开始依次插入eles中的所有元素
Object get(int index):获取指定index位置的元素
int indexOf(Object obj):返回obj在集合中首次出现的位置
int LastIndexOf(Object obj):返回obj在集合中最后一次出现的位置
Object remove(int index):移除指定index位置的元素，并返回此元素
Object set(int index,Object ele):设置指定index位置的元素为ele
List subList(int fromIndex,int toIndex):返回从fromIndex到toIndex位置的子集合
常用方法
增：add(Object obj)
删：remove(int index)/remove(Obejct obj)
改：set(int index,Object ele)
查：get(int index)
插：add(int index,Object ele)
长度：size()
遍历：Iterator迭代器方法/增强for循环/普通的循环
集合与数组的转换
集合转换成数组 --> coll.toArray()
数组转换成List --> Arrays.asList(new String[]{'AA','BB','CC'})
使用场景:生成一个不可更改的list
Arrays.asList
1.该方法适用于对象型数据的数组（String、Integer...）
2.该方法不建议使用于基本数据类型的数组（byte,short,int,long,float,double,boolean）
3.该方法将数组与List列表链接起来：当更新其一个时，另一个自动更新
4.不支持add()、remove()、clear()等方法。用此方法得到的List的长度是不可改变的
List arr = Arrays.asList(new int[]{123,456})会把new int[]{123,456}整体看成一个元素,基本数据类型数组会被看成一个整体。可以写成 List arr = Arrays.asList(123,456)
Set接口
Set接口中没有额外定义新的方法。
比较HashSet、LinkedHashSet、TreeSet
同：都是Set接口的实现类，存放数据无序、不可重复
HashSet:Set接口的主要实现类，线程不安全，可以存放null值，数组+链表存储数据
LinkedHashSet：HashSet的子类，遍历其内部数据时可以按照添加的顺序遍历，对于频繁的遍历操作,LinkedHashSet效率高于HashSet
TreeSet:数据是同一类的，可以按照添加对象的指定属性，进行排序。
无序性与不可重复性
无序性：不等于随机性，存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的hash值决定。(数组中的存储不是按照添加顺序添加的)
不可重复性:先比较添加元素的hash值是否相同，相同按照equals()判断是否重复
HashSet中元素的添加过程
向HashSet中添加元素a
1.先调用元素a所在类的hashCode()方法，计算a的哈希值。
2.此hash值通过散列函数计算出在HashSet底层数组中的存放位置 + 拉链法解决冲突
散列函数 + 拉链法解决冲突 拉链法时要先比较hash值再按照equals()判断是否重复，不重复时再链上
要求：向Set中添加的数据，其所在类的一定要重写HashCode方法和equals方法，此两个方法尽可能保持一致性。(相等的对象必须具有相同的hash值)
注意：
new HashSet()实际上是new了一个HashMap，向HashSet添加元素实际上是向HashMap添加元素,在HashSet中添加的元素相当于是HashMap的key，value都指向一个对象(这个对象没什么意义)
LinkedHashSet
LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用指针，遍历其内部数据时可以按照添加的顺序遍历
TreeSet
要求：向TreeSet中添加的数据，要求是相同类的对象作用：进行排序
遍历的时候会调用排序方法进行自动排序。
自然排序(Comparable接口)：比较两个对象是否相同的标准为:compareTo()返回0,不再是equals()
定制排序(Comparator接口)：比较两个对象是否相同的标准为:compare()返回0，不再是equals()
|
1
2
3
4
5
6
|
Comparator com = new Comparator(){ //定制排序内容 @override public int compare(Object o1,Object o2){}}TreeSet set = new TreeSet(com) |
练习题
1.在List内去除重复数字值,要求尽量简单
HashSet常常用于过滤重复元素 --> set.addAll(list) --> return new ArrayList(set)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
//Person类中重写了hashCode()和equals()方法HashSet set = new HashSet();Person p1 = new Person(1001,"AA");Person p2 = new Person(1002,"BB");set.add(p1);set.add(p2);p1.name = "CC";set.remove(p1);//remove时先计算hash值(此题由id和name共同计算所得),内容变了hash值也变了System.out.println(set);//1001,"CC" 1002,"BB"set.add(new Person(1001,"CC"));//原来的p1的hash值是按照1001,"AA"计算所得，此时算出来的应该是新的hash值System.out.println(set);//1001,"CC" 1002,"BB" 1001,"CC"set.add(new Person(1001,"AA")); //这里算出来是p1的hash值，hash值相同调用equals方法发现不同System.out.println(set);//1001,"CC" 1002,"BB" 1001,"CC" 1001,"AA" |
Map接口
Map实现类的结构
HashMap:作为Map的主要实现类，线程不安全，效率高。可以存储key/value = null
LinkedHashMap:在遍历map元素时，可以按照添加的顺序实现遍历。原因：在原有的HashMap底层结构基础上添加了一对指针，指向前一个和后一个元素。对于频繁的遍历操作,LinkedHashMap效率高于HashMap
TreeMap:保证按照添加的key-value对进行排序(key)，实现排序遍历，底层使用红黑树
Hashtable:作为古老实现类，线程安全，效率低,不可以存储key/value = null
Properties:常用来处理配置文件,key-value都是String类型
Entry(key,value)无序,不可重复(Set)
key无序,不可重复,用set存储。 --> 不可重复，key所在的类要重写quals()和hashCode() (HashMap为例)
value无序，可重复 --> value所在的类要重写equals,重写是为了实现通过value找到key的方法
Map中的常用方法
增删改
Object put(Object ket,Object value):将指定key-value添加到(或修改key的值)当前map对象
void putAll(Map m):将m中的所有key-value对存放在当前map中
Object remove(Object key):移除指定key的key-value对,并返回value
void clear():清空当前的map中的数据,map还在，只是里面没数据了。map.size()不会报错
查
Object get(Object key):获取指定key对用的value
boolean containsKey(Object key):是否包含指定的key
boolean containsValue(Object key):是否包含指定的key
int size():返回map中键值对的个数
boolean isEmpty():判断当前map是否为空
boolean equals(Object obj):判断当前map和参数对象obj是否相等
遍历
Set keySet():返回所有key构成的Set集合
Collection values():返回所有value构成的Collection集合
Set entrySet():返回所有key-value对构成的Set集合,Set<Map.Entry<Character,Integer>> entry = map.entetSet()
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
//返回的是Collection之后就可以使用iterator迭代器Set set = map.keySet();Iterator iterator = set.iterator();//遍历所有的key-valueSet entrySet = map.entrySet()Iterator iterator = entrySet.iterator();while(iterator.hasNext()){ Object obj = iterator.next(); Map.Entry entry = (Map.Entry) obj; System.out.println(entry.getKey()+"--->"+entry.getValue());}//写法二Set <Map.Entry<String,Integer>> entrySet = map.entrySet();Iterator <Map.Entry<String,Integer>> iterator = entrySet.iterator();while(iterator.hasNext()){ Map.Entry <String,Integer> entry = iterator.next(); String key = entry.getKey(); Integer value = entry.getValue();} |
HashMap
问题1：HashMap的底层实现原理?
JDK7:
|
1
2
3
4
|
//在实例化以后，底层创建了长度16的一维数组Entry[] tableHashMap<E,E> map = new HashMap<E,E>();//...可能已经执行过多次put...map.put(key1,value); |
往map中添加键值对的过程
- 调用key1所在类的hashCode()计算key1哈希值，得到在Entry中的存放位置
-
检查该位置是否有数据
- 没有数据，此时key1-value1添加成功
- 有数据，比较key1和已存在的数据的哈希值
- 如果哈希值一样，调用equals()方法，不相等则添加成功，相等用新的value替换旧的value。put有更新作用
- 如果哈希值不一样，则添加成功
在不断的添加过程中，默认的扩容方式:扩容为原有容量的2倍，并将原有的数据复制。
JDK8相较于JDK7的不同点(类似ArrayList)
1.new HashMap():底层没有创建一个长度为16的数组
2.首次调用put()方法时，底层创建长度为16的数组
3.jdk8 底层的数组是:Node[]
4.链表插入的方法(七上八下)
5.jdk7底层结构:数组+链表。jdk8中底层结构:数组+链表+红黑树。
当数组的某一个索引位置上的元素以链表形式存在的数据个数>8且当前数组的长度>64(若>8但是<64则扩容),此时该索引位置上的所有数据使用红黑树存储，
问题2:负载(加载)因子值的大小,对HashMap有什么影响?
HashMap的默认容量16
HashMao的默认加载因子0.75
threshold扩容的临界值=容量*填充因子=16 x 0.75=15
负载因子的大小决定了HashMap的数据密度
负载因子越大密度越大，发生碰撞的几率越高，性能会下降
负载因子越小，越容易触发扩容,会浪费空间
LinkedHashMap
LinkedHashMap是HashMap的子类，底层还是按照HashMap去存。
类似LinkedHashSet,在遍历map元素时，可以按照添加的顺序实现遍历。
LinkedHashMap中的内部类多了befor和after指针
TreeMap
要求：向TreeMap中添加key-value,要求key必须是由同一个类创建的对象
排序：按照key进行排序
自然排序(Comparable接口)：
比较两个对象是否相同的标准为:compareTo()返回0,不再是equals()
定制排序(Comparator接口)：
比较两个对象是否相同的标准为:compare()返回0，不再是equals()
|
1
2
3
4
5
6
7
8
9
10
|
//自然TreeMap map = new TreeMap();//添加的key类里重写compareTo()//定制Comparator com = new Comparator(){ //定制排序内容 @override public int compare(Object o1,Object o2){}}TreeMap map = new TreeMap(com) |
Properties
c类是Hashtable的子类，该对象用于处理属性文件。
由于属性文件里的key-value都是字符串类型，所以Properties里的key和value都是字符串类型。
存储数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法
需要在当前项目中添加配置文件，File(手动添加后缀.properties)/Resource Bundle(自动添加后缀)
|
1
2
3
4
5
|
Properties pros = new Properties();FileInputStream fis = new FileInputStream("配置文件的名字")//参数为流，加载流对用的文件pros.load(fis);fis.close(); |
Collections工具类
Collections是一个操作Set、List和Map等集合的工具类。
Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作,还提供了对集合对象设置不可变，对集合对象实现同步控制等方法
排序方法
reverse(List):反转List中元素的顺序
shuffle(List):对List集合元素进行随机排序
sort(List):根据元素的自然顺序对指定list集合元素按升序排序
sort(List,Comparator):根据指定的Comparator产生的顺序对List集合元素进行排序
swap(List,int,int):将指定list集合中的i处元素和j处元素进行交换
Object max/min(Collection):根据元素的自然排序，返回给定集合中的最大/最小元素
Object max/min(Collection,Comparator):根据Comparator指定的顺序,返回集合中的最大/最小元素
int frequency(Collection,Object):返回指定集合中指定元素出现的次数
void copy(List dest,List src):将src中的内容复制到dest中
boolean replaceAll(List list,Object oldVal,Objec newVal):把List中所有的旧值改成新值
copy的注意事项
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
//************错误写法1//错误原因:需要满足src.size()<= dest.size(),否则会报错List dest = new ArrayList();//...一堆list.add()List dest = new ArrayList();Collections.copy(dest,list);//************错误写法2//错误原因:传参是指定造底层数组的长度,需要的dest.size是填了几个List dest = new ArrayList();//...一堆list.add()List dest = new ArrayList(list.size());Collections.copy(dest,list);//************正确写法List dest = new ArrayList();//...一堆list.add()//asList数组转化成List,这里的数组会默认填充nullList dest = Arrays.asList(new Object[list.size()])Collections.copy(dest,list); |
Collections常用方法:同步控制
Collections类中提供了多个synchronizedXxx(xxx)方法，将指定集合包装成线程同步的集合，从而解决多线程并发访问集合时的线程安全问题。
ArrayList和HashMap都是线程不安全的,如果要求线程安全可以使用synchronizedList(List list)和synchronizedMap(Map map)
|
1
2
|
//返回的List1为线程安全的ListList list1 = Collections.synchronizedLisd(list); |
总结
本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注服务器之家的更多内容！
原文链接：https://www.cnblogs.com/rananie/p/14902612.html
