【备战秋招】JAVA集合

集合

前言

一方面, 面向对象语言对事物的体现都是以对象的形式,为了方便对多个对象 的操作,就要 对对象进行存储。

另一方面,使用Array存储对象方面具有一些弊端,而Java 集合就像一种容器,可以动态地把多个对象的引用放入容器中。

数组在内存存储方面的特点:

  • 数组初始化以后,长度就确定了。 String arr[];
  • 数组声明的类型,就决定了进行元素初始化时的类型

数组在存储数据方面的弊端:

  • 数组初始化以后,长度就不可变了,不便于扩展
  • 数组中提供的属性和方法少,不便于进行添加、删除、插入等操作,且效率不高。 同时无法直接获取存储元素的个数
  • 数组存储的数据是有序的、可以重复的。---->存储数据的特点单一

综上所诉,引入java集合类的必要性

  • Java 集合类可以用于存储数量不等的多个对象,还可用于保存具有映射关系的关联数组。

【备战秋招】JAVA集合_第1张图片

集合类概述

java 集合可分为 Collection 和 Map 两种体系

Collection接口:单列数据,定义了存取一组对象的方法的集合

  • List:元素有序、可重复的集合 -------“动态数组” |- ArrayList …LinkedList Vector
  • Set:元素无序、不可重复的集合 |-HashSet … LinkedHashSet …TreeSet

【备战秋招】JAVA集合_第2张图片

Map接口:双列数据,保存具有映射关系“key-value对”的集合

  • |-HashMap…Properties…LinkedHashMap…TreeMap

【备战秋招】JAVA集合_第3张图片

Collection接口

1、添加 add(Object obj) addAll(Collection coll)

2、获取有效元素的个数 int size()

3、清空集合 void clear()

4、是否是空集合 boolean isEmpty()

5、是否包含某个元素 boolean contains(Object obj):是通过元素的equals方法来判断是否 是同一个对象 boolean containsAll(Collection c):也是调用元素的equals方法来比 较的。拿两个集合的元素挨个比较。

6、删除 boolean remove(Object obj) :通过元素的equals方法判断是否是 要删除的那个元素。只会删除找到的第一个元素 boolean removeAll(Collection coll):取当前集合的差集

7、取两个集合的交集 boolean retainAll(Collection c):把交集的结果存在当前集合中,不影响c

8、集合是否相等 boolean equals(Object obj)

9、转成对象数组 Object[] toArray() 数组->集合 Arrays.asList()

10、获取集合对象的哈希值 hashCode()

11、遍历  iterator():返回迭代器对象,用于集合遍历、

添加类时,重写类的equals方法

Collection coll=new ArrayList();

//add(Obeject e) :将元素添加到集合roll
//添加类时,重写类的equals方法
coll.add(new Persion(22,"YQQ"));
coll.add("aa");
coll.add("bb");
coll.add(123);
coll.add(new Date());
coll.add(new String("Tom"));


//size():获取元素长度
System.out.println(coll.size());


//addAll() 将集合coll_1中的元素添加到coll
Collection coll_1=new ArrayList();

coll.addAll(coll_1);
System.out.println(coll);


//contains(Object e):查看是否包含 e
//调用时 会调用obj对象的equals方法
System.out.println("Tom");
System.out.println(coll.contains(new String("Tom")));
System.out.println("YYQ");
//调用Persion中的equals方法来比较coll里面有没有
System.out.println(coll.contains(new Persion(22, "YQQ")));

//containsAll(Collectin coll)判断形参coll1中的所有元素是否都存在于当前集合中
Collection coll_2 = Arrays.asList(123,456);
System.out.println("containsAll:"+coll.containsAll(coll_2));

//remove(Object obj:移除数据
// 仍要重写equals方法 同样调用该对象的equals()方法
System.out.println("remove:"+coll.remove(new Persion(22, "YQQ")));

//removeAll(Collection coll) :移除coll中的所有元素(交集),去除共有元素
coll.removeAll(coll_2);
System.out.println("removeAll"+coll);

//retainAll(Collection coll)获取当前集合和coll的交集,结果返回为当前集合
coll.retainAll(coll_2);

//equals(Object obj):要想返回ture 当前对象和形参对象集合的元素都想同
// ArrayList有序的 顺序不一样也是false
coll.equals(coll_1);

//hashcode():返回当前对象的hash值
System.out.println(coll.hashCode());

//集合->数组 toArray()
Object[] objects = coll.toArray();
for (int i = 0; i < objects.length; i++) {
System.out.println(objects[i]);
}
//扩展 数组到集合 Arrays.asList Arrays类的静态方法
List<String> list = Arrays.asList(new String[]{"AAA", "BBB", "CCC"});
System.out.println(list);

//iterator():返回iterator接口的实例,用于遍历集合元素



//clear():清空集合
coll.clear();

//isEmpty():查看集合是否为空
System.out.println(coll.isEmpty());

【备战秋招】JAVA集合_第4张图片

迭代器iterator

Iterator对象称为迭代器(设计模式的一种),主要用于遍历 Collection 集合中的元素。

GOF给迭代器模式的定义为:提供一种方法访问一个容器(container)对象中各个元 素,而又不需暴露该对象的内部细节。迭代器模式,就是为容器而生。类似于“公交车上的售票员”、“火车上的乘务员”、“空姐”。

Collection接口继承了java.lang.Iterable接口,该接口有一个iterator()方法,那么所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了 Iterator接口的对象。

Iterator 仅用于遍历集合,Iterator 本身并不提供承装对象的能力。如果需要创建 Iterator 对象,则必须有一个被迭代的集合。 集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合 的第一个元素之前。

【备战秋招】JAVA集合_第5张图片

【备战秋招】JAVA集合_第6张图片

//迭代器接口 iterator ->遍历集合
//此处是利用多态 查看collection的方法,左边编译,右边运行
Collection coll=new ArrayList();

//add(Obeject e) :将元素添加到集合roll
//添加类时,重写类的equals方法
coll.add(new Persion(22,"YQQ"));
coll.add("aa");
coll.add("bb");
coll.add(123);
coll.add(new Date());
coll.add(new String("Tom"));

Iterator iterator= coll.iterator();
// //方式一
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// //方式二
// for (int i = 0; i < coll.size(); i++) {
// System.out.println(iterator.next());
// }

//方式三 在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用,且
//下一条记录无效,直接调用it.next()会抛出NoSuchElementException异常。
while (iterator.hasNext()){
System.out.println(iterator.next());
}


}

//删除集合中Tom对象 
Iterator iterator = coll.iterator();
while(iterator.hasNext()){
        Object obj=iterator.next();
        if(obj.equals("Tom")) //指针指向这个数据
            iterator.remove();
            }
Iterator iterator_1 = coll.iterator();
while(iterator_1.hasNext()){
        System.out.println("第二次"+iterator_1.next());
}

增强for循环

【备战秋招】JAVA集合_第7张图片

Collection子接口: List接口

Image

鉴于Java中数组用来存储数据的局限性,我们通常使用List替代数组

List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引。

List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据 序号存取容器中的元素。

JDK API中List接口的实现类常用的有:ArrayList、LinkedList和Vector。

  • 同: 三个接口都是实现了List接口,储存数据的特点相同:存储有序,可重复的数据
  • 不同: Vector 古老的接口 List

ArrayList 源码分析

【备战秋招】JAVA集合_第8张图片

【备战秋招】JAVA集合_第9张图片

LinkList源码分析

体现了双向链表

【备战秋招】JAVA集合_第10张图片

Vector源码分析

Image

//void add(int index, Object ele):在index位置插入ele元素
list.add(1,"1111");


//boolean addAll(int index, Collection eles):从index位置开始将eles中
// 的所有元素添加进来
List list_1= Arrays.asList(222,222);
list.addAll(1,list_1);


// Object get(int index):获取指定index位置的元素
System.out.println(list.get(0));

// int indexOf(Object obj):返回obj在集合中首次出现的位置 没有返回-1
System.out.println("123第一次出现"+list.indexOf(123));

// int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
System.out.println("123最后一次出现"+list.lastIndexOf(123));

// Object remove(int index):移除指定index位置的元素,并返回此元素
Object remove = list.remove(0);
System.out.println(remove.toString()+list);

// Object set(int index, Object ele):设置指定index位置的元素为ele
list.set(0,11111);

// List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex
// 位置的子集合 前闭后开
List list1 = list.subList(0, 1);
System.out.println(list1);

总结常用方法

【备战秋招】JAVA集合_第11张图片

【备战秋招】JAVA集合_第12张图片

Collection子接口: Set接口

无序不重复

【备战秋招】JAVA集合_第13张图片

实现类:HashSet

【备战秋招】JAVA集合_第14张图片

hashset 底层是数组加链表

【备战秋招】JAVA集合_第15张图片

HashSet 是 Set 接口的典型实现,大多数时候使用 Set 集合时都使用这个实现类。

HashSet 按 Hash 算法来存储集合中的元素,因此具有很好的存取、查找、删除 性能。

HashSet 具有以下特点:

  • 不能保证元素的排列顺序
  • HashSet 不是线程安全的
  • 集合元素可以是 null

HashSet 集合判断两个元素相等的标准:两个对象通过 hashCode() 方法比较相 等,并且两个对象的 equals() 方法返回值也相等。

对于存放在Set容器中的对象,对应的类一定要重写equals()和hashCode(Object obj)方法,以实现对象相等规则。即:“相等的对象必须具有相等的散列码”

实现类:TreeSet 排序

可以按照添加 对象的指定属性 进行排序(同一个类)

1 自然排序-Comparable

其中比较两个对象是否相同的标准为:compareTo()返回0,不在是equals()方法

//TreeSet 同一个类的对象
TreeSet treeSet=new TreeSet();
treeSet.add(new Persion(23,"YYQ"));
treeSet.add(new Persion(21,"Lr"));
treeSet.add(new Persion(24,"HLZ"));
treeSet.add(new Persion(222,"YYYYYYYQ"));
treeSet.add(new Persion(222,"YYYQ"));

Iterator iterator = treeSet.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}

对Persion实现comparable接口,重写compareTo()接口

@Override
public int compareTo(Object o) {
if (o instanceof Persion){
    Persion p=(Persion)o;
    int i = this.name.compareTo(p.name);
    if(i!=0)
        return i;
    else
        return -Integer.compare(this.age,p.age);

}
throw new RuntimeException("数据类型错误");
}

2 定制排序 comparator-

Comparator com =new Comparator() {
@Override
public int compare(Object o1, Object o2) {
        if(o1 instanceof Persion && o2 instanceof Persion){
                Persion p1=(Persion)o1;
                Persion p2=(Persion)o2;
            return Integer.compare(p1.age,p2.age);
            }
        throw new RuntimeException("类型错误");
        }
};
//TreeSet 同一个类的对象
TreeSet treeSet=new TreeSet(com);
treeSet.add(new Persion(23,"YYQ"));
treeSet.add(new Persion(21,"Lr"));
treeSet.add(new Persion(24,"HLZ"));
treeSet.add(new Persion(222,"YYYYYYYQ"));
treeSet.add(new Persion(222,"YYYQ"));

Iterator iterator = treeSet.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}

Map接口

双列数据 key -value

【备战秋招】JAVA集合_第16张图片

 Map与Collection并列存在。用于保存具有映射关系的数据:key-value

 Map 中的 key 和 value 都可以是任何引用类型的数据

 Map 中的 key 用Set来存放,不允许重复,即同一个 Map 对象所对应的类,须重写hashCode()和equals()方法

 常用String类作为Map的“键”

 key 和 value 之间存在单向一对一关系,即通过指定的 key 总能找到唯一的、确定的 value

 Map接口的常用实现类:HashMap、TreeMap、LinkedHashMap和 Properties。其中,HashMap是 Map 接口使用频率最高的实现类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m4EYHbaw-1686112437497)(https://secure2.wostatic.cn/static/h6XhQqHgdrkDKHHBTBMZ1y/image.png)]

/**
* /----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之前)
* 数组+链表+红黑树(JDK8)

* 二、Map结构的理解
*      Map中的key无序的,不可重复的,使用Set存储所有的key ---->key所在的类要重写equals()和hashcCode()方法
*      Map中的value无序的,可重复的,使用Collection储存所有的value ---->value所在的类重写equals()方法
*      一个Key-value键值对构成了一个Entry对象。
*      Map中的entry:无序的、不可重复的,使用Set存储所有的entry
*
*
* 三、HashMap的底层实现原理
*      Jdk7:
*      HashMap map =new HashMap();
*      在实例化之后,底层创建了长度是16的一维数组 Entry[] table
*      ...可能执行很多put
*      map.(key1,values1)
*      首先,调用key1所在类的hashCode()方法计算key1的 哈希值,此哈希值经过某种算法计算之后,得到在Entry数组中的存放位置,
*          如果此位置上数据为空,此时的key1-value1添加成功
*          如果此位置上数据不为空,(意味着此位置存在一个或者多个数据(以链表的形式存在)),比较key1和已经存在的多个数据的hash值
*              如果key1的哈希值和已经存在的数据的哈希值都不同,此时key1-value1添加成功。
*              如果key1的哈希值和已经存在的数据(key2-value2)的哈希值相同,继续比较,调用key1所在类的equals(key2)
*                  如果equals()返回false,则key1-value1添加成功
*                  如果equals()返回为ture,则value1替换value2
*
*      在添加过程中,会涉及到扩容问题,当超出临界值且 默认的扩容是原来的二倍,并将原来的数据复制过来
*

*      Jdk8相较于jDk7的区别
*          1、new HashCode() :底层没有创建一个长度为16的数组
*          2、jdk8 底层数组为:Node[] 而非Entry[]
*          3、首次调用put(key,value)方法时,底层创建长度为16的数组
*          4、jdk7底层结构只有数组+链表
*      jdk8底层结构 数组+链表+红黑树
* 当数组的某一个索引位置上的元素以链表形式存在的数据个数>8 且当前数组的长度>64时,
* 此时此索引位置上的所有数据改为红黑树储存

HashMap的存储结构

JDK 7及以前版本:HashMap是数组+链表结构(即为链地址法)。 JDK 8版本发布以后:HashMap是数组+链表+红黑树实现。

【备战秋招】JAVA集合_第17张图片

11.6 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集合

//遍历所有的key
Set set = map.keySet();
Iterator iterator = set.iterator();
while(iterator.hasNext())
System.out.println(iterator.next());

//遍历所有的value
Collection values = map.values();
for(Object e : values)
System.out.println(e);

//方式一:遍历所有的key-value
Set set1 = map.entrySet();
Iterator iterator1 = set1.iterator();
while (iterator1.hasNext()){
Object obj=iterator1.next();
Map.Entry entry=(Map.Entry)obj;
//entrySet集合中的元素都是entry
System.out.println("key:"+entry.getKey()+"--->value:"+entry.getValue());
}

//方式二 遍历所有的key-value
Iterator iterator2 = set.iterator();
while (iterator2.hasNext()){
Object key = iterator2.next();
Object val = map.get(key);
System.out.println("key:--"+key+"---:"+val);

TreeMap

/TreeMap中添加Key-value 要求key必须是同一个类
//因为要按照key进行自然排序和定制排序

//自然排序 Persion实现comparable接口的compareTo接口 
TreeMap map=new TreeMap();
Persion p1=new Persion(22,"YYq");
Persion p2=new Persion(23,"Y2Yq");
Persion p3=new Persion(24,"Y21Yq");

map.put(p1,10);
map.put(p2,122);
map.put(p3,1122);
Set set = map.keySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()){
Object key = iterator.next();
Object value = map.get(key);
System.out.println(key+"----------"+value);
}

@Test
public void test1(){

//定制排序
TreeMap map=new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Persion && o2 instanceof Persion){
Persion p1=(Persion)o1;
Persion p2=(Persion)o2;
int compare = Integer.compare(p1.age, p2.age);
if(compare!=0) return compare;
else return p1.name.compareTo(p2.name);
}
throw new RuntimeException("类型不匹配");
}
});
Persion p1=new Persion(22,"YYq");
Persion p2=new Persion(22,"Y2Yq");
Persion p3=new Persion(24,"Y21Yq");

map.put(p1,10);
map.put(p2,122);
map.put(p3,1122);
Set set = map.keySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()){
Object key = iterator.next();
Object value = map.get(key);
System.out.println(key+"----------"+value);
}
}

Properties

Map->Hashable->Properties-------------------------------------------

  • Properties 类是 Hashtable 的子类,该对象用于处理属性文件
  • 由于属性文件里的 key、value 都是字符串类型,所以 Properties 里的 key 和 value 都是字符串类型
  • 存取数据时,建议使用setProperty(String key,String value)方法和 getProperty(String key)方法
Properties pro =new Properties();
FileInputStream fis =new FileInputStream("jdbc.properties");
pro.load(fis);
String name = pro.getProperty("name");
String password = pro.getProperty("password");
System.out.println(name+"----"+password);
fis.close();

Collections工具类

Collections 是一个操作 Set、List 和 Map 等集合的工具类

// 排序操作:(均为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 对象的所有旧值


//使用Collections.copy() 注意dest必须被撑开
List list=new ArrayList();
List list1 = Collections.synchronizedList(list);
list.add(123);
list.add(12);
list.add(-13);
list.add(2141);
List dest= Arrays.asList(new Object[list.size()]);
//把list->放入dest
Collections.copy(dest,list);
System.out.println(dest);

【备战秋招】JAVA集合_第18张图片

你可能感兴趣的:(备战秋招,#,重温Java,java,开发语言,jvm)