JAVA-高级编程-集合
集合
Collection接口；Collection子接口：List接口、Set接口
一、collection常用方法使用
/**
* 一：集合框架的概述
* Collection 单列集合
* List：有序可重复集合
* Set：无序不可重复集合
* Map 双列集合 key-value
*
* 1.集合、数组都是对多个数据进行存储操作的结构，简称java容器
* 说明：此时的存储指的是内存层面的存储，不涉及到持久化的存储
* 2.数组在存储多个数据方面的特点：
* >一旦初始化以后长度就确定了
* >存储数据类型必须一致
*
*
* 二：集合框架
* Collection接口：单列集合，用来存储一个一个的对象
* List接口：存储有序可重复数据
* ArrayList
* LinkedList
* Vector
* Set接口：存储无序不可重复的数据
* HashSet
* TreeSet
* Map接口：双列集合，用来存储一对数据key-value
* HashMap
* LinkedHashMap
* TreeMap
* Hashtable
* Properties
*
*
* 三、Collection接口中的方法使用
*
*
* @author from z
* @create 2021-02-05 22:09
*/
public class CollectionTest {
/**
* collection常用的方法
*/
@Test
public void test(){
Collection coll=new ArrayList();
//add(Object o)将元素添加到集合中
coll.add("aa");
coll.add("bb");
coll.add(123);
coll.add("aa");
//size()//获取添加的元素的个数
System.out.println(coll.size());
//addAll(Collection c)将coll2中的元素添加到当前的集合中
Collection coll2=new ArrayList();
coll2.add(1);
coll2.addAll(coll);
//clear()清空集合元素，并不是释放对象
coll2.clear();
//isEmpty()判断当前集合是否为空
System.out.println(coll2.isEmpty());
//contains(Object obj)判断当前集合中是否存在obj
//判断时会调用obj对象所在类的equals，向Collection接口对象中传数据时要求对象所在类重写equals
boolean b=coll.contains(123);
//containsAll(Collection coll)判断形参中的所有元素是否都存在当前集合中，并不是全部相等
boolean b2=coll.containsAll(coll2);
//remove(Object o)首先寻找相同对象 找到之后移除 也会调用equals比较
boolean b3=coll.remove(123);
//removeAll()//移除相同的集合元素 差集 修改当前集合
coll.removeAll(coll2);
//retainAll()获取当前集合和比较集合的交集，修改当前集合
coll.retainAll(coll2);
//equals()//因为coll的对象是有序的所以如果coll2的顺序不同也会false
coll.equals(coll2);
//hashCode()//返回当前对象的hash值
coll.hashCode();
//toArray()
Object[] objects = coll.toArray();
//数组转换集合
ListIterator 迭代器
public class IteratorTest {
/**
* 遍历接口一般使用迭代器
* 用hasNext和next方法配合使用
*
* 集合对象每次调用iterator方法都会得到一个全新的迭代器，默认游标都在集合的第一个元素前
*
* 内部定义了remove方法，可以在遍历的时候删除集合中的元素。此方法不同于集合直接调用remove
*/
@Test
public void test(){
Collection collection=new ArrayList();
collection.add(123);
collection.add("zzz");
Iterator iterator = collection.iterator();
System.out.println(iterator.next());//123
System.out.println(iterator.next());//"zzz"
System.out.println(iterator.next());//报异常：超出范围
for (int i=0;iforeach
/**
* jdk5.0新增了foreach循环
*/
@Test
public void test3(){
Collection coll=new ArrayList();
coll.add(123);
//循环输出集合元素
//内部仍然调用了迭代器
for (Object o:coll) {
System.out.println(o);
}
}
源码分析
/**
* Collection接口：单列集合，用来存储一个一个的对象
* List接口：有序可重复接口 ”动态数组“ ---替换原有数组
* ArrayList：List接口的主要实现类，线程不安全 效率高；底层使用Object数组存储
* Vector：List接口的古老实现类，线程安全 效率低；底层使用Object数组存储
* LinkedList：底层使用双向链表存储，对于频繁插入删除操作比arraylist效率高
* Set接口：无序不可重复接口
*
* ArrayList、Vector、LinkedList异同：
* 三个类都实现了List接口 有序 可重复
* 不同：
*/
/**
* ArrayList源码分析：jdk7.0
* ArrayList list=new ArrayList();//底层创建了一个长度为10的Object数组elementData
* list.add(123);//elementData=new Integer(123);
* --list.add(11);//如果此次添加导致数组容量不够，则进行扩容，扩容容量为1.5倍，同时将原来的数组复制到新的数组
* 建议开发中使用 new ArrayList(int capacity);直接指定数组容量
*
* ArrayList源码分析：jdk8.0
* new ArrayList();//底层并没有直接创建object数组，而是传入一个空数组{}
* add();//第一次调用此方法会创建一个初始长度为10并将数据添加到存储数组中
* 后续扩容添加操作与7相同
*
* LinkedList源码分析：
* LinkedList list=new LinkedList();内部声明了Node类型的first和last属性，默认值为null
* list.add(123);//将123封装到Node中，创建了Node对象
* 不需要扩容
*
*
*/
详细源码自行查找
list常用方法
/**
* list接口常用方法
*/
@Test
public void test(){
List list=new ArrayList();
//void add(int index,Object object)在index位置插入obj元素
list.add("abc");
list.add(1,"aa");
//boolean addAll(int index,Collection coll);从index位置开始将coll中的所有元素添加到集合中
list.addAll(1,list);
//Object get(index i)获取指定位置的元素
Object o = list.get(2);
//int indexOf(Object o)返回obj在当前集合的位置
list.indexOf("aa");//如果不存在返回-1
//int lastIndexOf(Object obj)返回obj在当前集合中末次出现的位置
list.lastIndexOf("aa");
//Object remove(int index)移除指定index位置的元素并返回此元素
list.remove(1);
//Object set(int index,Object o)设置指定位置的元素为o
list.set(1,123);
//List subList(int fromIndex,int toIndex)返回从fromIndex到toIndex位置的子集合
list.subList(1,2);
}
Set
public class SetTest {
/**
* Set接口的框架
* Collection接口：单列集合，用来存储一个一个的对象
* Set接口：无序不可重复的接口
* HashSet:作为set接口主要的实现类：线程不安全可以存储null
* (HashSet子类)LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历
* TreeSet：可以按照添加对象的指定属性进行排序
*
* 1.set接口没有新的方法 继承于collection
*
*
* 2.set：存储无序的不可重复的数据
* 以HashSet为例
* 无序性：不等于随机性，存储的数据在底层数组中并非按照数组索引的顺序添加，根据数据的hash值确定的
* 不可重复性：保证添加到元素按照equals方法判断时不能返回true，相同元素只能添加一个
*/
/**
* LinkedHashSet使用
* linkedhashset作为hashset的子类再添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据
* 对于频繁的遍历操作linkedhashset优于hashset
*/
@Test
public void test(){
/**
* TreeSet
* 向treeset中添加的数据，要求是相同类的对象
* 底层comparTo方法进行比较排序
*/
//treeset定制排序
TreeSet t=new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return 0;
}
});
}
}
Map接口
hashmap
/**
* Map：双列数据，存储key-value对的数据，
* HashMap：map主要实现类，线程不安全效率高，可以存储null的key和value
* LinkedHashMap:保证遍历map元素时，可以按照添加顺序遍历
* 原因：在原有的hashmap底层结构上添加了一对指针，指向前一个和后一个元素
* 对于频繁的遍历操作，此类的执行效率高
* TreeMap：保证按照添加的key-value进行排序实现遍历，此时考虑key的定制排序或自然排序
* Hashtable：古老实现类，线程安全效率低，不能存储null的key和value
* Properties：常用来处理配置文件。key-value都是string类型
*
* hashmap的底层：数组+链表 jdk7
* 素组+链表+红黑树 jdk'8
*
*
* 1.hashmap底层实现原理
*
* 2.hashmap和hashtable异同
*
*3.CurrentHashtable与hashtable区别（高级部分自行搜索）
*
* Map结构的理解
* map中的key是无序的不可重复的 使用set存储所有的key key所在的类要重写equals和hashcode方法 hashmap为例
* map中的value是可重复的无序的，使用collection存储所有value，所在类要重写equals
* 一个键值对：key-value构成了一个entry对象
* map中的entry：无序的不可重复的使用set存储所有的entry
*
* hashmap底层实现原理
* jdk7：new map() 实例化以后底层创建了一个 长度为16的Entry[] table 数组
* put(key,value)put方法会调用key的hashcode方法计算key的哈希值通过算法获取key在数组中的存放位置
* 此时如果此位置为空直接i添加成功
* 如果不为空，会调用key的equals方法来判断比较一个或多个数据(链表数据)
* 如果equals返回false则添加成功
* 如果equals返回true则替换key的value值
*
* 添加过程中会有扩容：默认扩容为原来的2倍，并将原有的数据赋值过来
* jdk8相较于7的不同
* new hashmap()底层没有创建一个长度为16的数组
* 底层数组是Node[]
* 首次调用put方法时才会创建长度为16的数组
* jdk7只有数组+链表
* jdk8 数组+链表+红黑树 当数组某一个索引位置上的元素以链表形式存在的数据个数>8且当前数组的长度>64
* 此时此索引位置上的所有数据改为使用红黑树存储
*
*/
map常用方法
/**
* map常用方法
* put(object key,object value):将指定的键值对放入map
* putAll(Map m):将m中所有的键值对存放到当前map中
* remove(object key):移除指定key的key-value
* clear():清空当前map中的所有数据
* get(Object key):获取指定key对应的value
* containsKey(Object key):是否包含指定的key
* containsValue(Object value):是否包含指定的value
* size():返回map的存储key个数
* isEmpty():判断map是否为空
* equals(Object o):判断当前map和参数对象obj是否相等
*
* keySet():返回所有key的构成的set集合
* values():返回所有的value构成的Collection集合
* entrySet()：返回所有entry构成的set集合
*/
@Test
public void test(){
Map map=new HashMap();
map.put("A",123);
map.put("A",456);//修改原来key=A的值为456
map.clear();//并不会给map=null，而是仅仅清空数据
Set set = map.entrySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()){
Object next = iterator.next();
Map.Entry entry=(Map.Entry)next;
System.out.println(entry.getKey());
System.out.println(entry.getValue());
}
}
treemap
/**
*向treemap中添加key-value要求key必须是由同一个类创建的对象
* 因为要按照key进行排序：自然排序，定制排序
*
*/
@Test
public void test2(){
TreeMap treeMap=new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof String && o2 instanceof String){
String o22 = (String) o2;
String o11=(String) o1;
return o11.compareTo(o22);
}
throw new RuntimeException();
}
});
treeMap.put("aaa",123);
treeMap.put("d",123);
treeMap.put("bbb",1324);
treeMap.put("a",1324);
Set set = treeMap.entrySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()){
Object next = iterator.next();
Map.Entry entry=(Map.Entry)next;
System.out.println(entry.getKey());
// System.out.println(entry.getValue());
}
}
/**
*Properties:常用来处理配置文件。key和value都是String类型
*/
collections常用方法(工具类)
/**
* Collections:操作Collection和Map的工具类
* reverse(List):反转list中元素的顺序
* shuffle(List):对list集合元素进行随机排序
* sort(List):根据元素的自然顺序对指定的list集合进行升序排序
* sort(List,comparator):根据指定的comparator产生的顺序对list进行集合排序
* swap(List,int,int):将指定list集合中的i处元素和j处元素进行交换
* max(Collection):根据元素的自然顺序，返回给定集合中的最大元素
* max(Collection,comparator)根据comparator指定的顺序，将集合中最大的元素返回
* min(Collection)
* min(Collection,comparator)
* frequency(Collection,Object):返回指定集合中指定元素的出现次数
* copy(List,list):将list中的内容复制到List中
* replaceAll(List,Object,Object new):使用新值替换list中的旧值
*
* Collections提供了多个synchronizedXxx()方法，该方法
* 可使将指定集合包装成线程同步的集合，从而可以解决多线程并发
* 访问集合时的线程安全问题
*/
public class CollectionsTest {
@Test
public void test(){
List list=new ArrayList();
list.add(123);
list.add(123);
List list1;
//Collections.copy(list1,list);//此时写法是错误的，copy会比较两个集合的size 如果list1.size