后端学习第二周

最新推荐文章于 2024-11-05 15:26:40 发布

m0_74973803

最新推荐文章于 2024-11-05 15:26:40 发布

阅读量443

点赞数

文章标签：学习 java jvm

本文链接：https://blog.csdn.net/m0_74973803/article/details/129868000

版权

一、Java常用类

1. String类

看着代码讲解

package com.bluemsun.TestString;

import java.lang.ref.SoftReference;

public class TestString {
    public static void main(String[] args) {

        String s1 = "core Java";
        String s2 = new String("Core Java");//也可以这样定义
        String s3 = null;
        String s4 = "";//s3和s4不一样
//        System.out.println(s3.length());//返回空指针异常
        System.out.println(s1.charAt(3));//提取下标为3的字符
        System.out.println(s1.length());//字符串的长度
        System.out.println(s1.equals(s2));//比较两个字符串是否相同，第一个字符有大小写差异，返回false
        System.out.println(s1.equalsIgnoreCase(s2));//比较两个字符串是否相同，忽略大小写，返回true
        System.out.println(s1.indexOf("Java"));//s1中是否包含"Java"，是的话返回其位置下标
        System.out.println(s1.indexOf("apple"));//s1中是否包含"apple"，否，返回-1
        String s5 = "I love Java. What is Java?";
        System.out.println(s5.indexOf("Java"));//从前往后找, 返回7
        System.out.println(s5.lastIndexOf("Java"));//从后往前找，返回21，是"J"所在的位置

1. main函数中s1和s2的使用了String类对象的两种定义方式

2. s3和s4不一样

3. s3的值为null，如果引用s3的方法和属性，会返回空指针异常

4. chatAt方法提取字符串中的字符

5. equals方法比较两个字符串是否相同，equalsIgnoreCase方法也是比较字符串是否相同，但忽略字母的大小写。

6. indexOf方法，判断是否含有某段字符串，是，返回其位置下标，否，返回-1。

7. lastIndexOf方法，从后往前找，返回值的方法同上。

package com.bluemsun.TestString;

import java.lang.ref.SoftReference;

public class TestString {
    public static void main(String[] args) {

        String s;
        String s6 = "How are you?";
        System.out.println(s6.startsWith("How"));//是否以"How"开头，是的，返回true
        System.out.println(s6.endsWith("you"));//是否以"you"结尾，否，是以"you?"结尾的，返回false

        //String是不可变字符串，以下全部返回的是新字符串，s6、s7始终没有被更改

        s = s6.replace(' ','&');//将s6中的字符' '替换为'&'，返回的是全新的字符串
        System.out.println("s6:" + s6);//输出的依然是未替换之前的字符串
        System.out.println("s:" + s);//输出替换之后的
        s = s6.substring(4);//提取子字符串，从下标为4的字符开始
        System.out.println(s);
        s = s6.substring(4, 7);//提取字符串，[4, 7)，7不取
        System.out.println(s);
        s = s6.toLowerCase();//转小写
        System.out.println(s);
        s = s6.toUpperCase();//转大写
        System.out.println(s);
        String s7 = "  How old are you??   ";
        s = s7.trim();//去除首尾的空格，中间不去除
        System.out.println(s);
        String s8 = "  How old are you??   ";
        String s9 = new String("  How old are you??   ");
        System.out.println(s7 == s8);//"=="比较的是是否是同一个对象，返回true
        System.out.println(s7 == s9);//"=="比较的是是否是同一个对象，返回false，具体看视频里的内存分析
    }
}

8. startsWith方法，判断是否为某段字符串开头，返回值为boolean型。

9. endsWith方法，判断是否为某段字符串结尾，返回值为boolean型。

10. replace方法，将字符串中某字符替换为另一字符。

11. String是不可变字符串，这意味着对String类做的改变不会改变字符串本身，而是重新创造一个新字符串，故replace方法以及以下的提取子串、转换为大写、转换为小写、去除首尾空格这些方法都不会改变原字符串本身。

12. subString方法，如果输入为一个整数，则从该整数下标开始提取到最后；如果输入为两个整数，则从第一个整数下标开始提取到第二个下标。

13. toLowerCase和toUpperCase方法，将字符串中每个字母字符转为小写和大写。

14. trim方法，去除首尾的空格，中间空格不去除。

15. == ，比较两个字符串是否是同一个同一个对象，和equals方法不一样。

2.StringBuffer和StringBuilder可变字符串序列

1. StringBuffer线程安全，做线程同步检查，效率较低

2. StringBuilder线程不安全，不做线程同步检查，效率较高，一般采用此类。

3. 与String不同在于其父类的value数组没有final修饰。

4. append方法，为StringBuilder对象添加字符序列，但仍然返回自身对象

5. delete方法，传入两个整数，可以删除从start开始到end为止（ [start, end) ）的一段字符序列，仍然返回自身对象。

6. deleteCharAt方法，删除指定位置上的char，仍然返回自身对象。

7. 重载的insert方法，在指定位置插入字符序列。

8. reverse方法，将字符串逆序。

9. toString返回次序列中数据的字符串表示形式。

10. 其他和string类相似的方法，indexOf、subString、length等。

不作演示了，用到的时候再详细了解。

11. 工作中遇到字符串拼接、删除等情况，用StringBuilder。

3. Date类

1. Date() 分配一个Date对象，并初始化此对象为系统当前的日期和时间，可以精确到毫秒。

2. Date(long date) 分配 Date 对象并初始化此对象，以表示自从标准基准时间以来的毫秒数。

3. boolean equals(Object obj) 比较两个日期的相等性。

4. long getTime() 返回毫秒数。

5. String toString() 把此 Date 对象转换为以下形式的String：dow mon dd hh:mm:ss zzz yyyy其中：dow是一周中的某一天。

4. DateFormat类

1. DateFormat类把时间对象转化成指定格式的字符串。反之，把指定格式的字符串转化成时间对象。

2. DateForma是一个抽象类，一般使用它的的子类SimpleDateFormat类来实现。

5. Calendar类

1. Calendar类是一个抽象类，为我们提供了关于日期计算的功能，比如:年、月、日、时、分、秒的展示和计算。

2. GregorianCalendar是Calendar的子类，表示公历。

6. Math类

1. C语言中接触过的，如abs、sqrt、pow、max、min等。

2. ceil、floor、round，分别是向上取整、向下取整、四舍五入取整。

3. 常用常量：PI和E。

4. random，获取 [0, 1) 的随机一个小数。

5. 三角函数，cos、sin、tan、acos、asin、atan。

7. Random类

1. 用于生成随机数。

2. nextDouble方法，生成 [0, 1) 的随机double型数据。

3. nextFloat方法，生成 [0, 1) 的随机float型数据。

4. nextInt方法，生成int类型允许范围内的整型数据；如果有一个整型输入bound，则随机生成 [0, bound) 之间的int类型整数。

5. nextBoolean方法，随机生成true或false。

8. File类

1. File类常见构造方法。public File(String pathname))。以pathname为路径创建File对象，如果pathname是相对路径，则默认的当前路径在系统属性user.dir 中存储。

2. 创建文件或目录的方法列表

方法	说明
createNewFile()	创建新的File
delete()	删除File对应的文件
mkdir()	创建一个目录;中间某个目录缺失，则创建失败
mkdirs()	创建多个目录;中间某个目录缺失，则创建该缺失目录

3. 访问属性的方法列表

方法	说明
public boolean exists()	判断 File是否存在
public boolean isDirectory()	判断File是否是目录
public boolean isFile()	判断File是否是文件
public long lastModified()	返回File最后修改时间
public long length()	返回File大小
public String getName()	返回文件名
public String getPath()	返回文件的目录路径

二、异常类

工作中程序可能遇到各种不同的意外问题，异常机制就是用于对这些情况进行合理的处理和解决，其本质为一个当程序出现异常，程序安全的退出、处理完后继续执行的机制。

1. 异常类的分类

Exception 异常类是 Throwable类的子类。Throwable类的另一个子类是Error类。异常类分为 CheckedException 和 RuntimeException 两部分。

1. RuntimeException 运行时异常

1) ArithmeticException ：试图除以0。

解决：添加变量不等于0的判断。

2) NullPointException 空指针异常

解决：添加变量不等于null的判断。

3) ClassCastException 类型转化异常。

将Dog类对象转换为Cat类变量。

解决：添加变量是否 instanceof 该类的判断。

4) ArrayIndexOutOfBoundsException 数组越界异常

解决：添加变量在 [0, arr.length()) 的判断。

5) NumberFormatException 数字格式化异常

String str = "1234abcd";
System.out.println(Integer.parseInt(str));

此时出现数字格式化异常。

解决：

        String str = "1234abcd";
        Pattern p = Pattern.compile("^\\d+$");
        Matcher m = p.matcher(str);
        if(m.matches()){
            System.out.println(
                    Integer.parseInt(str);
            );
        }

2. CheckedException 已检查异常

CheckedException在编译时处理，否则无法通过编译。

两种处理方式：

1. “try/catch” 捕获异常机制

2. “throw” 声明异常

2. 捕获异常机制

我们用 “try/catch” 语句实现

如上图所示，程序从try部分开始运行，若遇到异常语句，则直接跳至catch部分的相应语句执行。若未遇到异常语句，不执行catch部分语句。最后一定执行finally部分的语句。

几个注意点：

1. 当异常处理的代码执行结束以后，不会回到 try 语句去执行尚未执行的代码。

2. 如果异常类之间有继承关系，先捕获子类异常再捕获父类异常。

3. 通常在finally中关闭已打开的资源，比如：关闭文件流、释放数据库连接等。

3. 声明式异常处理

1. CheckedException 产生时，不一定立刻处理它，可以把异常throws，由调用者处理

2. 一个方法抛出多个已检查异常，就必须在方法的首部列出所有的异常。

三、容器

Java数组的使用不是很方便，也有像空间浪费、效率不高等不足。于是我们引入容器的概念。

1. Java容器分类

Collection和Map区别在于，Collection存储“一列”，而Map存储“两列”。

2. Collection

其中包括List系列集合和Set系列集合。

List系列的元素有序、可重复、有索引；Set系列的元素五无序、不重复、无索引。

1) Collection的一些基本方法：

注意：Collection是一个接口，我们不能直接创建他的对象。所以，现在我们学习他的方法时，只能创建他实现类的对象。

1. add(E e)方法，把给定的对象添加到当前集合中，返回boolean类型，若可以添加（List和没有相同元素的Set），返回true，若无法添加（已有相同元素的Set），返回false。

2. clear()方法，清空集合中所有的元素。

3. remove(E e)方法，把给定的对象在当前集合中删除，返回boolean类型，类似于add的返回值，可以删除时返回true，否则返回false。

4. contains(object obj)方法，判断当前集合中是否包含给定的对象，返回值为boolean类型。

5. isEmpty()方法，判断当前集合是否为空，返回值为boolean类型。

6. size()方法，返回集合中元素的个数/集合的长度。

2) 三种遍历方式

1. 迭代器遍历

2. 增强for遍历

3. Lambda表达式遍历

3) List的常用方法和遍历方式

1. add(int index,E element)方法，在此集合中的指定位置插入指定的元素。

2. E remove(int index)方法，删除指定索引处的元素，返回被删除的元素。

3. E set(int index,E element)方法，修改指定索引处的元素，返回被修改的元素。

4. E get(int index)方法，返回指定索引处的元素。

5. 列表迭代器遍历。

6. 普通for遍历。

四、泛型

在创建经济核对对象的时候，如果我们没有给集合指定类型，将默认所有的数据类型都是Object类型，此时我们可以往集合中添加任意的数据类型。但是这伴随着一个坏处，我们在获取集合的数据的时候，无法使用其特有的行为。于是在JDK5中推出了泛型，可以在添加数据的时候就把类型进行统一。于是我们可以在编译阶段约束操作的数据类型，并进行检查。

1. 泛型添加

、添加泛型方法如下代码所示，此时无法添加除String类外的其他类型数据。

        ArrayList<String> list = new ArrayList<>();//添加泛型的格式，这样list的元素就被指定为string类了
        list.add("aaa");
        list.add("bbb");
        list.add(123);//不能添加整型

注意：

1) 泛型只能支持引用数据类型，要传入基本数据类型要用其对应的包装类。

2) 指定泛型的具体类型后，传递数据时，可以传入该类型或者其子类类型。

2. 泛型类

使用场景：当一个类中，某个变量的数据类型不确定时，就可以定义带有泛型的类。如

public class MyArryList<E>

此时可以在创建该对象时确定E的类型。

3. 泛型方法

方法中形参类型不确定时，可以使用类名后面定义的泛型<E>。如下：

public class MyArrayList<E>{
    public boolean add(E e){
        obj[aize] = e;
        size++;
        return true;
    }
}

如果该类中只有一个方法的形参不确定，可以把泛型定义在方法上面，如下：

public class MyArrayList{
    public <E> boolean add(E e){    
        obj[aize] = e;
        size++;
        return true;
    }
}

3. 泛型接口

泛型接口的定义格式与上面的泛型类相似，我们重点介绍泛型接口的使用。

1) 在实现类中给出具体类型，如下：

public class MyArrayList implements List<String> {
    
    @Override
    public boolean add(String s) {
        return false;
    }
}

此时实现类中使用了<E>的泛型类会自动变为我们给出的具体类型。

2) 实现类延续泛型，创建实现类对象时再确定类型，如下：

public class MyArrayList<E> implements List<E> {

    @Override
    public boolean add(E e) {
        return false;
    }
}

此时实现类中的泛型类依然使用E类型。此时创建实现类的对象时要给出具体的类型。

4. 泛型的通配符

使用泛型我们可以接受任何数据类型，但是有时候我们不知道传递的具体数据类型，但是希望只能传递某些数据类型，此时我们可以使用泛型的通配符。

泛型的通配符也表示不确定的类型，但是它对传入的类型进行范围的限定。有两种方式：

1) <? extends E> 表示可以传递E或者E的所有子类类型。

2) <? super E> 表示可以传递E或者E的所有父类类型。

应用场景：

1. 如果我们在定义类、方法、接口的时候，如果类型不确定，就可以定义泛型类、泛型方法、泛型接口。

2. 如果类型不确定，但是能知道以后只能传递某个继承体系中的，就可以定义泛型的通配符。