DAY07 Collection、Iterator、泛型、数据结构

学习目标

能够说出集合与数组的区别数组:1.是引用数据类型的一种2.可以存储多个元素3.数组的长度是固定的 int[] arr1 = new int[10];  int[] arr2 = {1,2,3};4.数组即可以存储基本类型的数据,又可以存储引用数据类型的数据int[],double[],String[],Student[]集合:1.是引用数据类型的一种2.可以存储多个元素3.集合的长度是可以变化的(可以往集合中添加元素,删除集合中的元素)4.只能存储引用数据类型的数据ArrayList<int> 错误	ArrayList<Integer>	ArrayList<Student>
能够使用Collection集合的常用功能(重点)public boolean add(E e) ： 把给定的对象添加到当前集合中 。public boolean remove(E e) : 把给定的对象在当前集合中删除。public boolean contains(Object obj) : 判断当前集合中是否包含给定的对象。public boolean isEmpty() : 判断当前集合是否为空。public int size() : 返回集合中元素的个数。public Object[] toArray() : 把集合中的元素，存储到数组中public void clear() :清空集合中所有的元素。
能够使用迭代器对集合进行取元素(重点)//1.创建集合对象,往集合中添加元素Collection<String> coll = new ArrayList<>();//Collection<String> coll = new HashSet<>();coll.add("詹姆斯");coll.add("姚明");coll.add("科比");coll.add("乔丹");coll.add("艾弗森");//2.使用Collection接口中的方法iterator,获取迭代器的实现类对象Iterator<String> it = coll.iterator();//3.使用迭代器对象Iterator中的方法hasNext和next遍历集合while(it.hasNext()){String s = it.next();System.out.println(s);}
能够使用增强for循环遍历集合和数组(重点)for(集合|数组中元素的数据类型 变量名: 集合|数组){sout(变量名);}int[] arr = {1,2,3};for(int i : arr){sout(i);}ArrayList<String> list = new ArrayList<>();list.add("a");list.add("b");for(String s : list){sout(s);}
能够理解泛型上下限泛型的上限限定: ? extends E ==>传递的未知类型?只能是E的子类或者本身泛型的下限限定: ? super E   ==>传递的未知类型?只能是E的父类或者本身
能够阐述泛型通配符的作用泛型的通配符: ?  可以接收任意的数据类型
能够说出常见的数据结构栈,队列,数组,链表,红黑树
能够说出数组结构特点查询快,增删慢
能够说出栈结构特点先进后出
能够说出队列结构特点先进先出
能够说出单向链表结构特点查询慢,增删快

第一章 Collection集合

1.集合和数组的区别

数组:

1.是引用数据类型的一种

2.可以存储多个元素

3.数组的长度是固定的 int[] arr1 = new int[10]; int[] arr2 = {1,2,3};

4.数组即可以存储基本数据类型的数据,又可以存储引用数据类型的数据 int[] double[] String[] Student[]

集合:

1.是引用数据类型的一种

2.可以存储多个元素

3.集合的长度是可以变化的(添加元素,删除集合中的元素)

4.集合只能存储引用数据类型的数据

ArrayList<int> 错误 ArrayList<Integer> ArrayList<Student> ArrayList<String>正确

2.集合常用类的继承体系

3.Collection常用功能(重点)

package com.itheima.demo01Collection;import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;/*java.util.Collection<E>Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。Collection接口中定义了所有单列集合共性的成员方法,所有的实现类都可以使用public boolean add(E e) ： 往集合中添加元素public boolean remove(E e) : 移除集合中指定的元素public boolean contains(Object obj) : 判断当前集合中是否包指定的元素。public boolean isEmpty() : 判断当前集合是否为空。public int size() : 返回集合中元素的个数。获取集合的长度public Object[] toArray() : 把集合中的元素，存储到数组中public void clear() :清空集合中所有的元素。*/
public class Demo01Collection {public static void main(String[] args) {//创建Collection集合对象:多态(接口指向实现类对象,扩展性强)Collection<String> coll = new ArrayList<>();coll = new HashSet<>();/*public boolean add(E e) ： 往集合中添加元素返回值:boolean添加成功,返回true,添加元素百分之百会成功添加失败,返回false*/boolean b1 = coll.add("张三");System.out.println("b1:"+b1);//b1:truecoll.add("李四");coll.add("王五");coll.add("张三");coll.add("赵六");coll.add("田七");System.out.println(coll);//[张三, 李四, 王五, 张三, 赵六, 田七]  打印对象名,不是地址值,重写了Object类的toString方法/*public boolean remove(E e) : 移除集合中指定的元素返回值:boolean集合中存储指定的元素,移除元素,返回true;如果集合移除的元素有相同的,只会移除第一个集合中不存在指定的元素,remove方法对集合没有影响,返回false*/boolean b2 = coll.remove("张三");System.out.println("b2:"+b2);//b2:trueSystem.out.println(coll);//[李四, 王五, 张三, 赵六, 田七]boolean b3 = coll.remove("赵四");System.out.println("b3:"+b3);//b3:falseSystem.out.println(coll);//[李四, 王五, 张三, 赵六, 田七]/*public boolean contains(Object obj) : 判断当前集合中是否包指定的元素。返回值:boolean集合中包含指定的元素,返回true集合中不包含指定的元素,返回false*/boolean b4 = coll.contains("田七");System.out.println("b4:"+b4);//b4:trueboolean b5 = coll.contains("胡歌");System.out.println("b5:"+b5);//b5:false/*public boolean isEmpty() : 判断当前集合是否为空。返回值:boolean集合中没有元素,是空的,返回true集合中有元素,不是空的,返回false*/boolean b6 = coll.isEmpty();System.out.println("b6:"+b6);//b6:false/*public int size() : 返回集合中元素的个数。获取集合的长度*/int size = coll.size();System.out.println("size:"+size);//size:5/*public Object[] toArray() : 把集合中的元素，存储到数组中*/Object[] arr = coll.toArray();System.out.println(Arrays.toString(arr));//[李四, 王五, 张三, 赵六, 田七]/*public void clear() :清空集合中所有的元素。注意:此方法只是清空集合中的元素,不是删除集合;清空完集合还存在,还可以使用*/coll.clear();System.out.println(coll);//[]System.out.println(coll.size());//0System.out.println(coll.isEmpty());//true}
}

第二章 Iterator迭代器

1.迭代器的概述

/*迭代器:是一种通用取出集合中元素的方式迭代器的由来:集合有很多种,每种集合的数据结构不同(数组,链表,哈希表...),集合取出元素的方式也不同我们不可能为每种集合都定义一种取出元素的方式,浪费所以我们可以使用迭代器,是集合通用的取出元素的方式迭代器的原理:判断集合中还有没有元素,有就取出来;再判断集合中还有没有元素,有再取出来;一直判断到集合中没有元素为止,这种取出元素的方式叫迭代------------------------------------------------------------------------------------java.util.Iterator<E>接口:对 collection 进行迭代的迭代器。Iterator接口的常用方法:boolean hasNext() 如果仍有元素可以迭代，则返回 true。判断集合中还没有没有元素;有返回true,没有返回falseE next() 返回迭代的下一个元素。 取出集合中的元素------------------------------------------------------------------------------------Iterator是一个接口无法创建对象使用,使用Iterator接口的实现类对象,Iterator接口的实现类对象是每个集合的内部类(了解)我们可以使用Collection接口中的方法iterator获取迭代器Iterator接口的实现类对象Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。注意:我们无需关注iterator方法返回的是接口的哪个实现类对象,我们只需要会使用Iterator接口来接收这个实现类对象即可(多态)*/

2.迭代器的基本使用(重点)

/*迭代器的使用步骤(重点):1.创建集合对象,往集合中存储元素2.使用Collection接口中的方法iterator,获取迭代器接口的实现类对象3.使用迭代器对象Iterator接口中的方法hasNext和next遍历集合*/
public class Demo01Iterator {public static void main(String[] args) {//1.创建集合对象,往集合中存储元素Collection<String> coll = new ArrayList<>();coll.add("詹姆斯");coll.add("姚明");coll.add("科比");coll.add("乔丹");coll.add("艾弗森");/*2.使用Collection接口中的方法iterator,获取迭代器接口的实现类对象注意:迭代器Iterator是有泛型的,迭代的泛型跟着集合走,集合是什么泛型,迭代器就是什么泛型*///多态 接口         =   实现类对象Iterator<String> it = coll.iterator();//3.使用迭代器对象Iterator接口中的方法hasNext和next遍历集合/*我们发现使用迭代器取出元素是一个重复的过程,所以我们可以使用循环优化代码不知道集合中有多个元素,一般使用while循环while循环结束的条件:it.hasNext方法返回false*/while (it.hasNext()){//判断集合中还有没有元素//有元素,取出元素String s = it.next();System.out.println(s);}System.out.println("-----------------------------");//注意:迭代器只能使用一次,想要在遍历元素,必须重新获取一个新的迭代器for(Iterator<String> it2 = coll.iterator();it2.hasNext();){String s = it2.next();System.out.println(s);}/*boolean b = it.hasNext();System.out.println(b);//trueString s = it.next();System.out.println(s);//詹姆斯b = it.hasNext();System.out.println(b);//trues = it.next();System.out.println(s);//姚明b = it.hasNext();System.out.println(b);//trues = it.next();System.out.println(s);//科比b = it.hasNext();System.out.println(b);//trues = it.next();System.out.println(s);//乔丹b = it.hasNext();System.out.println(b);//trues = it.next();System.out.println(s);//艾弗森b = it.hasNext();System.out.println(b);//false*///s = it.next();//没有元素,就不能使用next方法获取元素,在获取元素会抛出没有元素异常:NoSuchElementException}
}

3.迭代器的执行原理

4.迭代器的并发修改异常(面试)

package com.itheima.demo02Iterator;import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;/*迭代器的并发修改异常:在使用迭代器遍历集合的过程中,对集合长度进行了修改,迭代器就会抛出并发修改异常ConcurrentModificationException注意:1.并发:遍历和修改同时进行2.修改:修改集合的长度(添加元素,删除元素)解决方案:1.遍历集合的同时,不修改集合的长度2.Iterator接口有一个子接口叫ListIterator在ListIterator接口定义了往集合中添加元素的方法public interface ListIterator<E>extends Iterator<E>void add(E e)  迭代器中往集合添加元素的方法void remove() 删除的是next方法取出的元素注意:1.如果使用迭代器中的add|remove方法,往集合中添加|删除元素就相当于集合和迭代器商量好了,可以往集合中添加|删除元素,迭代器就不会抛出并发修改异常了2.ListIterator迭代器只能遍历List接口下的集合(ArrayList,LinkedList),不能遍历Set接口下的集合(HashSet,LinkedHashSet)*/
public class Demo02Iterator {public static void main(String[] args) {//创建集合对象,往集合中添加元素ArrayList<String> list = new ArrayList<>();list.add("aaa");list.add(null);list.add("bbb");list.add("ccc");list.add("ddd");list.add("eee");//使用迭代器遍历list集合//使用集合中的方法iterator获取迭代器接口的实现类对象Iterator<String> it = list.iterator();//使用Iterator迭代器中的方法hasNext和next遍历集合while (it.hasNext()){String s = it.next();System.out.println(s);/*需求:增加一个判断,如果取出的元素是"ccc"就给集合添加一个新的元素"itcast"编程技巧:使用equals方法判断的时候,一般都把已知的值写在前边,防止空指针异常*/if("ccc".equals(s)){//list.add("itcast");//ConcurrentModificationException//list.remove("ddd");//ConcurrentModificationException}}System.out.println("--------------第二种解决并发修改异常的方法------------------------");//使用List接口中的方法listIterator获取ListIterator迭代器接口的实现类对象//ListIterator<E> listIterator() 返回此列表元素的列表迭代器（按适当顺序）。ListIterator<String> lit = list.listIterator();//使用迭代器中的方法hasNext和next遍历集合while (lit.hasNext()){String s = lit.next();System.out.println(s);/*需求:增加一个判断,如果取出的元素是"ccc"就给集合添加一个新的元素"itcast"*/if("ccc".equals(s)){//lit.add("itcast");//使用迭代器中的add方法,往集合中添加元素lit.remove();//删除的是next方法取出的元素}}//遍历的过程中是不会打印出新添加的元素的,遍历之后在打印就可以看到了System.out.println(list);//[aaa, null, bbb, ccc, itcast, ddd, eee]    [aaa, null, bbb, ddd, eee]}
}

5.迭代器的实现类是每个集合的内部类(了解)

6.增强for循环(重点)

注意:

​ 增强for循环底层是一个迭代器,所以在使用增强for循环遍历的时候,不能对集合的长度进行修改,否则会抛出并发修改异常

package com.itheima.demo02Iterator;import java.util.ArrayList;/*增强for循环(重点)是JDK1.5之后出现的新特性使用for循环的方式,对迭代器进行了简化增强for循环内部就是一个迭代器,对迭代器进行了封装Collection接口有一个父接口叫Iterablepublic interface Collection<E> extends Iterable<E>java.lang.Iterable<T>接口实现这个接口允许对象成为 "foreach" 语句的目标。Collection接口继承了Iterable接口,所以可以使用增强for循环Collection接口所有的实现类,都可以使用增强for循环(ArrayList,LinkedList,HashSet...)------------------------------------------------------------增强for循环的格式:重点for(集合|数组中元素的类型 变量名 : 集合名|数组名){sout(变量名);}*/
public class Demo03Foreach {public static void main(String[] args) {show03();}/*使用增强for循环遍历集合快捷键:数组名|集合名.for 增强for*/private static void show03() {ArrayList<Student> list = new ArrayList<>();list.add(new Student("张三",18));list.add(new Student("李四",19));list.add(new Student("王五",20));for (Student s : list) {//注意:增强for循环底层就是一个迭代器,在遍历的过程中不能修改集合的长度//list.add(new Student("赵六",18));//ConcurrentModificationExceptionSystem.out.println(s);}}/*使用增强for循环遍历集合好处:可以在遍历的过程中使用元素特有的方法*/private static void show02() {ArrayList<String> list = new ArrayList<>();list.add("aaa");list.add("bbbbbbb");list.add("cc");list.add("ddddd");for(String s : list){System.out.println(s+"-->"+s.length());}}/*使用增强for循环遍历数组好处:格式简单弊端:只能遍历,不能修改数组中的元素*/private static void show01() {int[] arr1 = {1,2,3};//使用普通for循环遍历数组for (int i = 0; i < arr1.length; i++) {arr1[i]*=2;System.out.println(arr1[i]);}System.out.println("arr1[0]:"+arr1[0]);System.out.println("--------------------");int[] arr2 = {1,2,3};for(int s : arr2){s *= 2;System.out.println(s);}System.out.println("arr2[0]:"+arr2[0]);}
}

第三章 泛型

1.泛型的概述

2.使用泛型的好处

package com.itheima.demo03Generic;import java.util.ArrayList;
import java.util.Iterator;/*java中的泛型:是一个伪泛型,在.java文件中有,但是.class文件中没有*/
public class Demo01Generic {public static void main(String[] args) {show02();}/*使用泛型创建ArrayList集合对象好处:1.使用什么泛型就只能存储什么类型的数据;避免向下转型抛出类型转换异常2.写上泛型存储的是什么类型,取出的就是什么类型,不用向下转型,就可以使用特有的方法弊端:1.不能什么类型的数据都存储*/private static void show02() {ArrayList<String> list = new ArrayList<>();list.add("aaa");//list.add(1);//使用迭代器遍历list集合Iterator<String> it = list.iterator();while (it.hasNext()){String s = it.next();System.out.println(s+"-->"+s.length());}}/*不使用泛型创建ArrayList集合对象好处:不使用泛型,集合默认的数据类型就是Object类型,可以存储任意数据类型的元素弊端:1.不能使用元素特有的方法(多态)2.在进行向下转型的时候,容易引发类型转换异常*/private static void show01() {ArrayList list = new ArrayList();list.add("aaa");list.add(1);//使用迭代器遍历list集合Iterator it = list.iterator();while (it.hasNext()){//存储的泛型是Object类型,取出元素类型也是Object类型Object obj = it.next();System.out.println(obj);/*多态 Object obj = "aaa"; 无法使用子类特有的方法*/if(obj instanceof String){String s = (String)obj;System.out.println(s.length());}}}
}

通过反编译软件,查看的class文件中,没有泛型

3.定义和使用含有泛型的类

package com.itheima.demo04GenericClass;/*定义和使用含有泛型的类:模拟ArrayList集合当我们不知道使用什么类型的时候,就可以使用泛型,是一个未知的数据类型可以给泛型赋值任意的数据类型:Integer,Student,Person,String...定义格式:public class 类名<泛型>{类中使用数据类型的地方,都可以使用类上定义好的泛型}什么时候确定类上泛型的数据类型创建对象的时候,确定类上泛型的数据类型;对象使用什么类型,类的泛型就是什么类型*/
public class GenericClass<C> {private C name;public C getName() {return name;}public void setName(C name) {this.name = name;}
}

package com.itheima.demo04GenericClass;public class Demo01GenericClass {public static void main(String[] args) {//创建GenericClass对象,不使用泛型,类型默认就是Object类型GenericClass gc1 = new GenericClass();//创建GenericClass对象,泛型使用String类型GenericClass<String> gc2 = new GenericClass<>();gc2.setName("aaa");String name = gc2.getName();System.out.println(name);//创建GenericClass对象,泛型使用Integer类型GenericClass<Integer> gc3 = new GenericClass<>();gc3.setName(10);Integer in = gc3.getName();System.out.println(in);}
}

4.定义和使用含有泛型的方法(重点)

package com.itheima.demo05GenericMethod;/*定义和使用含有泛型的方法(重点)泛型需要定义在方法的修饰符和返回值类型之间定义格式:修饰符 <泛型> 返回值类型 方法名(参数类型-->使用泛型){方法体;}什么时候确定泛型的数据类型:调用方法,传递的参数是什么类型,方法的泛型就是什么类型*/
public class GenericMethod {//定义含有泛型的方法(重点)public <M> void method01(M m){System.out.println(m);}//定义含有泛型的静态方法(了解)public static <S> void method02(S s){System.out.println(s);}//定义含有泛型的方法,返回值类型使用泛型(了解==>看源码)public <AAA> AAA method03(AAA aaa){System.out.println(aaa);return aaa;}
}

package com.itheima.demo05GenericMethod;import com.itheima.demo02Iterator.Student;public class Demo01GenericMethod {public static void main(String[] args) {//创建GenericMethod对象GenericMethod gm = new GenericMethod();gm.method01(1);gm.method01("aaa");gm.method01(1.1);gm.method01(true);gm.method01('@');gm.method01(new Student("徐峥",45));System.out.println("------------------------------");//通过类名.方法名(参数)可以直接调用静态方法GenericMethod.method02(1);GenericMethod.method02("aaa");GenericMethod.method02(1.1);System.out.println("------------------------------");Integer in = gm.method03(11);System.out.println(in);String abc = gm.method03("abc");System.out.println(abc);}
}

5.定义和使用含有泛型的接口

package com.itheima.demo06GenericInterface;/*定义含有泛型的接口*/
public interface GenericInterface<I> {//定义抽象方法,使用接口上的泛型,作为参数的类型public abstract void show(I i);
}

package com.itheima.demo06GenericInterface;/*含有泛型的接口:第一种使用方式定义一个类,实现含有泛型的接口,在实现接口的同时,指定接口泛型的数据类型格式:public class GenericInterfaceImpl1 implements GenericInterface<String>{重写接口中的方法,使用指定的类型Stringpublic void show(String s) { }}public class GenericInterfaceImpl1 implements GenericInterface<Integer>{重写接口中的方法,使用指定的类型Integerpublic void show(Integer integer) { }}*/
public class GenericInterfaceImpl1 implements GenericInterface<Integer>{@Overridepublic void show(Integer in) {System.out.println(in);}
}

package com.itheima.demo06GenericInterface;/*含有泛型的接口:第二种使用方式定义类实现含有泛型的接口,接口使用什么泛型,实现类就使用什么泛型实现类跟着接口走,就和定义一个含有泛型的类是一样的格式:public class GenericInterfaceImpl2<I> implements GenericInterface<I>{重写的方法使用接口上的泛型public void show(I i) { }}注意:创建对象的时候,确定泛型的数据类型;创建对象是什么数据类型,泛型就是什么数据类型*/
public class GenericInterfaceImpl2<I> implements GenericInterface<I>{@Overridepublic void show(I i) {System.out.println(i);}
}

package com.itheima.demo06GenericInterface;public class Demo01GenericInterface {public static void main(String[] args) {//创建GenericInterfaceImp1对象GenericInterfaceImpl1 gii1 = new GenericInterfaceImpl1();gii1.show(10);//创建GenericInterfaceImpl2对象GenericInterfaceImpl2<String> gii2 = new GenericInterfaceImpl2<>();gii2.show("aaa");GenericInterfaceImpl2<Double> gii3 = new GenericInterfaceImpl2<>();gii3.show(1.1);//匿名内部类new GenericInterface<String>(){@Overridepublic void show(String s) {System.out.println(s);}}.show("123123");}
}

6.泛型的通配符

package com.itheima.demo07Generic;import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;/*泛型的通配符?:代表可以接收任意的数据类型?已经由java定义好了,我们可以直接使用*/
public class Demo01Generic {public static void main(String[] args) {Collection<Integer> c1 = new ArrayList<>();c1.add(1);c1.add(2);Collection<String> c2 = new ArrayList<>();c2.add("aaa");c2.add("bbb");printCollction(c1);printCollction(c2);/*泛型的通配符只能作为方法参数的数据类型使用,不能创建对象作为数据类型使用*///ArrayList<?> list = new ArrayList<>();//list.add(1);//list.add("a");}/*定义一个方法,能遍历任意数据类型的Collection集合1.Collection c:不写泛型,默认就是Object类型2.可以使用泛型的通配符?,可以接收任意的数据类型*/public static void printCollction(Collection<?> c){//使用迭代器遍历集合;集合的泛型是?,迭代器也是?Iterator<?> it = c.iterator();while (it.hasNext()){/*it.next方法取出的元素是什么类型是Object类型,Object可以接收任意数据类型的数据*/Object obj = it.next();System.out.println(obj);}}
}

package com.itheima.demo07Generic;import java.util.ArrayList;
import java.util.Collection;/*泛型通配符的高级使用泛型的通配符: ? 代表可以接收任意数据类型的数据泛型的上限限定: ? extends E==>传递的未知类型?只能使用E的子类或者是E本身泛型的下限限定: ? super E==>传递的未知类型?只能使用E的父类或者是E本身*/
public class Demo02Generic {public static void main(String[] args) {Collection<Integer> list1 = new ArrayList<Integer>();Collection<String> list2 = new ArrayList<String>();Collection<Number> list3 = new ArrayList<Number>();Collection<Object> list4 = new ArrayList<Object>();/*Integer extends Number extends ObjectString exntends Object*/getElement1(list1);//getElement1(list2);//报错 String和Number没有关系getElement1(list3);//getElement1(list4);//报错 Object类型是Number的父类,需要Number子类//getElement2(list1);//报错 Integer是Number的子类,需要Number的父类//getElement2(list2);//报错 String和Number没有关系getElement2(list3);getElement2(list4);System.out.println("----------------------------------");//Collection集合中的方法 boolean addAll(Collection<? extends E> c);ArrayList<Integer> list01 = new ArrayList<>();list01.add(1);list01.add(2);ArrayList<Object> list02 = new ArrayList<>();//addAll的限制,传递list01集合泛型只能使用list02集合泛型的子类或者本身list02.addAll(list01);//把list01集合中的所有元素都存储到list02中System.out.println(list02);//[1, 2]ArrayList<String> list03 = new ArrayList<>();//list03.addAll(list01);}// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类public static void getElement1(Collection<? extends Number> coll){}// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类public static void getElement2(Collection<? super Number> coll){}}

第四章 数据结构

1.数据结构_栈

2.数据结构_队列

3.数据结构_数组

4.数据结构_链表

5.数据结构_红黑树