对象的容器,实现了对对象常用的操作
数组长度固定,集合长度不固定
数组可以存储基本类型和引用类型,集合只能存储引用类型
java.util.*;
特点:代表一组任意类型的对象,无序、无下标、不能重复。
创建集合 Collection collection = new ArrayList();
添加元素 collection.add();
删除元素
collection.remove();
collection.clear();
遍历元素(重点)
使用增强for(因为无下标)
for(Object object : collection){ }
使用迭代器
//haNext(); 有没有下一个元素
//next(); 获取下一个元素
//remove(); 删除当前元素
Iterator it = collection.iterator();
while(it.hasNext()){
String object = (String)it.next(); //强转
// 可以使用it.remove(); 进行移除元素
// collection.remove(); 不能用collection其他方法 会报并发修改异常
}
判断 collection.contains(); collection.isEmpty();
特点:有序、有下标、元素可重复
创建集合对象 List list = new ArrayList<>( );
添加元素 list.add( ); 会对基本类型进行自动装箱
删除元素 可以用索引 list.remove(0)
当删除数字与索引矛盾时 对数字强转
list.remove((Object) 10) 或 list.remove(new Integer(10))
遍历
使用for遍历
for(int i = 0; i < lise.size(); i++){
sout(list.get(i));
}
使用增强for
for(Object list: collection){ }
使用迭代器
Iterator it = collection.iterator();
while(it.hasNext()){
String object = (String)it.next(); //强转
// 可以使用it.remove(); 进行移除元素
// collection.remove(); 不能用collection其他方法 会报并发修改异常
}
使用列表迭代器 💡(注意和迭代器区别)
ListIterator li = list.listIterator();
while(li.hasNext()){
System.out.println(li.nextIndex() + “:” + li.next()); //从前往后遍历
}
while(li.hasPrevious()){
System.out.println(li.previousIndex() + “:” + li.previous()); //从后往前遍历
}
获取 list.indexOf( );
返回子集合 sublist(x, y); 左闭右开
List subList = list.subList(1, 3); 返回索引 1、2
ArrayList 【重点】
数组结构实现,必须要连续空间,查询快、增删慢
jdk1.2版本,运行效率块、线程不安全
Vector
数组结构实现,查询快、增删慢
jdk1.0版本,运行
LinkedList
双向链表结构实现,无需连续空间,增删快,查询慢
创建集合 ArrayList arrayList = new ArrayList<>();
添加元素 arrayList.add();
删除元素 arrayList.remove(new Student(“name”, 10));
这里重写了 equals(this == obj) 方法
public boolean equals(Object obj){
//1 判断是不是同一个对象
if(this == obj){
return true;
}
//2 判断是否为空
if(obj == null){
return false;
}
//3 判断是否是Student类型
if(obj instanceof Student){
Student == (Student)obj;
//4 比较属性
if(this.name.equals(s.getName()) && this.age == s.getAge()){
return true;
}
}
//5 不满足条件返回false
return false;
}
遍历元素【重点】
使用迭代器
Iterator it = arrayList.iterator();
while(it.hasNext()){
Student s = (Student)it.next(); //强转
}
列表迭代器
ListIterator li = arrayList.listIterator();
while(li.hasNext()){
Student s = (Student)li.next(); //从前往后遍历
}
while(li.hasPrevious()){
Student s = (Student)li.previous();//从后往前遍历
}
判断
arrayList.contains(); 和 arrayList.isEmpty();
查找
arrayList.indexof();
原码分析
DEFAULT_CAPACITY = 10; //默认容量
//注意:如果没有向集合中添加任何元素时,容量0,添加一个后,容量为10
//每次扩容是原来的1.5倍
elementData存放元素的数组
size 实际元素个数
创建集合 Vector vector = new Vector<>();
增加、删除、判断同上
遍历中枚举器遍历
Enumeration en = vector.elements();
while(en.hasMoreElements()){
String o = (String)en.nextElement();
sout(o);
}
创建链表集合LinkedList li = new LinkedList<>();
常用方法与List一致
本质是参数化类型,把类型作为参数传递
常见形式有泛型类、泛型接口、泛型方法
语法 T成为类型占位符,表示一种引用类型,可以写多个逗号隔开
好处 1. 提高代码重用性 2. 防止类型转换异常,提高代码安全性
// 写一个泛型类
public class MyGeneric{
//使用泛型T
//1 创建变量
T t;
//2 泛型作为方法的参数
public void show(T t){
sout(t);
}
//3 泛型作为方法的返回值
public T getT(){
return t;
}
}
// 使用泛型类
public class TestGeneric{
public static void main(String[] args){
//使用泛型类创建对象
// 注意: 1. 泛型只能使用引用类型
// 2. 不用泛型类型对象之间不能相互赋值
MyGeneric myGeneric = new MyGeneric();
myGeneric.t = “hello”;
myGeneric.show(“hello world!”);
String string = myGeneric.getT();
MyGeneric<Integer> myGeneric2 = new MyGeneric<Integer>();
myGeneric2.t = 100;
myGeneric2.show(200);
Integer integer = myGeneric2.getT();
}
}
语法:接口名
注意:不能泛型静态常量
语法: 返回值类型
public class MyGenericMethod{
//泛型方法
public T show(T t){
sout(“泛型方法” + t);
return t;
}
}
//调用
MyGenericMethod myGenericMethod = new MyGenericMethod();
myGenericMethod.show(“字符串”);// 自动类型为字符串
myGenericMethod.show(200);// integer类型
myGenericMethod.show(3.14);// double类型
概念:参数化类型、类型安全的集合,强制集合元素的类型必须一致
特点:
编译时即可检查,而非运行时抛出异常
访问时,不必类型转换(拆箱)
不同泛型之间应用不能相互赋值,泛型不存在多态
特点:无序、无下标、元素不可重复
方法:全部继承自Collection中的方法
增、删、遍历、判断与collection一致
存储结构:哈希表(数组+链表+红黑树)
存储过程(重复依据)
根据hashCode计算保存的位置,如果位置为空,直接保存,若不为空,进行第二步
再执行equals方法,如果equals为true,则认为是重复,否则形成链表
特点
基于HashCode计算元素存放位置
利用31这个质数,减少散列冲突
31提高执行效率 31 * i = (i << 5) - i 转为移位操作
当存入元素的哈希码相同时,会调用equals进行确认,如果结果为true,则拒绝后者存入
新建集合 HashSet hashSet = new HashSet();
添加元素 hashSet.add( );
删除元素 hashSet.remove( );
遍历操作
1. 增强for for( type type : hashSet)
2. 迭代器 Iterator it = hashSet.iterator( );
判断 hashSet.contains( ); hashSet.isEmpty();
特点
基于排列顺序实现元素不重复
实现SortedSet接口,对集合元素自动排序
元素对象的类型必须实现Comparable接口,指定排序规则
通过CompareTo方法确定是否为重复元素
存储结构:红黑树
创建集合 TreeSet treeSet = new TreeSet<>()
添加元素 treeSet.add();
删除元素 treeSet.remove();
遍历 1. 增强for 2. 迭代器
判断 treeSet.contains();
补充:TreeSet集合的使用
Comparator 实现定制比较(比较器)
Comparable 可比较的
// 重写compare
@override
public int compare(Person o1, Person o2){
int n1 = o1.getAge()-o2.getAge();
int n2 = o1.getName().comareTo(o2.getName());
return n1 == 0 ? n2 : n1;
}
Map接口的特点
-
用于存储任意键值对(key - value)
-
键:无序、无下标、不允许重复(唯一)
-
值:无序、无下标、允许重复
方法: -
V put(K key, V value) 将对象存到集合中,关联键值
-
Object get(Object key) 根据键获得对应的值
-
Set 返回所有的Key
-
Collection values() 返回包含所有值的Collection集合
-
Set<Map.Entry<K, V>> 键值匹配的Set集合
//创建Map集合
Map<String, String> map = new HashMap<>();
// 1. 添加元素
map.put(“cn”, “中国”);
map.put(“uk”, “英国”);
map.put(“cn”, “zhongguo”); // 会替换第一个
// 2. 删除
map.remove(“uk”);
// 3. 遍历
// 3.1 使用KeySet()
//Set keyset = map.keySet(); // 所有Key的set集合
for(String key : map.keyset){
sout(key + “—” + map.get(key));
}
// 3.2 使用entrySet()
//Set<Map.Entry<String, String>> entries = map.entrySet();
for(Map.Entry<String, String> entry : map.entries){
sout(entry.getKey() + “—” + entry.getValue();
}
存储结构:哈希表(数组+链表+红黑树)
使用key可使hashcode和equals作为重复
增、删、遍历、判断与上述一致
原码分析总结:
HashMap刚创建时,table是null,节省空间,当添加第一个元素时,table容量调整为16
当元素个数大于阈值(16*0.75 = 12)时,会进行扩容,扩容后的大小为原来的两倍,目的是减少调整元素的个数
jdk1.8 当每个链表长度 >8 ,并且数组元素个数 ≥64时,会调整成红黑树,目的是提高效率
jdk1.8 当链表长度 <6 时 调整成链表
jdk1.8 以前,链表时头插入,之后为尾插入
线程安全,运行效率慢;不允许null作为key或是value
hashtable的子类,要求key和value都是string,通常用于配置文件的读取
实现了SortedMap接口(是map的子接口),可以对key自动排序
概念:集合工具类,定义了除了存取以外的集合常用方法
直接二分查找int i = Collections.binarySearch(list, x); 成功返回索引
其他方法 : copy复制、reverse反转、shuffle打乱
补充:
// list转成数组
Integer[] arr = list.toArray(new Integer[10]);
sout(arr.length);
sout(Array.toString(arr));
// 数组转成集合
// 此时为受限集合,不能 添加和删除!
String[] name = {“张三”,“李四”,“王五”};
List list2 = Arrays.asList(names);
// 把基本类型数组转为集合时,需要修改为包装类
Integer[] nums = {100, 200, 300, 400, 500};
List list3 = Arrays.asList(nums);
EOF
本文作者:Coder Zjz’s blog
本文链接:https://www.cnblogs.com/coderzjz/p/13587167.html
关于博主:评论和私信会在第一时间回复。或者直接私信我。
版权声明:本博客所有文章除特别声明外,均采用 BY-NC-SA 许可协议。转载请注明出处!
声援博主:如果您觉得文章对您有帮助,可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力!
分类: java
标签: java
好文要顶 关注我 收藏该文 CoderZjz
关注 - 3
粉丝 - 80
+加关注
320
« 上一篇: 力扣Leetcode 1518. 换酒问题
» 下一篇: JAVA集合类简要笔记 - 内部类 包装类 Object类 String类 BigDecimal类 system类
posted @ 2020-08-30 22:59 CoderZjz 阅读(11272) 评论(5) 编辑 收藏 举报
登录后才能查看或发表评论,立即 登录 或者 逛逛 博客园首页
编辑推荐:
· 浅谈 C# 字符串构建利器 StringBuilder
· 老项目的倔强 —— 性能优化篇
· 2021 .NET Conf China 主题分享之-轻松玩转.NET大规模版本升级
· 理解 OAuth2.0 协议和授权机制
· Asp.net core IdentityServer4 与传统基于角色的权限系统的集成
最新新闻:
· 勒索老黄未果!黑客公布英伟达核心源代码,超40万个文件、75GB机密数据
· 不断加深的危机迫使物理学家重新思考自然法则的结构
· “拯救者”拯救不了联想手机
· 骨传导耳机不会影响听力,是真的咩?
· 苹果坚持职能制,组织转型还有必要吗?
» 更多新闻…
Java集合 Collection、Set、Map、泛型 简要笔记
发表于 2020-08-30 22:59阅读次数:11272评论次数:5
JAVAJAVA
[ 凡是过往皆为序章 ]
This blog has running : 695 d 16 h 58 m 21 sღゝ◡╹)ノ♡
友情链接:Github/CSDN博客/申请坑位/申请坑位/申请坑位
Copyright © 2022 CoderZjz Powered by .NET 6 on Kubernetes
Theme version: v1.3.0 / Loading theme version: v1.3.0
1.0 集合
1.1 什么是集合
1.2 Collection体系
1.3 泛型
1.4 Set集合
1.5 Map
1.6 Collection工具类
转载至:https://www.cnblogs.com/coderzjz/p/13587167.html