小白学习Java第十三天

于 2022-08-20 14:02:48 发布
阅读量267 收藏 1
点赞数
分类专栏： Java小白 文章标签： java 学习 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sjxxxx_/article/details/126438932
版权

复习

1.Math
java.lang,数学类，类中成员都是静态的，因此通过类名直接访问。
max()/min()/round()/pow()…
random():随机数，double，0.0~1.0
new java.util.Random().nextDouble()
.nextInt(int n)

2.System
java.lang,系统类，类中成员静态的，因此通过类名直接访问。
属性：
in，out，err
方法：
exit(0)/currentTimeMillis()

3.时间日期对象
java.util.Date:
时间日期，精确到毫秒，类中大部分方法都已过时，被日历对象Calendar替代。
构造方法：

   方法：
     getTime()
     setTime(毫秒值)
   日期格式化对象：
       java.text.DateFormat
          --SimpleDateFormat(y,M,d, h/H, m,s)
          format(Date)
          parse(text)
   Calendar:
     getInstance()
     get(字段名)
     获取/设置毫秒值：
     getTimeInMillis()
     setTimeInMillis(毫秒值)
     日历对象和日期对象互转：
        Date getTime()
        setTime(Date)

4.异常

  1. 异常的理解
    a.程序出现错误，导致不能继续运行
    b.不同的错误有对应的对象来描述，该对象中：异常名、原因、位置…
    c.处理异常的一种机制

  2. 异常继承体系
    Throwable
    –Error
    –Exception
    –RuntimeException
    异常：
    编译时异常
    运行时异常

  3. jvm的默认处理异常的机制
    哪行有问题会封装成对象，将对象逐级向上抛出，直至交给jvm，jvm采用默认处理，将错误的信息使用错误输出设备输出到控制台。

  4. 手动处理异常的方式
    捕获

    try{}、catch(异常类型){}、finally{}
   try-catch  try-catch-catch...  try-catch-finally  try-catch-catch...finally  try-finally

    声明或抛出

    throws:异常类名，用在方法上，谁调用谁处理。
throw：异常对象，用在方法内

  5. 异常通用方法
    构造方法、方法

  6. 自定义异常
    步骤：
    1.定义类继承Exception或RuntimeException
    2.调用父类构造方法

  7. 继承时重写方法的注意事项
    1、重写时父类方法有throws
    2、重写时父类方法没有throws

课程

一. 集合概述

(一) 集合和数组的区别

  1. 相同点: 两者都是数据存储容器,可以存储多个数据
  2. 不同点:
    数组:
    1)数组的长度是不可变的,集合的长度是可变的
    2)数组可以存基本数据类型和引用数据类型
    集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类

(二) 集合体系结构

在这里插入图片描述

List :

  1. 元素存取有序
  2. 元素有索引
  3. 存储的元素可以重复

Set:

  1. 元素存取无序
  2. 没有索引
  3. 不存储重复元素
/*
* 集合框架：
*   jdk1.2版本
*   集合：  容器，存储对象。
*           变量、数组、字符串缓冲区
*   集合和数组区别：
*      集合：
*          1.大小可变    2.存储不同类型的对象   3.只能存储引用类型数据
*      数组：
*          1.大小不可变  2.相同类型的数据    3.既可以存储基本也可以存储引用
*
*   单列：
*       多行一列，一个对象一个对象的存储。
*   根：
*      Collection
*         ---List ：有序(存入的顺序和取出的顺序一致)可重复
*            ---ArrayList
*            ---LinkedList
*         ---Set  :无序(存入的顺序和取出的顺序不一定一致))不可重复
*            ---HashSet
*            ---TreeSet
*     容器有这么多，因为不同的容器，存储和取出数据的方式不同(底层算法不同,数据结构),针对不同的场景使用不同的容器。
*
*
*   双列：
*     多行两列，一对数据一对数据存储
*     Map(映射)
*      --HashMap
*      --TreeMap
* */

二. 单列集合体系的详细讲解

(一) 顶层接口Collection常用功能

  1. 概述: Collection是单列集合的顶层接口,定义的是所有单列集合中共有的功能. JDK不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现.

  2. 创建Collection集合的对象:
    Collection接口，不能直接创建对象，因此找一个实现类ArrayList创建对象
    1)多态: 多态的方式 – 父类引用指向子类对象 Collection c = new ArrayList();
    2)具体的实现类创建 – 本类引用指向本类对象 ArrayList a = new ArrayList();

  3. Collection集合常用方法:
    1)boolean add(Object e): 添加元素
    2)boolean remove (Object o): 从集合中移除指定的元素
    3)void clear(): 清空集合中的元素
    4)boolean contains(Object o): 判断集合中是否存在指定的元素
    5)boolean isEmpty(): 判断集合是否为空(集合存在,没有元素), 如果集合为空, 那么返回true, 如果集合不为空 false
    6)int size(): 返回集合中元素的数量，返回集合的长度。
    7)Object[] toArray(): 返回集合的对象的数组

import java.util.ArrayList;
import java.util.Collection;

public class Demo2 {
    public static void main(String[] args) {
        //创建集合容器
        Collection  coll = new ArrayList(); //多态

        //添加
        coll.add("abc");
        coll.add(123); //自动装箱
        coll.add(null);
        coll.add(new Object());

        //清空容器
        //coll.clear();
        //移除指定元素
        //coll.remove(123);

        //获取元素个数
        //System.out.println(coll.size());

        //判断是否包含指定元素
        //System.out.println(coll.contains("abc"));
        //判断容器是否为空，元素个数是否为0，  不空=false
        //System.out.println(coll.isEmpty());


        //带All的方法
        Collection c = new ArrayList();
        c.add("abc");
        c.add("bcd");
        c.add("cde");

        //将c中的数据添加到coll中
        System.out.println(coll.addAll(c));

        //coll中是否包含c中的所有元素
        System.out.println(coll.containsAll(c));

        //将coll中与c中相同的元素，coll中删除
        //System.out.println(coll.removeAll(c));

        //取出两个容器中的相同元素存储到coll中，即去交集元素
        System.out.println(coll.retainAll(c));

        System.out.println(coll);
        System.out.println(c);

    }
}

/*
 包：java.util
* 单列集合根接口：
*   Collection：
*      接口中设计的方法应为围绕着：增 / 删  /改 /查。
* */

(二) 单列集合的遍历

2.1迭代器遍历
  1. 迭代: 更新换代, 从一个到下一个概念, 迭代相当于遍历的含义
  2. 迭代器: 专门对于单列集合进行遍历的对象, 称为迭代器
  3. 获取集合迭代器的方法
    Iterator iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到
  4. Iterator中的常用方法:
    • boolean hasNext(): 判断当前位置是否有元素可以被取出
    • E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置
    • void remove(): 删除迭代器对象当前指向的元素
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo4 {
    public static void main(String[] args) {
        Collection coll = new ArrayList();

        coll.add(new Person("小明",18));
        coll.add(new Person("小丽",19));
        coll.add(new Person("小刚",20));
        coll.add(new Person("小黑",21));
        coll.add(new Person("小白",22));

        Iterator it = coll.iterator();
        while(it.hasNext()){
//            System.out.println( ((Person)it.next()).name +"...."+ ((Person)it.next()).age);
//           Object obj =  it.next();
//           Person p = (Person)obj;

            Person p = (Person)it.next();
            //System.out.println(p.name+"..."+p.age);
            System.out.println(p);
        }
    }
}

class Person{
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
2.2增强for(foreach)遍历

  1. 概述:
    1)增强for是JDK5之后出现的,其内部原理是一个Iterator迭代器
    2)实现Iterable接口的类才可以使用迭代器和增强for简化数组和Collection集合遍历

  2. 格式:
    for(集合/数组中元素的数据类型 变量名 : 集合/数组名){
    // 已经将当前遍历到的元素封装到变量中了,直接使用变量即可
    }

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo3 {
    public static void main(String[] args) {
        Collection coll= new ArrayList();

        coll.add("abc01");
        coll.add("abc02");
        coll.add("abc03");
        coll.add("abc04");
        coll.add("abc05");

        //遍历集合元素，将集合中的元素进行依次输出，在过程中可以对指定的元素进行操作。

        //1.将集合转数组
       /* Object[] objects = coll.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }*/

        System.out.println("------------------------------------------");

        //2.集合特有的方法遍历集合元素
        //通过iterator，返回的一个迭代器，迭代器可以迭代取出Collection中的元素
        Iterator it = coll.iterator(); //多态  接口类型的引用指向了自己的实现类对象
        while(it.hasNext()){
            //System.out.println(it.next());
            Object obj = it.next();
            String s = (String)obj; //向下转型
            if(s.equals("abc02")){
                //coll.add("999");
                //coll.remove("abc02");
                it.remove();
            }
        }

        /*
        * ConcurrentModificationException:并发修改异常
        *    当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
        *    如上述的代码：coll又要遍历(迭代器操作)，又要添加元素(集合操作)
        *    解决方式：
        *       要么使用迭代器中的功能操作集合，要么使用集合中的方法操作和。
        * */




        System.out.println("-------------------------------------");
        /*
            for-each语句
               作用：遍历数组或集合。
        *    for(元素类型 变量名：被遍历的对象){
        *           ...
        *    }
             原理就是：迭代器Iterator
        * */
        for(Object  object :coll){
            System.out.println(object);
        }


        System.out.println(coll);
    }
}

(三) 有序单列集合List

3.1概述
  1. 概述: List集合是Collection接口的子接口,其下有两个常用实现类分别为 ArrayList 和 LinkedList
  2. List集合特点:
    1)有序：元素存入集合与从集合中取出的顺序一致
    2)有索引：每个元素都有自己的索引编号,从0开始,到集合长度-1为止
    3)元素可以重复：即使是值相同的几个元素，位置和索引也各不相同，可以区分这几个值
  3. List集合的特有方法:
  1. void add(int index,E element): 在此集合中的指定位置插入指定的元素
    2)E remove(int index): 删除指定索引处的元素，返回被删除的元素
    3)E set(int index,E element): 修改指定索引处的元素，返回被修改的元素
    4)E get(int index):返回指定索引处的元素
import java.util.ArrayList;
import java.util.List;

public class Demo5 {
    public static void main(String[] args) {
        //创建List集合容器
        List list = new ArrayList();
        //添加元素
        list.add("java01");
        list.add("java02");
        list.add("java03");
        list.add("java03");

        //在指定位置添加元素
        //list.add(0,"abc01");
        //根据索引获取元素
        //System.out.println(list.get(10));
        //根据索引，移除元素，并返回被移除的元素
        //System.out.println(list.remove(0));
        //根据索引，修改元素
        //list.set(0,"999");

        //注意：索引必须在，才能进行增删改查

        System.out.println(list);

    }
}

/*
* List:
*  有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。
*  用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。 索引值也是从0开始。
*  可以存储重复元素。
*  该接口中新增了一下方法，围绕着索引进行设计的。
* */
  1. 针对List集合特有的遍历方式
    1)可以通过集合的size方法获取list集合索引的范围，根据索引通过get方法可以获取指定索引的值。
    2)可以通过ListIterator迭代器，list专用，通过集合对象的listIterator()方法得到
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Demo6 {
    public static void main(String[] args) {
        List list = new ArrayList();
        //添加元素
        list.add("java01");
        list.add("java02");
        list.add("java03");
        list.add("java04");


        //1.转数组
        Object[] objects = list.toArray();
        for (int i = 0; i < objects.length; i++)
            System.out.println(objects[i]);

        System.out.println("---------------------------------------------------");
        //2.迭代器 、
        Iterator it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("-----------------------------------------------------");
        //3.for-each
        for(Object obj:list)
            System.out.println(obj);

        System.out.println("----------------------------------------");
        //4.普通for语句
        for(int i =0 ; i < list.size(); i++)
            System.out.println(list.get(i));
        System.out.println("----------------------------------------");

        //5.列表迭代器  注意：仅限于List使用。
        ListIterator listIt = list.listIterator();
        while(listIt.hasNext()) {
           Object obj = listIt.next();
           if(obj.equals("java02")){
               //listIt.add("999"); //添加
               //listIt.remove();  //移除
               listIt.set("999"); //修改
           }
        }

        System.out.println(list);
//        while(listIt.hasPrevious())
//            System.out.println(listIt.previous());

    }
}
3.2 并发修异常的产生原因和解决办法

  1. ConcurrentModificationException 并发修改异常

  2. 异常发生原因: 在迭代器遍历过程中使用集合的引用进行元素的添加或删除

  3. 解决方法:
    (1) 通过for循环遍历集合,在遍历过程中可以进行添加和删除元素
    (2) 使用迭代器中的remove()方法删除集合元素
    (3) 使用List集合的特有迭代器ListIterator, 通过List中的方法listIterator()获取, 该迭代器允许迭代期间修改列表
    – add(E e) 添加元素
    – remove() 移除元素

案例 : 定义一个List集合, 存储字符串数据”ok”,”java”,”hello”,”world”, 迭代器遍历集合元素, 如果集合中存在”hello”字符串,向集合中添加”end”字符串

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Demo7 {
    /*
    * 定义一个List集合, 存储字符串数据”ok”,”java”,”hello”,”world”, 迭代器遍历集合元素,
    * 如果集合中存在”hello”字符串,向集合中添加”end”字符串
    * */
    public static void main(String[] args) {
        List list = new ArrayList();

        list.add("ok");
        list.add("java");
        list.add("hello");
        list.add("world");

        //遍历
        /*ListIterator it = list.listIterator();
        while(it.hasNext()){
            Object obj = it.next();
            if(obj.equals("hello"))
                it.add("end");
        }*/


        for (int i = 0; i < list.size(); i++){
            if(list.get(i).equals("hello")) {
                list.add(i+1 , "end");
            }
            System.out.println(list.get(i));;
        }
//        System.out.println(list);
    }
}

(四) 数据结构之栈和队列

数据结构是计算机存储,组织数据的方式,通常情况下, 精心选择的数据结构可以带来更高的运行和存储效率

4.1栈

栈: stack,又称堆栈，它是运算受限的线性表，其限制是仅允许在标的一端进行插入和删除操作，不允许在其他任何位置进行添加、查找、删除等操作。

特点: 先进后出,（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。

在这里插入图片描述

压栈：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。
弹栈：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。

4.2队列

queue,简称队，它同堆栈一样，也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，而在表的另一端进行删除。
特点:

  1. 先进先出（即，存进去的元素，要在它前面的元素依次取出后，才能取出该元素）。例如，小火车过山洞，车头先进去，车尾后进去；车头先出来，车尾后出来。
  2. 队列的入口、出口各占一侧。例如，下图中的左侧为入口，右侧为出口
    在这里插入图片描述
4.3数据结构之数组和链表
  1. 数组:
    Array:是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。就像是一排出租屋，有100个房间，从001到100每个房间都有固定编号，通过编号就可以快速找到租房子的人。
    特点查找元素快:
    通过可以快速访问指定位置的元素
    在这里插入图片描述

增删元素慢:
指定索引位置增加元素：需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据索引，复制到新数组对应索引的位置。如下图
在这里插入图片描述

指定索引位置删除元素：需要创建一个新数组，把原数组元素根据索引，复制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中。如下图

在这里插入图片描述

  1. 链表:linked list,由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。我们常说的链表结构有单向链表与双向链表，那么这里给大家介绍的是单向链表。
    在这里插入图片描述

  2. 简单的说，采用该结构的集合，对元素的存取有如下的特点：
    多个结点之间，通过地址进行连接。例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了。

在这里插入图片描述

查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素
增删元素快： 增加元素 --> 只需要修改连接下个元素的地址即可。
删除元素：只需要修改连接下个元素的地址即可。

4.4 ArrayList和LinkedList对比分析
  1. ArrayList集合:
    (1) 在创建ArrayList集合对象的时候,会维护一个长度为10的Object类型的数组.
    (2) 当插入数据10个长度不够,这时候以1.5倍的形式进行扩容
    (3) 存储特点 : 查询快, 增删慢

在这里插入图片描述

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Vector;

public class Demo8 {
    public static void main(String[] args) {
        Vector v = new Vector();

        v.addElement("abc01");
        v.addElement("abc02");
        v.addElement("abc03");
        v.addElement("abc04");
        v.addElement("abc04");

        Enumeration en = v.elements();
        while(en.hasMoreElements()){
            System.out.println(en.nextElement());
        }

        for (Enumeration e = v.elements(); e.hasMoreElements();)
            System.out.println(e.nextElement());

        new ArrayList<>().add("abc");
    }
}
/*
* ArrayList:
*  是List接口的实现类。
*  底层采用的就是数组算法，适合做查询，线程不安全。
*
*    Vector：
*      jdk1.0版本的，底层也是可变数组实现，是一个线程安全对象。效率慢。
*    ArrayList：
*      jdk1.2版本的，底层也是可变数组实现，是一个线程不安全对象。效率高。
* */
  1. LinkedList:集合数据存储的结构是链表结构。方便元素添加、删除的集合。
    LinkedList是一个双向链表，特点 : 查询慢, 增删快, 链表结构不需要连续内存空间, 可以利用内存中零散空间

在这里插入图片描述
在这里插入图片描述

实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。这些方法我们作为了解即可：

public void addFirst(E e):将指定元素插入此列表的开头。
public void addLast(E e):将指定元素添加到此列表的结尾。
public E getFirst():返回此列表的第一个元素。
public E getLast():返回此列表的最后一个元素。
public E removeFirst():移除并返回此列表的第一个元素。
public E removeLast():移除并返回此列表的最后一个元素。

import java.util.LinkedList;

public class Demo9 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();

        list.add("01");
        list.add("02");
        list.add("03");
        list.add("04");

        //在头和尾添加元素
        list.addFirst("66");
        list.addLast("88");  //jdk1.2 返回值类型是void

//        list.offerFirst("99");
//        list.offerLast("55");  jdk1.6 返回值类型是boolean



        //头和尾的获取
//        System.out.println(list.getFirst());
//        System.out.println(list.getLast());  //jdk1.2  如果列表为空，获取时出现 NoSuchException异常

        System.out.println(list.peekFirst());
        System.out.println(list.peekLast()); //jdk1.6  如果列表为空，获取时返回null



        //头和尾的删除  返回移除的元素
        System.out.println(list.removeFirst());  //jdk1.2  如果列表为空，获取时出现 NoSuchException异常
        System.out.println(list.removeLast());

//        System.out.println(list.pollFirst());
//        System.out.println(list.pollLast()); //jdk1.6  如果列表为空，获取时返回null


        System.out.println(list);
    }
}
sjxxxx_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值