1 Java 集合框架概述
一方面, 面向对象语言对事物的体现都是以对象的形式,为了方便对多个对象的操作,就要对对象进行存储。另一方面,使用Array存储对象方面具有一些弊端,而Java 集合就像一种容器,可以动态地把多个对象的引用放入容器中。
数组在内存存储方面的特点:
数组初始化以后,长度就确定了。
数组声明的类型,就决定了进行元素初始化时的类型
数组在存储数据方面的弊端:
数组初始化以后,长度就不可变了,不便于扩展
数组中提供的属性和方法少,不便于进行添加、删除、插入等操作,且效率不高。同时无法直接获取存储元素的个数
数组存储的数据是有序的、可以重复的。---->存储数据的特点单一
Java 集合类可以用于存储数量不等的多个对象,还可用于保存具有映射关系的关联数组。
Collection接口继承树:
Map接口继承树:
2 Collection接口方法
Collection 接口是 List、Set 和 Queue 接口的父接口,该接口里定义的方法既可用于操作 Set 集合,也可用于操作 List 和 Queue 集合。 JDK不提供此接口的任何直接实现,而是提供更具体的子接口(如:Set和List)实现。
在 Java5 之前,Java 集合会丢失容器中所有对象的数据类型,把所有对象都当成 Object 类型处理;从 JDK 5.0 增加了泛型以后,Java 集合可以记住容器中对象的数据类型。
public class CollectionTest1 {
@Test
public void test1(){
Collection collection = new ArrayList();
//add方法:将元素添加到集合collection
collection.add("AA");
collection.add("123");
collection.add(123);
collection.add(new Date());
collection.add("CC");
//size获取添加元素的个数
System.out.println(collection.size());
//addall(Collection coll) 将coll集合中的元素添加到当前的集合中
Collection collection1 = new ArrayList();
collection1.addAll(collection);
//clear:清空元素
collection.clear();
//isempty判断当前集合是否为空
System.out.println(collection.isEmpty());//false
//Contains()
System.out.println(collection1.contains("CC"));//true
}
}
Person类中重写了equals方法,这样只要判断年龄(基本类型)值相等以及字符串因为重写了equals所以也是比较值是否相等.
@Override
public boolean equals(Object o) {
System.out.println("重写的equals");
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add(new String("Tom"));
coll.add(new Person());
coll.add(123);
coll.add(true);
coll.add("AA");
// Person p = new Person("suo",18);
// coll.add(p);
coll.add(new Person("suo",18));
//1.Contains()
//我们在判断时会调用object所在类的equals方法
boolean contains = coll.contains(true);//true
System.out.println(contains);
System.out.println(coll.contains(new String("Tom")));//true,因为string重写了equal
System.out.println(new String("Tom"));
//System.out.println(coll.contains(p));//true
System.out.println(coll.contains(new Person("suo",18)));//false;当从写了equal以后,变为true
//2.ContainsAll(Collection col(另一个接口)):自己要有不在的就是false
boolean b = coll.containsAll(coll);
Collection coll1 = Arrays.asList(123,456);
System.out.println(b);
//3.remove():删除对应元素
coll.remove(1234);//找到并移除
System.out.println(coll);
System.out.println(coll.remove(new Person("suo", 18)));//true 调用equals查找
//4.removell(Collection col):差集:移除COl中的所有元素:移除交集
coll.removeAll(coll1);
System.out.println(coll);//移除交集
}
@Test
public void test2(){
Collection coll = new ArrayList();
coll.add(new String("Tom"));
coll.add(new Person());
coll.add(123);
coll.add(true);
coll.add("AA");
// Person p = new Person("suo",18);
// coll.add(p);
coll.add(new Person("suo",18));
Collection coll1 = Arrays.asList(123,456,789);
//5.retainAll(Collection col):保留交集,并返回给当前集合
coll.retainAll(coll1);
System.out.println(coll);//[123]
//6.equals():当前集合和形参的元素都相同,返回true;有序的,顺序不一样不算一样
Collection coll2 = new ArrayList();
coll2.add(new String("Tom"));
coll2.add(new Person());
coll2.add(123);
coll2.add(true);
coll2.add("AA");
coll2.add(new Person("suo",18));
System.out.println(coll2.equals(coll));//false 上面删除了一些coll
}
@Test
public void test3(){
Collection coll = new ArrayList();
coll.add(new String("Tom"));
coll.add(new Person());
coll.add(123);
coll.add(true);
coll.add("AA");
// Person p = new Person("suo",18);
// coll.add(p);
coll.add(new Person("suo",18));
//7.hashCode():返回当前对象的哈希值
System.out.println(coll.hashCode());
//8.集合转换为数组:toarray
Object[] objects = coll.toArray();
System.out.println(objects);
for (int i = 0; i < objects.length; i++) {
System.out.println(objects[i]);
}
//数组转换为集合:?调用Arrays.asList
List<Object> objects1 = Arrays.asList(objects);
System.out.println(objects1);//[Tom, CollectionTest.Person@22927a81, 123, true, AA, CollectionTest.Person@78e03bb5]
//iterator():返回Iterator接口的实例,用于遍历集合元素,
}
}
3 Iterator迭代器接口
Iterator对象称为迭代器(设计模式的一种),主要用于遍历 Collection 集合中的元素。
GOF给迭代器模式的定义为:提供一种方法访问一个容器(container)对象中各个元素,而又不需暴露该对象的内部细节。迭代器模式,就是为容器而生。类似于“公交车上的售票员”、“火车上的乘务员”、“空姐”。 Collection接口继承了java.lang.Iterable接口,该接口有一个iterator()方法,那么所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象。
Iterator 仅用于遍历集合,Iterator 本身并不提供承装对象的能力。如果需要创建Iterator 对象,则必须有一个被迭代的集合。
集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前。
//Iterator
@Test
public void test(){
Collection coll = new ArrayList();
coll.add(new String("Tom"));
coll.add(new Person());
coll.add(123);
coll.add(true);
coll.add("AA");
// Person p = new Person("suo",18);
// coll.add(p);
coll.add(new Person("suo",18));
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());
System.out.println(iterator.next());
//System.out.println(iterator.next());//NoSuchElementException报异常
//方式二:
Iterator iterators = coll.iterator();
for (int i = 0; i < coll.size(); i++) {
System.out.println(iterators.next());
}
//推荐三:
Iterator iteratorss = coll.iterator();
while (iteratorss.hasNext()){//hasNext判断是否还有下一个元素
//next()1.指针下移2.下移以后的集合位置上的元素返回
System.out.println(iteratorss.next());
}
}
@Test
public void test2(){
Collection coll = new ArrayList();
coll.add(new String("Tom"));
coll.add(new Person());
coll.add(123);
coll.add(true);
coll.add("AA");
// Person p = new Person("suo",18);
// coll.add(p);
coll.add(new Person("suo",18));
Iterator iterator = coll.iterator();
//错误方式一.
while (iterator.next() != null){//next是向下走,不会判断有没有
System.out.println(iterator.next());//NoSuchElementException
}
//错误方式二.
while (coll.iterator().hasNext()){//这个会一直有
System.out.println(iterator.next());
}
}
//测试remove方法
@Test
public void test3(){
Collection coll = new ArrayList();
coll.add(new String("Tom"));
coll.add(new Person());
coll.add(123);
coll.add(true);
coll.add("AA");
// Person p = new Person("suo",18);
// coll.add(p);
coll.add(new Person("suo",18));
//删除集合中"AA"
Iterator iterator = coll.iterator();
while (iterator.hasNext()){
Object next = iterator.next();
if ("AA".equals(next)){
iterator.remove();
}
}
//重新遍历
iterator = coll.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
foreach不会改变原先数组中的值
String[] str = new String[5];
for (String myStr : str) {
myStr = "atguigu";
System.out.println(myStr);
}
for (int i = 0; i < str.length; i++) {
System.out.println(str[i]);
}
结果:
4 Collection子接口之一:List接口
describe:
1.—Collection接口:单列集合
|—list接口:有序的,可重复的数据---->"动态"数组,替换原有的数组
|—ArrayList:作为List接口的主要实现类,线程不安全的,执行效率高;底层使用Object[] elementData存储
|—LinkedList:对于频繁的插入,删除操作,使用 此类效率比ArrayList高;底层使用的双向列表存储
|—Vector:作为List接口的古老实现类,线程安全,执行效率低;底层使用Object[] elementData存储
面试题:比较ArrayList,LinkedList,Vector三者的异同:
相同点:三个累都实现了List接口,存储数据的特点相同:存储有序的,可重复的数据
不同点:ArrayList
2.ArrayList源码分析: JDK7 的情况下:
ArrayList list = new ArrayList();//创建了底层长度时10的Object[]数组 Object[] elementData
list.add(123);//elementData[0] = new Integer(123);
…
list.add(456)//当此次添加的个数大于10,则扩容,默认扩容为原来容量的1.5倍数,将原有数组中的数据复制到新的数组中
结论:建议开发中使用带参的构造器
JDK8的变化:ArrayList
ArrayList list = new ArrayList();//底层Object[] elementData初始化为{},并没有创建长度为10的数组
list.add(123);//第一次调用add时,底层才创建了长度为10的数组,并将数据123添加到elementData
…
后续的添加和扩容操作与JDK7无异 内存节省
小结:JDK8相当于懒汉式单例模式(节省内存);JDK7相当于饿汉式
3.Linkedlist:
LinkedList link = new linkedList();内部声明了Node类型的first和last属性;默认值为null
list.add(123)//将123封装到Node中;创建了Node对象.
其中,Node定义为,体现了LinkedList的双向链表说法
4.Vector的源码分析:在JDK和8中,通过Vector构造器创建对象时,底层都创建了长度为10的数组;
扩容方面,默认扩容为原来的2倍
5.List接口中的常用方法:
总结常用方法:
增:add(obj),addall
删除:remove()位置或者数字
改:set
查:get
长度:size
插:add(index,obj)
遍历:遍历: 迭代Iterator
增强for
普通循环
@author suoliang
@create 2021-04-15:21
private static void updateList(List list) {
list.remove(2);
}
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
updateList(list);
System.out.println(list);//
结果:
效率高的原因:链表
双向链表:数据结构知识:只要知道了首尾链表一个链表就可以都查到了
5 Collection子接口之二:Set接口
describe:
1.|—set接口:有序的,不可重复的数据—>高中讲的"集合"
|—HashSet:作为set的主要实现类,线程不安全,可以存储null值
|—LinkedHashSet:作为HashSet的子类,遍历其内部数据时,可以按照添加的顺序遍历;
|—TreeSet:可以按照添加的元素的指定属性进行排序
2.Set:存储无序的,不可重复的数据
以HashSet为例
1.无序性:不等于随机性.存储的数据在底层数组中并非按照数组索引的顺序添加,而是根据数据的哈希值添加
2.不可重复性:保证添加的元素按照equals判断时,不能返回true,即,相同的元素只能有一个
(1)set没有额外定义的方法,使用的都是Collection中声明的方法
1. 添加元素的过程:以HashSet()为例:
我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法,计算元素a的哈希值
此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(索引位置),判断数组此位置上是否已经有元素:
如果此位置没有元素,则a元素添加成功—>情况一
如果此位置上有其他的元素b(或以链表形式存在的多个元素),则比较元素a和元素b的Hash值:
如果Hash值不相同,则添加成功—>情况二
如果Hash值相同,进而需要调用u元素a所在类的equals方法
equals返回true,元素添加失败
equals返回false,元素添加成功—>情况三
JDK7:元素a放到数组中,指向原来的元素
JDK:原来的元素在数组中,指向元素a
总结:七上八下
HashSet底层:数组+数据结构
2.要求:向Set中添加的数据,其所在的类一定要重写Hash Code()和equals();
要求L重写的HashCode和equals要保持一致性;相同的对象必须有相同的散列码
重写的小技巧:直接调用
@Test
public void test(){
Set set = new HashSet();
set.add(456);
set.add(478);
set.add(478);
set.add("aa");
set.add(new Person("name",15));
set.add(new Person("name",15));//如**果不重写HashCode他俩的H**ash值是不同的,重写以后,Hash值相同,而且equals,所以只显示一个添加成功
set.add(187);
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
describe:
1.treeSet中添加的数据,要求是相同类的对象;
2.两种排序方式:自然排序(实现Comparable接口),定制排序
3.自然排序中比较两个对象是否相同的标准为:CompareTo返回0,不再使用equals方法
4.定制排序中,比较两个元素是否相同利用compare
@Test
public void test(){
TreeSet treeSet = new TreeSet();
// treeSet.add(135);
// treeSet.add(456);
// treeSet.add("AA");//异常java.lang.Integer cannot be cast to java.lang.String
// treeSet.add(true);
// treeSet.add(new Person("suo",12));
// treeSet.add(12.3);
treeSet.add(456);
treeSet.add(789);
treeSet.add(844);
treeSet.add(542);
treeSet.add(4562);
//举例1
Iterator iterator = treeSet.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());//从小到大添加
}
@Override
public int compareTo(Object o) {
if (o instanceof Person){
Person person = (Person)o;
//return this.name.compareTo(person.name);//从小到大排列
//return -this.name.compareTo(person.name);//从大到小排列
if(this.name.compareTo(person.name) != 0){
return this.name.compareTo(person.name);
}else{
if (this.age > person.age){
return 1;
}else{
return -1;
}
}
}else{
throw new RuntimeException("数据类型不一致");
}
}
@Test
public void test2(){
TreeSet treeSet = new TreeSet(){};
treeSet.add(new Person("suo",78));
treeSet.add(new Person("suo1",788));
treeSet.add(new Person("suo2",781));
treeSet.add(new Person("suo3",78));
treeSet.add(new Person("suo4",78));
treeSet.add(new Person("suo5",78));
treeSet.add(new Person("suo6",78));
treeSet.add(new Person("suo6",799));//相当于和上面的一样,compareto比较一样,需要二级排序
System.out.println(treeSet);
}
@Test
public void test3(){
Comparator comparator = new Comparator() {
@Override
//按照年龄大小排序
public int compare(Object o1, Object o2) {
if(o1 instanceof Person && o2 instanceof Person){
Person person = (Person)o1;
Person person1 = (Person)o2;
if (person.getAge() > person1.getAge()){
return 1;
//return Integer.compare(p1.getage, p2.getage)
}else
{
return -1;
}
}
else{
throw new RuntimeException("数据类型不一致");
}
}
};
TreeSet treeSet = new TreeSet(comparator);//按照上面方法排序
treeSet.add(new Person("suo",78));
treeSet.add(new Person("suo1",788));
treeSet.add(new Person("suo2",781));
treeSet.add(new Person("suo3",78));
treeSet.add(new Person("suo4",78));
treeSet.add(new Person("suo5",78));
treeSet.add(new Person("suo6",78));
treeSet.add(new Person("suo6",799));//相当于和上面的一样,compareto比较一样,需要二级排序
}
因为虽然改了name,但是他还在name=AA,age=1001的地方放着
练习:在List内去除重复数字值,要求尽量简单:把list转化为hashset就可以实现去重
public static List duplicateList(List list) {
HashSet set = new HashSet();
set.addAll(list);
return new ArrayList(set);
}
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(2));
list.add(new Integer(4));
list.add(new Integer(4));
List list2 = duplicateList(list);
for (Object integer : list2) {
System.out.println(integer);
} }