Java集合框架---Java基础宋红康学习笔记
一、集合框架概述
/*
* 一、集合框架的概述
* 1、集合、数组都是对多个数据进行存储操作的结构，简称java容器
* 说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi,数据库中）
*2.1、数组在存储多个数据方面的特点
* >一旦初始化以后，其长度确定。
* >数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了
* 2.2、数组在存储多个数据方面的缺点
* >一旦初始化以后，长度不可修改
* >数组中提供的方法有限，对于添加、删除、插入数据等等操作，非常不方便，同时效率不高。
* >获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
* >数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足
* */
/*
* 二、集合框架
* -Collection接口：单列集合，用来存储一个一个的对象
* --List接口:存储有序的，可重复的数据 -->"动态"数组
* ---ArrayList LinkedList Vector
* --Set接口：存储无序的、不可重复的数据 -->高中讲的"集合"
* ---HashSet LinkedHashSet TreeSet
* -Map接口：双列集合，用来存储一对一对（key-value）的数据 -->高中函数：y = f(x)
* --HasMap、LinkedHashMap、TreeMap、Hashtable、Properties
* */
public class CollectionTest {
}
二、Collection接口方法
-
添加
- add(Object obj)
- addAll(Collection coll)
-
获取有效元素
- int size()
-
清空集合
- void clear()
-
是否是空集合
- boolean isEmpty()
-
是否包含某个元素
-
boolean contains(Object obj)：是通过元素的equals方法来判断是否
是同一个对象
-
boolean containsAll(Collection c)：也是调用元素的equals方法来比
较的。拿两个集合的元素挨个比较。
-
-
删除
-
boolean remove(Object obj) ：通过元素的equals方法判断是否是
要删除的那个元素。只会删除找到的第一个元素
-
boolean removeAll(Collection coll)：取当前集合的差集
-
-
取两个集合的交集
-
boolean retainAll(Collection c)：把交集的结果存在当前集合中，不
影响c
-
-
集合是否相等
- boolean equals(Object obj)
-
转成对象数组
- Object[] toArray()
-
获取对象的哈希值
- hashCode()
-
遍历
- iterator()：返回迭代器对象，用于集合遍历
三、Iterator迭代器接口
1、迭代器的使用
/*
* 结课元素的遍历操作，使用Iterator接口
* 1、内部的方法：hasNext() 和 next()
* 2、集合对象每次调用iterator()方法都得到一个全新的迭代对象
* */
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("dsad",20));
coll.add(new String("asd"));
coll.add(false);
Iterator iterator = coll.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
2、迭代器中的remove方法
@Test
public void test3(){
Collection coll = new ArrayList();
coll.add("123");
coll.add("456");
coll.add(new Person("dsad",20));
coll.add(new String("asd"));
coll.add(false);
// 删除集合中的 ”Tom“
Iterator iterator = coll.iterator();
while(iterator.hasNext()){
Object next = iterator.next();
if("456".equals(next)){
iterator.remove();
}
}
//遍历集合
Iterator iterator1 = coll.iterator();
while(iterator1.hasNext()){
System.out.println(iterator1.next());
}
}
四、List接口
1、结构概述
- 鉴于java中数组用来存储数据的局限性，我们通常可以使用List代替数组
- List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引
- List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素
- jdk API中的List接口的实现类常用的有：ArrayList,LinkedList，Vector
2、 源码分析
package com.Java集合框架;
/*
* List接口：存储有序的，可重复的数据。
* -ArrayList
* -LinkedList
* -Vector
*
*
* 1、ArrayList,LinkedList,Vector三者的异同
* -同：三个类都实现了List接口，存储数据的特点相同：存储的数据有序，可重复
* -异：ArrayList： 作为List接口的主要实现类；线程不安全的，效率高；底层使用Object数组存储
* LinkedList：对于频繁的插入、删除操作，使用效率比ArrayList高； 底层使用双向链表
* Vector：作为List的古老实现类：线程安全的效率低；底层使用Object数组存储
*
* 2、ArrayList的源码分析：
* 2.1 jdk 7情况下
* -ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
* -list[123];//elementData[0] = new Integer(123);
* ....
* 默认情况下，扩容为原来容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中
*
* 结论：建议开发中使用带参的构造器
*
* 2.2、jdk 8中ArrayList的变化
* ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}，并没有创建长度为10的数组
* list.add(123);//第一次调用add()时，底层才创建了长度为10的数组，并将数据123添加到elementData[0]
* .....
* 后续的添加与扩容操作与jdk 7无异
* 2.3、小结：jdk7中的ArrayList的对象的创建类似与单例的饿汉式，而jdk8中的ArrayList的对象的创建
* 类似于单例的懒汉式，延迟了数组的创建，节省内存
*
* 3、LinkList的源码分析
* LinkedList list = new LinkedList();//内部声明了Node类型的frist和last属性，默认值为null
* list.add(123);//将123封装到Node中，创建了Node对象
*
* .........
*
* 4、Vector源码分析：jdk7和jdk8中通过了Vector()构造器创建对象时，底层都创建了长度为10的数组
* 在扩容方面，默认扩容为原来数组的2倍
*
*
* */
public class ListTest {
}
3、常用方法
- 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(Object obj)
改: set(int index,Object ele)
查: get(int index)
长度: size()
遍历:
- Iterator迭代器方式
- 增强型for循环
- 普通循环
五、set接口
详细可参考 https://www.cnblogs.com/bingyimeiling/p/10255037.html
package com.Java集合框架;
/*
* -Set接口：存储无序的、不可重复的数据
* --HashSet:作为Set接口的主要实现类；线程不安全；可以存储null值
* ---LinkedHashSet:作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历
* --TreeSet:可以按照添加对象的指定属性，进行排序
*
*
*1、Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法
*
* 2、要求：向Set中添加的数据，其所在的类一定要重写hashCode()和equals()
* 要求：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码（哈希值）
* */
public class SetTest {
/*
* 一、set:存储无序的，不可重复的数据
* 以HashSet为例说明
* 1、无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定
*
* 2、不可重复性：保证添加的元素按照equals()判断时，不能返回true：即相同的元素只能添加一个
*
* 二、添加元素的过程：以HashSet为例：
* 我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值
* 此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置，判断数组此位置上是否已经有元素：
* 如果此位置上没有其他元素，则元素a添加成功 --->情况1
* 如果此位置上有其他元素b（或以链表形式存在多个元素），则比较元素a与元素b的hash值
* 如果hash值不相同，则元素a添加成功 --->情况2
* 如果hash值相同，进而需要调用元素a所在类的equals()方法
* equals()返回ture,则元素a添加失败
* equals()返回false，则元素a添加成功。--->情况2
*
* 对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储
* jdk7:元素a方法数组中，指向原来的元素
* jdk8：原来的元素在数组中，指向元素a
*
* HashSet的底层是数组+链表的结构
*
* */
}
1、LinkedHashSet的使用
LinkedHashSet作为HashSet子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据
优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet
2、TreeSet
package com.Java集合框架;
import com.Java常用类.Person;
import org.junit.Test;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class TreeSetTest {
/*
* 1、向TreeSet中添加的数据，要求是相同类的对象
*2、两种排序方式 自然排序(实现Comparable接口) 自定义排序
*
* 3、自然排序中，比较两个对象是否相同的标准为：compareTo()返回0,不再是equals()
*4、定制排序中，比较两个对象是否相同的标准：compara()返回0，不再是equals()
* */
@Test//自然排序 实现Comparable接口
public void test1(){
TreeSet set = new TreeSet();
//失败：不能添加不同类的对象
/* set.add("sad");
set.add(123);
set.add(456);
set.add(new Person("sad", 123));*/
set.add(123);
set.add(456);
set.add(123);
set.add(1723);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
@Test//自制排序
public void test2(){
Comparator com = new Comparator() {
//按照年龄从小到大排序
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Person && o2 instanceof Person){
Person u1 = (Person) o1;
Person u2 = (Person) o2;
return Integer.compare(u1.getAge(),u2.getAge());
}
throw new RuntimeException("参数类型错误");
}
};
/*没有参数按自然排序（实现comparater接口），有参数按参数要求排序*/
TreeSet set = new TreeSet(com);
set.add(new Person("sad", 1234));
set.add(new Person("sasd", 1253));
set.add(new Person("saed", 1213));
set.add(new Person("saad", 1203));
set.add(new Person("safd", 1233));
set.add(new Person("sgad", 1023));
}
}
六、Map接口
package com.Java集合框架;
import org.junit.Test;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
/*一、Map的实现类的结构
* -Map：双列数据，存储kuy-value对的数据 ----类似于高中的函数：y = f(x)
* --HashMap:作为Map的主要实现类；线程不安全的，效率高；存储null的key和value
* ---LinkedHashMap:保证遍历map元素时，可以按照添加的顺序实现遍历
* 原因：在原有的HashMap的底层结构基础上，添加了一对指针，指向前一个和后一个元素
* 对于频繁的遍历操作，此类执行效率高于HashMap。此时考虑key的自然排序或定制排序
* --TreeMap:保证按照添加的key-value对进行排序，实现排序遍历
* 底层使用红黑树（二叉树）
* --HashTable:作为Map的古老实现类；线程安全的，效率低；不能存储null的key和value
* ---Propertise:常用来处理配置文件。key和value都是String类型
*
*
* HashMap的底层：数组+链表（jdk7及之前）
* 数组+链表+红黑树(jdk8)
*
*
* 面试题：
* 1、HashMap的底层实现原理
* 2、HashMap和Hashtable的异同
*
*
*二、Map的结构理解
* Map中的key:无序的、不可重复的，使用Set存储所有的key --->key所在的类重写equals()和hashCode()方法 （以HashMap为例）
* Map中的value：无序的、可重复的，使用Collection存储所有的value --->value所在的类要重写equals()
* 一个键值对：key-value构成了一个Entry对象。
* Map中的entry:无序的、不可重复的，使用Set存储所有的entry
*
* 三、HashMap的底层实现原理？以jdk7为例说明
* HashMap map = new HashMap();
* 在实例化以后,底层创建了长度为16的以为数组Entry[] table。
* ...可能已经执行过多次put...
* map.put(key1,value1)
* 首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置
* 如果此位置上的数据为空，此时的key1-value1添加成功 ---情况一
* 如果此位置上的数据不为空（意味着此位置上存在一个或多个数据（以链表的形式存在）），比较key1和已经存在的一个或多个数据的哈希值
* 如果key1的哈希值与已经存在的数据的哈希值都不相同，此时的key1-value1添加成功 ---情况二
* 如果key1的哈希值和已经存在的某一个数据的哈希值相同，继续比较：调用key1所在类的equals()方法，比较：
* 如果equals()返回false：此时key1-value1添加成功 ---情况三
* 如果equals()返回true：将value替换相同key的value值。
*
* 补充：情况一和情况二：此时key1-value1和原来的数据以链表的方式存储
*
* 在不断的添加的过程中，会涉及到扩容问题，默认的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来
*
* jdk8 相较于jdk7在等层实现方面的不同：
* 1、new HashMap():底层没有创建一个长度为16的数组
* 2、jdk 8底层的数组是：Node[],而非Entry[]
* 3、首次调用put()方法时，底层创建长度为16的数组
* 4、jdk7的曾结构只有：数组+链表。jdk8中底层结构：数组+链表+红黑树
* 当数组的某一个索引位置上的元素一链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，
* 此时此索引上的所有数据改为红黑树存储。
*
*
* 四、LinkedHashMap的底层实现原理（了解）
*
* */
public class MapTest {
@Test
public void test1(){
Map map = new HashMap();
// map = new Hashtable();
map.put(null,null);
}
}
1、Map常用方法
-
添加、删除、修改操作：
-
Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中 void
-
putAll(Map m):将m中的所有key-value对存放到当前map中
-
Object remove(Object key)：移除指定key的key-value对，并返回value
-
void clear()：清空当前map中的所有数据
-
元素查询的操作：
-
Object get(Object key)：获取指定key对应的value
-
boolean containsKey(Object key)：是否包含指定的key
-
boolean containsValue(Object value)：是否包含指定的value
-
int size()：返回map中key-value对的个数
-
boolean isEmpty()：判断当前map是否为空
-
boolean equals(Object obj)：判断当前map和参数对象obj是否相等
-
元视图操作的方法：
-
Set keySet()：返回所有key构成的Set集合
-
Collection values()：返回所有value构成的Collection集合
-
Set entrySet()：返回所有key-value对构成的Set集合
2、TreeMap
public class TreeMapTest {
/*
* 向TreeMap中添加key-value,要求key必须是由同一个类创建的脆响
* 因为要按照key进行排序：自然排序、定制排序
* */
@Test
public void test1(){
TreeMap map = new TreeMap();
Person person1 = new Person("123",113);
Person person2 = new Person("1123",123);
Person person3 = new Person("1223",133);
Person person4 = new Person("1323",143);
Person person5 = new Person("1423",153);
map.put(person1,123);
map.put(person2,1223);
map.put(person3,1233);
map.put(person4,1234);
map.put(person5,1235);
//遍历 自然排序 定制排序
//参照 TreeSet
}
}
3、Properties处理属性文件
public static void main(String[] args) {
FileInputStream fis = null;
try {
Properties properties = new Properties();
fis = new FileInputStream("jdbc.properties");
properties.load(fis);//加载流对应的文件
System.out.println(properties.getProperty("name"));
} catch (IOException e) {
e.printStackTrace();
}finally{
if(fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
4、Collection工具类
public class CollectionsTest {
/*
* Collections:操作Collection、Map的工具类
*
* 面试题：Collection 和 Collections 区别
* */
}
1、常用方法
-
Collection 是一个操作Set、List和Map等集合的工具类
-
Collection中提供了一系列静态方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
-
排序操作（均为static方法）
-
reverse(List)：反转 List 中元素的顺序
-
shuffle(List)：对 List 集合元素进行随机排序
-
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
-
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
-
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
-
-
查找、替换
-
Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
-
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
-
Object min(Collection)
-
Object min(Collection，Comparator)
-
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
-
void copy(List dest,List src)：将src中的内容复制到dest中
-
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换List 对象的所有旧值
-
