day07【Collection、泛型、数据结构】

最新推荐文章于 2024-04-10 16:13:00 发布

编程叮当猫

最新推荐文章于 2024-04-10 16:13:00 发布

阅读量136

点赞数

分类专栏：【模块1】JAVAEE进阶模块文章标签： java

本文链接：https://blog.csdn.net/qq_44845814/article/details/104801903

版权

【模块1】JAVAEE进阶模块专栏收录该内容

24 篇文章 2 订阅

订阅专栏

day07【Collection、泛型、数据结构】

反馈和复习

1.老师多照顾一下基础差的哥们
2.老师讲的太慢了  
3.学生管理系统3遍

今日内容

今日+明日+后日(非常重要!!主要讲各种集合!!)
今日:
	1.Collection(所有集合的根接口)
    2.根接口中共性方法 
    3.迭代器(用于遍历集合)    
    4.泛型(理解即可)
    5.数据结构(重点)

第一章 Collection集合【重点】

1.集合的介绍&集合和数组的区别

a.什么是集合?
    集合就是Java用来保存数据的容器
b.我们学过哪些容器??
    数组,ArrayList
    数组定义: 数据类型[] 变量名 = new 数据类型[数组的长度];
	集合定义: ArrayList<数据类型> 变量名 = new ArrayList<数据类型>();
c.数组和集合的区别在吗??【面试题】
    i.数组长度是固定的,集合的长度是可变的
    ii.数组中元素类型可以是基本类型,也可以是引用类型
    	但是集合中元素类型必须只能是引用类型,如果想保持基本类型,要写该基本类型对应的包装类
    	比如: 
			ArrayList<int> arr = new ArrayList<int>();//报错!!
			ArrayList<Integer> arr = new ArrayList<Integer>();//对的

2.集合框架的继承体系

在这里插入图片描述

3.Collection中的通用方法

增:增加
   public boolean add(E e);  添加元素,返回值表示是否添加成功!
删:删除
   public boolean remove(E e); 删除元素,返回值表示是否删除成功!
改:修改
   无!
查:获取
   无!
其他:
	public boolean contains(Object obj); 判断集合中是否包含某个元素
    public void clear(); 清空集合(把集合的元素全部删除,不是把集合置为null)
    public boolean isEmpty(); 判断集合是否为空(是指集合中是否没有元素,并不是值集合是否为null)
	public int size(); 返回集合中元素的个数
    public Object[] toArray(); 将集合转成数组  
        
public class TestCollection {
    public static void main(String[] args) {
        //1.创建一个ArrayList
        Collection<String> cc = new ArrayList<String>(); //多态
        //2.测试方法
        //添加
        cc.add("java1");
        cc.add("java2");
        cc.add("java3");
        cc.add("java4");
        System.out.println(cc);//不会打印出来地址,而是打印出来集合中的元素内容
        //删除
        boolean b = cc.remove("java4");
        System.out.println("是否删除成功:" + b);
        System.out.println(cc);
        //其他方法
        //判断是否包含
        boolean b1 = cc.contains("java2");
        System.out.println("是否包含:"+b1);
        //清空集合
        cc.clear();
        System.out.println(cc);
        //判断是否集合没有元素
        boolean b2 = cc.isEmpty();
        System.out.println("集合是否为空集合:"+b2);
        //获取集合的长度
        int size = cc.size();
        System.out.println("集合中元素的个数:"+size);
        //将集合转成数组
        Object[] objects = cc.toArray();
        System.out.println(objects[0]);
        System.out.println(objects[1]);
        System.out.println(objects[2]);
    }
}

第二章 Iterator迭代器【重点】

1.集合迭代器的介绍和使用

a.迭代器(iterator):
	用于遍历集合的对象(集合有无索引,均可使用迭代器来遍历,迭代器遍历集合时是不需要索引的!!!)
b.如何使用迭代器?
   i.获取要遍历的集合的迭代器对象
   ii.调用迭代器对象.hasNext();
   iii.调用迭代器对象.next();

public class TestIterator {
    public static void main(String[] args) {
        //1.创建一个集合
        Collection<String> cc = new ArrayList<String>();
        //添加
        cc.add("java");
        cc.add("php");
        cc.add("python");
        cc.add("c++");
        cc.add("c");
        cc.add("c#");
        cc.add("Objective-C");
        //使用迭代器
//        i.获取要遍历的集合的迭代器对象
        Iterator<String> it = cc.iterator();
//        ii.调用迭代器对象.hasNext();
//        iii.调用迭代器对象.next();
        while (it.hasNext()){
            String ss = it.next();
            System.out.println(ss);
        }
    }
}

迭代器的注意事项(2个异常):

a.NoSuchElementException: 没有此元素异常
    出现原因: 迭代器的hasNext返回false,再调用next方法,就会出现此异常
b.ConcurrentModificationException: 并发修改异常
    出现原因: Java的迭代器规定,使用迭代器的过程中,不能向集合中增删元素(不能影响集合的长度)
        	否则就会抛出并发修改异常
结论:
	a.使用迭代器时,必须先使用hasNext方法判断,且判断结果为true,才能调用next方法
    b.使用迭代器时,我们应该尽量只做遍历(绝对不允许直接向集合中增删元素)

2.迭代器的原理(画图)

迭代器的底层使用了"指针原理"

在这里插入图片描述

3.增强for循环【重点】

a.什么是增强for循环
    实际上是一种简便格式(语法糖),实际上是迭代器的语法糖
    
b.增强for循环的用法:
	for(数据类型 变量名:集合/数组){
        System.out.println(变量名);
    }

public class TestForeach {
    public static void main(String[] args) {
        //1.增强for循环,可以快速遍历集合/数组
        //a.数组
        int[] arr = {10,20,30,40,50,60,70};

        for(int num : arr){
            System.out.println(num);
        }
        //b.集合
        ArrayList<String> arr2 = new ArrayList<String>();
        arr2.add("java1");
        arr2.add("java2");
        arr2.add("java3");
        arr2.add("java4");
        arr2.add("java5");
        arr2.add("java6");

        for(String s : arr2){
            System.out.println(s);
        }
    }
}
c.增强for循环底层使用的就是迭代器
    怎么证明呢??
    	a.看源码(目前你是看不懂)
    	b.如果在使用增强for的过程中向集合中添加或者删除元素会怎么样??
    		和使用迭代器时一样也会抛出 ConcurrentModificationException
    注意:和使用迭代器一样,增强for就是用于单纯的遍历集合,不要在遍历的过程中增删元素!!

第三章泛型【理解】

1.什么是泛型

泛型是JDK1.5的新特性
比如:
	在JDK1.5之前,创建集合: ArrayList arr = new ArrayList(),集合中可以保存任意的对象
    在JDK1.5时候,创建集合: ArrayList<具体的引用类型> arr = new ArrayList<具体的引用类型>();

什么是泛型:
	是一种不确定的类型,程序员使用时再确定下来
泛型的格式:
	<E>,<P>,<MVP> 
    <K,V>

2.泛型的好处

public class TestGeneric {
    public static void main(String[] args) {
        method2();
    }
    //不使用泛型
    public static void method1(){
        //1.创建集合,但是不用泛型
        ArrayList arr = new ArrayList();
        //问题: 没写泛型,集合可以保存什么类型?? Object类型
        arr.add("java");
        arr.add(10);
        arr.add(3.14);
        arr.add(true);
        arr.add('A');
        //2.取出
        for(Object s :arr){
            String ss = (String)s;
            System.out.println("ss的长度是:"+ss.length());
        }
        //不使用泛型,就必须用到向下转型,可能转型的过程中还会引发ClassCastException
        //添加元素一时爽,取出元素火葬场
    }

    //使用泛型
    public static void method2(){
        //1.创建集合,并且使用泛型
        ArrayList<String> arr = new ArrayList<String>();
        //2.添加
        arr.add("java");
        arr.add("10");
        arr.add("3.14");
        arr.add("true");
        arr.add("A");
        //3.取出
        for(String s:arr){
            //a.避免向下转型的麻烦
            //b.也避免了类型转换异常
            System.out.println(s+"的长度是:"+s.length());
        }
    }
}

总结泛型的好处:
	a.避免了强转(向下转型)的麻烦
    b.将运行时期的ClassCastException，转移到了编译时期变成了编译失败。 
    c.总之: JDK1.5之后,Java强烈推荐(必须)使用泛型!!!!

3.泛型的定义和使用【理解】

泛型可以定义在类上,方法上,接口上!!!

泛型类

泛型可以定义在类上
    
泛型类的定义:
	/**
     * 泛型类
     */
    public class MyArrayList<E> {
        //就是把E当做某种数据类型使用
        private E ee;

        public E getEe() {
            return ee;
        }

        public void setEe(E ee) {
            this.ee = ee;
        }
    }
泛型类的使用:
	public class TestMyArrayList {
        public static void main(String[] args) {
            //1.使用泛型类,MyArrayList
            MyArrayList<String> arr = new MyArrayList<String>();
            //此时arr中集合对象中没有E了!!所有E都变成String
            arr.setEe("java");
            String ee = arr.getEe();
            System.out.println(ee);

            //2.使用泛型类,MyArrayList
            MyArrayList<Integer> arr1 = new MyArrayList<Integer>();
            //此时arr1中集合对象中没有E了!!所有E都变成Integer
            arr1.setEe(100);
            System.out.println(arr1.getEe());
        }
    }

泛型方法

泛型定义在某个方法上

泛型方法的定义:
	public class Dog {
        /**
         * 泛型方法
         */
        public <E> void show(E num){
            System.out.println(num);
        }
    }

泛型方法的使用:
	public class TestDog {
        public static void main(String[] args) {
            //1.创建Dog对象
            Dog dd = new Dog();
            //2.调用方法
            dd.show("java");
            dd.show(10);
            //严格的方式
            dd.<String>show("java");
            dd.<Integer>show(10);
        }
    }

泛型接口

泛型定义在某个接口上
    
泛型接口的定义:
	/**
     * 泛型接口
     */
    public interface MyInterface<MVP> {
        //在接口中就可以使用MVP
        public abstract void show(MVP mm);
        public abstract void eat(MVP mm);
    }

泛型接口的使用:
	//泛型接口的泛型,可以在以下两种情况中确定
    //a.定义一个实现类 实现 该接口时,确定MVP的具体类型
    class MyClass1 implements MyInterface<Integer>{
        //重写抽象方法
        @Override
        public void show(Integer mm) {

        }
        @Override
        public void eat(Integer mm) {

        }
    }

    //b.定义一个实现类 实现 该接口时,保留泛型
    class MyClass2<MVP> implements MyInterface<MVP>{

        @Override
        public void show(MVP mm) {

        }

        @Override
        public void eat(MVP mm) {

        }
    }
    //此时实现类 其实就是一个泛型类,创建该类的对象时,可以确定泛型的具体类型
    // MyClass2<String> mc = new MyClass2<String>();
    // MyClass2<Integer> mc = new MyClass2<Integer>();

	//c.丢弃泛型
	//c.也可以直接丢弃泛型,此时所有的泛型都会变成Object
    class MyClass3 implements MyInterface{
        @Override
        public void show(Object mm) {

        }
        @Override
        public void eat(Object mm) {

        }
    }

总结

在开发我们很少自定义泛型类.泛型方法,泛型接口,所以我们的重点是别人定义好了一个泛型类(ArrayList<E>)
    我们会使用它即可!!
    ArrayList<具体的类型> arr = new ArrayList<具体的类型>();

4.泛型统配符【理解】

a.什么是泛型统配符:
	当集合中泛型不确定为何种类型时,那么我可以使用泛型通配符,表示何种泛型均可
		ArrayList<String>
        ArrayList<Integer> 
        ArrayList<?>
        
public class TestDemo {
    public static void main(String[] args) {
        //1.定义三个集合
        ArrayList<String> arr1 = new ArrayList<String>();
        ArrayList<Integer> arr2 = new ArrayList<Integer>();
        ArrayList<Double> arr3 = new ArrayList<Double>();
        //2.调用方法
        method(arr1);
        method(arr2);
        method(arr3);
        //Java要求调用方法时,不仅要数据类型一样,泛型必须也一样,否则编译报错!!
    }

    //方法,要求该方法可以接收 以上三个集合中的任意一个
    public static void method(Collection<?> arr) {

    }
}

5.泛型的上下限【重点】

举例:
	比我线下上课时候,你们班的辅导老师,邀请大家吃饭,消费金额每个人是50-1000RMB之间
    下限:50RMB 
	上限:1000RMB
        
泛型上下限:
	<?> 什么泛型都是OK的
    <? extends Animal>,叫泛型的上限,表示该泛型必须是Animal本类或者其子类(Dog,Cat) 
    我们可以理解为: "<? <= Animal>"    
        
    <? super Student>,叫泛型的下限, 表示该泛型必须是Student本类或者其父类(Person,Object)   
    我们可以理解为: "<? >= Student>"  
        
举例:
public class TestDemo02 {
    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>();
        //Number是 Integer的父类
        // Object
        //   子类 String Number
        //               子类 Integer
        //调用方法1
        getElement1(list1); //OK
        getElement1(list2);
        getElement1(list3); //OK
        getElement1(list4);

        //调用方法2
        getElement2(list1); // 0
        getElement2(list2); // 0
        getElement2(list3); // 1
        getElement2(list4); // 1
    }

    //要求:泛型必须是Number 或者 Number的子类(上限)
    public static void getElement1(Collection<? extends Number> coll) {

    }

    //要求:泛型必须是Number 或者 Number的父类(下限)
    public static void getElement2(Collection<? super Number> coll) {

    }
}

第四章数据结构【重点】

1.什么是数据结构

是容器保存数据的方式!!
    
    举例: 我租了一间仓库,卖大米,我去批发市场买进很多袋大米(黑米,薏米,小米,...)
          我把一袋一袋大米写上编号,存入仓库
         a.平铺保存(都放地上,不要叠起来)
         b.堆叠保存(一直堆叠直到顶到屋顶)
    思考:a和b两种结构哪种好??
        a.容易取出
        b.节省空间

2.常见的4+1种数据结构

我们需要掌握前四种数据结构

栈结构
```
特点: 先进后出,后进先出
```
队列结构
```
特点: 先进先出,后进后出
```
数组结构
```
特点: 查改快,增删慢!
```
链表结构
```
特点: 查改慢,增删快!
```

在这里插入图片描述

我们还需要了解另一种数据结构

树结构【了解即可】

树结构--->二叉树---> 二叉查找树 ---> 平衡树二叉 ---> 红黑树【了解】
红黑树的特点：
    查询效率非常恐怖！！！！

总结

1.Collection 集合根接口【重点】
    i.集合继承体系
    ii. Collection中定义的通用方法
    iii.明白集合和数组的区别
    
2.迭代器【重点】
    i.迭代器使用的三个步骤: 获取迭代器,判断有没有下一个,取出下一个元素
    ii.增强for循环使用(底层使用就是迭代器)   
    iii.迭代器和增强for使用过程 不能增删元素   
        
3.泛型【理解】
    i.泛型怎么写 <E>
    ii.泛型类,泛型接口,泛型方法怎么定义和使用
    iii.泛型通配符以及上下限【重点】
        <?> 代表任意泛型均可
        <? extends 类名> 上限
        <? super 类名> 下限
4.数据结构【重点】
    栈结构: 先进后出
    队列结构: 先进先出
    数组结构: 增删慢,查询快
    链表结构: 增删快,查询慢
    红黑树: 查询效率非常恐怖!!  【记住结论即可】

编程叮当猫

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day07【Collection、泛型、数据结构】

day07【Collection、泛型、数据结构】反馈和复习1.老师多照顾一下基础差的哥们2.老师讲的太慢了 3.学生管理系统3遍今日内容今日+明日+后日(非常重要!!主要讲各种集合!!)今日: 1.Collection(所有集合的根接口) 2.根接口中共性方法 3.迭代器(用于遍历集合) 4.泛型(理解即可) 5.数据结构(重...
复制链接

扫一扫