门户网站建设重建方案,淄博网站的优化,网站制作工作室哪家比较好,免费供求信息发布集合
前言
一方面#xff0c; 面向对象语言对事物的体现都是以对象的形式#xff0c;为了方便对多个对象 的操作#xff0c;就要 对对象进行存储。
另一方面#xff0c;使用Array存储对象方面具有一些弊端#xff0c;而Java 集合就像一种容器#xff0c;可以动态地把多…集合
前言
一方面 面向对象语言对事物的体现都是以对象的形式为了方便对多个对象 的操作就要 对对象进行存储。
另一方面使用Array存储对象方面具有一些弊端而Java 集合就像一种容器可以动态地把多个对象的引用放入容器中。
数组在内存存储方面的特点:
数组初始化以后长度就确定了。 String arr[];数组声明的类型就决定了进行元素初始化时的类型
数组在存储数据方面的弊端
数组初始化以后长度就不可变了不便于扩展数组中提供的属性和方法少不便于进行添加、删除、插入等操作且效率不高。 同时无法直接获取存储元素的个数数组存储的数据是有序的、可以重复的。----存储数据的特点单一
综上所诉引入java集合类的必要性
Java 集合类可以用于存储数量不等的多个对象还可用于保存具有映射关系的关联数组。 集合类概述
java 集合可分为 Collection 和 Map 两种体系
Collection接口单列数据定义了存取一组对象的方法的集合
List元素有序、可重复的集合 -------“动态数组” |- ArrayList …LinkedList VectorSet元素无序、不可重复的集合 |-HashSet … LinkedHashSet …TreeSet Map接口双列数据保存具有映射关系“key-value对”的集合
|-HashMap…Properties…LinkedHashMap…TreeMap 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 collnew 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_1new 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(removeAllcoll);//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类的静态方法
ListString list Arrays.asList(new String[]{AAA, BBB, CCC});
System.out.println(list);//iterator():返回iterator接口的实例用于遍历集合元素//clear()清空集合
coll.clear();//isEmpty():查看集合是否为空
System.out.println(coll.isEmpty()); 迭代器iterator
Iterator对象称为迭代器(设计模式的一种)主要用于遍历 Collection 集合中的元素。
GOF给迭代器模式的定义为提供一种方法访问一个容器(container)对象中各个元 素而又不需暴露该对象的内部细节。迭代器模式就是为容器而生。类似于“公交车上的售票员”、“火车上的乘务员”、“空姐”。
Collection接口继承了java.lang.Iterable接口该接口有一个iterator()方法那么所有实现了Collection接口的集合类都有一个iterator()方法用以返回一个实现了 Iterator接口的对象。 Iterator 仅用于遍历集合Iterator 本身并不提供承装对象的能力。如果需要创建 Iterator 对象则必须有一个被迭代的集合。 集合对象每次调用iterator()方法都得到一个全新的迭代器对象默认游标都在集合 的第一个元素之前。 //迭代器接口 iterator -遍历集合
//此处是利用多态 查看collection的方法左边编译右边运行
Collection collnew 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 objiterator.next();if(obj.equals(Tom)) //指针指向这个数据iterator.remove();}
Iterator iterator_1 coll.iterator();
while(iterator_1.hasNext()){System.out.println(第二次iterator_1.next());
}增强for循环 Collection子接口 List接口 鉴于Java中数组用来存储数据的局限性我们通常使用List替代数组
List集合类中元素有序、且可重复集合中的每个元素都有其对应的顺序索引。
List容器中的元素都对应一个整数型的序号记载其在容器中的位置可以根据 序号存取容器中的元素。
JDK API中List接口的实现类常用的有ArrayList、LinkedList和Vector。
同: 三个接口都是实现了List接口储存数据的特点相同存储有序可重复的数据不同: Vector 古老的接口 List
ArrayList 源码分析 LinkList源码分析
体现了双向链表 Vector源码分析 //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);总结常用方法 Collection子接口 Set接口
无序不重复 实现类:HashSet hashset 底层是数组加链表 HashSet 是 Set 接口的典型实现大多数时候使用 Set 集合时都使用这个实现类。
HashSet 按 Hash 算法来存储集合中的元素因此具有很好的存取、查找、删除 性能。
HashSet 具有以下特点
不能保证元素的排列顺序HashSet 不是线程安全的集合元素可以是 null
HashSet 集合判断两个元素相等的标准两个对象通过 hashCode() 方法比较相 等并且两个对象的 equals() 方法返回值也相等。
对于存放在Set容器中的对象对应的类一定要重写equals()和hashCode(Object obj)方法以实现对象相等规则。即“相等的对象必须具有相等的散列码”
实现类:TreeSet 排序
可以按照添加 对象的指定属性 进行排序(同一个类)
1 自然排序-Comparable
其中比较两个对象是否相同的标准为:compareTo()返回0不在是equals()方法
//TreeSet 同一个类的对象
TreeSet treeSetnew 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;elsereturn -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 treeSetnew 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 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(keyvalue)方法时底层创建长度为16的数组
* 4、jdk7底层结构只有数组链表
* jdk8底层结构 数组链表红黑树
* 当数组的某一个索引位置上的元素以链表形式存在的数据个数8 且当前数组的长度64时
* 此时此索引位置上的所有数据改为红黑树储存HashMap的存储结构
JDK 7及以前版本HashMap是数组链表结构(即为链地址法)。 JDK 8版本发布以后HashMap是数组链表红黑树实现。 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 objiterator1.next();
Map.Entry entry(Map.Entry)obj;
//entrySet集合中的元素都是entry
System.out.println(key:entry.getKey()---valueentry.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 mapnew TreeMap();
Persion p1new Persion(22,YYq);
Persion p2new Persion(23,Y2Yq);
Persion p3new 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 mapnew 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 p1new Persion(22,YYq);
Persion p2new Persion(22,Y2Yq);
Persion p3new 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(ListComparator)根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
//swap(Listint int)将指定 list 集合中的 i 处元素和 j 处元素进行交换// 查找、替换
//Object max(Collection)根据元素的自然顺序返回给定集合中的最大元素
//Object max(CollectionComparator)根据 Comparator 指定的顺序返回给定集合中的最大元素
//Object min(Collection)
//Object min(CollectionComparator)
//int frequency(CollectionObject)返回指定集合中指定元素的出现次数
//void copy(List dest,List src)将src中的内容复制到dest中
//boolean replaceAll(List listObject oldValObject newVal)使用新值替换 List 对象的所有旧值//使用Collections.copy() 注意dest必须被撑开
List listnew 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);
