Java复习笔记-13

最新推荐文章于 2024-08-30 18:40:43 发布

puputt

最新推荐文章于 2024-08-30 18:40:43 发布

阅读量43

点赞数

文章标签： java 笔记开发语言

本文链接：https://blog.csdn.net/puputt/article/details/132459146

版权

API --Object&String

1 API介绍

API ( Application Programming Interfaces) 应用程序接口

需要先学会查看API文档

2 Object类

Object 类是类层次结构的根，是所有类的父类，所有对象（包括数组）都实现此类的方法。

2.1 Object常用方法

clone()

	 // CloneNotSupportedException 克隆不支持异常   如果一个类想要被克隆，需要实			现Cloneable接口
		public class TestDemo implements Cloneable
   	 // 克隆方法 会把对象拷贝一份新的副本 里面的属性值也会全部拷贝
        TestDemo clone = (TestDemo) testDemo.clone();
        System.out.println(clone.i);
        System.out.println(clone.name);

finalize()

方法已废弃，不推荐但仍然可以使用

// 通知GC回收对象，但是GC不一定执行
    testDemo.finalize();
    System.gc();// 这两个方法效果一样

getClass()

getClass() 方法是获取运行阶段时的真正类型

    Object obj = "abc";
    System.out.println(obj.getClass());

hashCode()

获取对象的哈希码值

// 获取对象的哈希码值
// 哈希码值是根据哈希散列算法计算出来的一个值
// 这个值会随机散落在int类型(将近43亿)的值的范围内
// 我们一般认为同一个类的不同对象的哈希码值是唯一的
// 往往会根据哈希码值来决定对象的内存存储
Object obj2 = new Object();
System.out.println(obj2.hashCode());

toString()

默认打印对象的地址值，一般子类都会重写

@Override
public String toString() {
    return "Person{" +
            "name='" + name + '\'' +
            ", age=" + age +
            ", address='" + address + '\'' +
            ", email='" + email + '\'' +
            ", password='" + password + '\'' +
            '}';
}

equals()

默认比较地址，一般子类都会重写

public static void main(String[] args) {
    User user = new User();
    user.name = null;
    user.age = 18;
    user.gender = '女';

    User user1 = new User();
    user1.name = null;
    user1.age = 18;
    user1.gender = '女';

    System.out.println(user.equals(user1));
    // == 对于基本数据类型是比较值   对于引用数据类型是比较地址
    System.out.println(user == user1);
}

//重写思路，也可以用快捷键重写
class User{
    String name;
    int age;
    char gender;


    @Override
    public boolean equals(Object obj) {
        // 判断地址是否相同
        if (this == obj){
            return true;
        }

        // 判断参数是否为空
        if (obj == null){
            return false;
        }
        // 判断类型是否一致
        if (this.getClass() != obj.getClass()){
            return false;
        }
        // 判断属性值是否一致
        User user = (User) obj;
        // 判断年龄是否一致
        if (this.age != user.age)
            return false;

        // 判断性别是否一致
        if (this.gender != user.gender)
            return false;

        // 判断姓名是否一致
        if (this.name == null){
            if (user.name != null)
                return false;

        }else if (!this.name.equals(user.name))
            return false;

        return true;
    }
}

3 String类

String类是被final修饰的类，是一个最终类，继承Object。

字符串是常量，是不可变的。并且是被共享的。

字符串本质上是一个字节数组。

3.1 字符串内存存储

在这里插入图片描述

3.2 字符串拼接问题

3.2.1 字符串+号拼接

        String s1 = "ab";
        String s2 = "a" + "b";
        String s3 = "a";
        s3 += "b";
        // s2在编译期间也是字面量，结果是"ab"
        System.out.println(s1 == s2);//true
        // s3+="b" 由于编译是一行行编译的，所以在编译阶段不认识s3，所以这里是变量
        // 实际上是相当于
//        s3 = new StringBuilder(s3).append("b").toString();
        // s3 = new String("ab");
        // 上面这一行代码就产生了一个新的String对象,地址发生了改变
        System.out.println(s1 == s3);//false

String s3 = "a";

s3 += "b";
产生了几个对象?
    
5个对象
    "a"  
    "b"
    "ab"
    new StringBuilder();
    new String();

字符串使用+号拼接，效率非常非常低.

3.2.2 StringBuilder拼接字符串

StringBuilder用于大量字符串的拼接

        // 获取计算机元年到当前时间的毫秒值
        long begin = System.currentTimeMillis();
//        String str = "";
//        for (int i = 0;i < 100000;i++){
//            str += "a";
//        }

        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0;i < 100000;i++){
            stringBuilder.append("a");
        }
        // 把StringBuilder转换成String
        String str = stringBuilder.toString();
        long end = System.currentTimeMillis();
        System.out.println(end - begin);

注意:如果有大量的字符串拼接，尽量不要使用 + 来进行拼接，执行效率非常低。

3.3 String的常用方法

charAt() 获取指定索引的字符

length() 获取字符串的长度

toCharArray() 将字符串转换成字符数组

new String(char[] cs) 将字符数组转换成字符串

new String(char[] cs,int offset,int count) 将字符数组的一部分转换成字符串

 // 字符串常用的方法
        String str = "abcdfesdf";
        // charAt方法 获取指定索引处的字符  索引是从0开始
        char c = str.charAt(3);
        System.out.println(c);
        // 获取字符串的长度
        System.out.println(str.length());
        // StringIndexOutOfBoundsException 字符串索引越界
        // ArrayIndexOutOfBoundsException  数组索引越界
//        System.out.println(str.charAt(9));
        // 将字符串转换成字符数组
        char[] chars = str.toCharArray();
        System.out.println(chars);

        // 将字符数组转换成字符串
        char[] cs = {'a','e','d','g','p','r'};
        String s = new String(cs);
        System.out.println(s);
        // 将字符数组的一部分转换成字符串
        // 参数一:字符数组
        // 参数二:要转换的起始索引
        // 参数三:要转换的长度
        String s1 = new String(cs, 1, 3);
        System.out.println(s1);

3.4 字符串练习

输入一个字符串以及两个数字，按照输入的数字对字符串进行截取

hafdefefer 3 6 -->表示从字符串的索引为3的位置开始，截取到索引为6(不包含索引为6)的位置 def

private static void practice1() {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        // 要截取的字符串的开始索引
        int begin = scanner.nextInt();
        // 要截取的字符串的结束索引
        int end = scanner.nextInt();
        // 判断索引是否合法
        if (begin < 0 || end > str.length() || begin > end){
            return;
        }
        // 先将字符串转换成字符数组
        char[] chars = str.toCharArray();
        // 将一部分的字符数组转换成字符串
        String s = new String(chars, begin, end - begin);
        System.out.println(s);
    }

输入一个字符串，统计每一个字符出现的次数

aaabbbcccddd a:3 b:3 c:3 d:3

    private static void practice4() {
        // 输入一个字符串，统计字符出现的个数
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();

        // 定义一个布尔数组,存放字符是否被统计过的标记
        boolean[] bs = new boolean[str.length()];

        // 遍历布尔数组
        for (int i = 0; i < bs.length; i++) {
            // 判断当前位置的内容是否被统计过
            if (bs[i]) {
                continue;
            }

            // 获取当前位置的字符
            char c = str.charAt(i);
            // 定义字符出现的次数
            int count = 0;
            for (int j = i; j < str.length(); j++) {
                if (c == str.charAt(j)) {
                    count++;
                    bs[j] = true;
                }
            }
            System.out.println(c + ":" + count);
        }
    }

3.5 String常用方法

compareTo方法

		String str1 = "abc";
        String str2 = "d";
        // 字符串在底层会转换成字节数组-->可以转换成字符数组
        // 在比较两个字符数组的时候，是进行逐位比较
        // 如果对应位置上的字符比较之后不相等
        // 那么返回这两个字符之差
        // 如果相等，则比较下一位
        // 如果每一位都相等，则返回两个字符串的长度之差
        // 如果返回的是一个正数，对象 > 参数
        // 如果返回的是一个负数，对象 <参数
        System.out.println(str1.compareTo(str2));

使用compareTo方法对于字符串数组进行升序排序

String[] arr = {"re","ag","ewg","he","tr","hh"};

使用冒泡排序

private static void practice5() {
        String[] arr = {"re","ag","ewg","he","tr","hh"};

        for (int i = 1;i < arr.length;i++){
            for (int j = 1;j <= arr.length - i;j++){
                if (arr[j - 1].compareTo(arr[j]) > 0){
                    String s = arr[j - 1];
                    arr[j - 1] = arr[j];
                    arr[j] = s;
                }
            }
        }
        for (String s : arr) {
            System.out.println(s);
        }
    }

concat方法拼接一个新的字符串

private static void demo3() {
        // 拼接字符串，会产生一个新的字符串，不会影响原来的字符串
        String str = "afefe";
        String str1 = str.concat("def");
        System.out.println(str1);
        System.out.println(str);
    }

contains方法判断是否包含字符串

private static void demo4() {
        String str = "afef";
        // 判断是否包含某一段字符串
        // 返回true表示包含
        // 返回false表示不包含
        boolean contains = str.contains("fef");
        System.out.println(contains);
    }