Java基础

1.Object类

import java.util.Objects;

public class Object01 {
    public static void main(String[] args) throws CloneNotSupportedException{

        /*
            TODO 方法：
                 clone() => 创建并返回此对象的副本 (浅拷贝)
                 equals => 判断两个对象是否相等
                      equals 默认底层使用 == 对两个对象地址进行判断，如果地址相同，那么结果为true
                 hashCode() => 返回对象的Hash值，该函数是一个映射函数  传入一个值，肯定有一个唯一对应的随机的值
                 toString() => 用于将当前对象转换成一个字符串
                 getClass() => 获取当前对象的类路径
         */
        Object object = new Object();
        String objStr = object.toString();
        System.out.println(objStr); // java.lang.Object@4554617c
        System.out.println(object); // java.lang.Object@4554617c  println就是调用了 toString 方法

        String str = new String("这是一个字符串");
        System.out.println(str.toString());  // 子类可以重写toString 方法

        MyClass myClass1 = new MyClass("toString", "这是一个自定义类");
        MyClass myClass2 = new MyClass("toString", "这是一个自定义类");
        System.out.println(myClass1);
        System.out.println(myClass1.equals(myClass2)); // true




        // TODO 在Java中Class也是一个类 该类的对象表示 类对象
        Class aClass = myClass1.getClass();
        System.out.println(aClass.getName().toString()); // 获取当前对象的类路径
        //结果： com.shujia.Day07_Object_StringFunction_WrapClass.MyClass


    }
}

/*
    对于一个自定义类，如果该类用于表述数据 那么其规范的写法：
        比如对于 Mysql中的emp表 每一行数据代表是一个员工类 员工的字段是类中的属性
 */
class MyClass{
    private String name;
    private String data;

    public MyClass(String name, String data) {
        this.name = name;
        this.data = data;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

    //equals()方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MyClass myClass = (MyClass) o;
        return Objects.equals(name, myClass.name) && Objects.equals(data, myClass.data);
    }

    
    //重写hashCode()方法
    @Override
    public int hashCode() {
        return Objects.hash(name, data);
    }
    /*
       TODO  对于外部获取当前类对象的信息时，一般会调用toString方法
            对于继承的toString方法 不能获取其属性信息  所以需要对其进行重写
     */

    @Override
    public String toString() {
        return "MyClass{" +
                "name='" + name + '\'' +
                ", data='" + data + '\'' +
                '}';
    }
    
}

2.Scanner类

import java.io.InputStream;
import java.util.Scanner;

public class ScannerClass {
    public static void main(String[] args) {
        /*
            TODO Scanner类
         */
        /*
            TODO 想要从控制台获取数据 => System.in
                 in 是 System中的一个属性 类别为 InputStream 称为输入流

         */
        InputStream inputStream = System.in;
        Scanner scanner = new Scanner(inputStream);
        /*
        TODO
            next()一定要读取到有效字符后才可以结束输入，对输入有效字符之前遇到的空格键、
              Tab键或Enter键等结束符，next()方法会自动将其去掉，只有在输入有效字符之后，
            next()方法才将其后输入的空格键、Tab键或Enter键等视为分隔符或结束符。
            nextLine()方法的结束符只是Enter键，
              即nextLine()方法返回的是Enter键之前的所有字符，它是可以得到带空格的字符串的。
         */

//        String next = scanner.next();
        String next = scanner.nextLine();
        System.out.println(next+"|");

    }
}

3.String类

public class StringClass {
    public static void main(String[] args) {
        /*
            TODO String类
         */
        String str1 = "String";
        String str2 = "String";
        String newStr = new String("String");
        System.out.println(str1 == str2); // true  => 内存地址一样
        System.out.println(str1 == newStr); // false  => == 用于判断内存地址是否相同 内存地址不一样
        System.out.println(str1.equals(newStr)); // true  => equals是比较具体的数据(String类中的equals()方法经过了重写，判断值是否相等)

        String str3 = "1+1=2";
        String str4 = "1+1=";
        String str5 = "2";
        String str6 = str4 + str5;  // 通过 + 的方式得到的结果，会在堆空间中保存数据
        System.out.println(str3 == str6);  // false str3会存放到栈空间中


    }
}

4.String方法01

public class StringFunction01 {
    public static void main(String[] args) {
        /*
            TODO String类的方法
                1.构造方法
                    new String(char[] chars)
                    new String(byte[] bytes)
                2.判断功能
                    boolean equals(Object obj)  等值判断  // 非常重要
                    boolean equalsIgnoreCase(String str)  // 忽略大小写比较字符串
                    boolean contains(String str) // 是否包含某个子字符串
                    boolean startsWith(String str)  // 判断是否以某个子字符串为开头
                    boolean endsWith(String str) // 判断是否以某个子字符串为结尾
                    boolean isEmpty() //判断字符串是否为空
               3.String类的获取功能
                    int length() => 获取字符长度 // 非常重要
                    char charAt(int index) => 根据下标获取其对应下标位置上的数据 => 因为字符串可以看成是char类型的数组
                    int indexOf(int ch)   indexOf是用于返回其传入 参数(注意参数列表) 在字符串中的下标
                    int indexOf(String str)
                    int indexOf(int ch,int fromIndex)
                    int indexOf(String str,int fromIndex)  fromIndex 表示从某个下标开始寻找
                    String substring(int start)  // 非常重要  从某个开始下标截取字符串直到末尾
                    String substring(int start,int end) // 非常重要 从某个开始下标截取字符串直到结束下标 截取区间为左闭右开区间

         */
        char[] chars = {'a','b','c','d'};
        String char2Str = new String(chars);
        System.out.println(char2Str); // print()方法内部调用了toString()方法，因此可以这样输出

        // TODO 对于字符串来说 认为byte[]中保存的数据是字节数据，在创建对象时，会根据其ASC码值将其转换成对应的字符
        byte[] bytes = {97,98,99};
        System.out.println(new String(bytes));  // abc


        String str = "ABCD";
        System.out.println(char2Str.equalsIgnoreCase(str));  // true

        System.out.println(char2Str.contains("a")); // true

        System.out.println(str.startsWith("AB")); // true

        System.out.println(str.endsWith("CD")); // true

        System.out.println(str.isEmpty()); //

        // 对字符串赋予 null 值之后，使得其指向的内地址消失 所以调用时会出现空指针异常
//        String nullStr = null;
        //注：null与""是两个概念，isEmpty()输出不同
        String emptyStr = "";
//        System.out.println(nullStr.isEmpty()); // java.lang.NullPointerException
        System.out.println(emptyStr.isEmpty()); // true

        System.out.println(str.length()); // 4
        System.out.println(str.charAt(0));

        System.out.println(str.indexOf("BC")); // 1 返回的是第一个字符的下标

        String str2 = "ABCDABCD";
        System.out.println(str2.indexOf("BC",2)); // 5 从第二个字符开始查找，并返回下标

        System.out.println(str2.substring(2)); // CDABCD
        System.out.println(str2.substring(2,6));  // CDAB

    }
}

5.String方法02

import java.util.Arrays;

public class Demo05StringFunction2 {
    public static void main(String[] args) {
        /*
            TODO 字符串方法
                转换功能
                byte[] getBytes()  （若无参数）表示使用平台的默认字符集将字符串编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
                char[] toCharArray() 将字符串中的字符转换为字符数组
                static String valueOf(char[] chs) 将 char 数组 data 转换成字符串
                static String valueOf(int i) 将 int 变量 i 转换成字符串
                String toLowerCase() 将字符串中字符转换成大写
                String toUpperCase() 将字符串中字符转换成小写
                String concat(String str) 用于将指定的字符串参数连接到字符串上
         */

        String str = "abcd";
        byte[] bytes = str.getBytes();
        System.out.println(Arrays.toString(bytes)); // [97, 98, 99, 100]

        /*TODO
            注：对于一个中文默认占用三个字节数据
         */
        String str2 = "字符串"; // => [-27, -83, -105, -25, -84, -90, -28, -72, -78]
        System.out.println(Arrays.toString(str2.getBytes()));

        /*TODO
            注：对于一个中文默认占用一个字符数据
        */
        char[] chars = str2.toCharArray();
        System.out.println(Arrays.toString(chars));
        System.out.println(str.toCharArray());

        char[] chars2 = {'数','组'};
        /* TODO:
            String.valueOf(char[] data) : 将 char 数组 data 转换成字符串
            String.valueOf(char[] data, int offset, int count) :
            将 char 数组 data 中 由 data[offset] 开始取 count 个元素 转换成字符串
         */
        String char2Str = String.valueOf(chars2);
        System.out.println(char2Str);

        System.out.println(str.toUpperCase());
        System.out.println(str.toUpperCase().toLowerCase());

        // 如何将hello转换成Hello
        String hello = "helLo"; // => Hello
        String takeStr = hello.substring(1).toLowerCase();
//        String headStr = hello.substring(0, 1).toUpperCase();
        String headStr = String.valueOf(hello.charAt(0)).toUpperCase();
        System.out.println(headStr+takeStr);

        String str3 = "head";
        String str4 = "tail";
        System.out.println(str3+","+str4);
        System.out.println(str3.concat(",").concat(str4));


    }
}

6.String方法03

package com.shujia.Day07_Object_StringFunction_WrapClass;

import java.util.Arrays;

public class Demo06StringFunction3 {
    public static void main(String[] args) {
        /*
          TODO  String类的其他功能
                String replace(char old,char new)
                String replace(String old,String new) // 非常重要
                String trim()  去除前后空格信息
                字典顺序比较：(字典顺序指的是ASCII码表中的字符顺序。ASCII表中每个字符都有对应的下标，从0开始升序排列，共128个字符。)
                int compareTo(String str)：
                  用字符串1跟字符串2作比较（字符串1.compareTo(字符串2)），如果字符串1的字典顺序在字符串2前面，
                   则返回一个正数。若在后面，则返回一个负数。若两个字符串的字典顺序相同，则返回0。
                   特殊案例：
                   String str1 = "ljj";
                   String str2 = "ljjLovexql";
                   System.out.println(str1.compareTo(str2));
                   以上代码运行结果为 -7，str1比str2少7个字符，所以返回 -7
                int compareToIgnoreCase(String str) 方法用于按字典顺序比较两个字符串，不考虑大小写
                注意：对于String中修改数据的函数，不会对String本身进行修改，会返回一个新的String对象
         */
        String str = "123 456";
        System.out.println(str.replace(" ", ","));
        System.out.println(str);

        String str1 = "  今天天气真好呀  \t";
        System.out.println(str1);
        System.out.println(str1.trim()+"|");

        // 对于数值数据进行排序时，是按照自然排序方式
        int[] ints = {11,10,100};
        Arrays.sort(ints);
        System.out.println(Arrays.toString(ints));  // [10, 11, 100]

        // 对于字符串类型数据进行比较时，是按照字典顺序进行比较的
        String strArr[] = {"11","10","100"};
        Arrays.sort(strArr);
        System.out.println(Arrays.toString(strArr)); // [10, 100, 11]

        String intStr1 = "11";
        String intStr2 = "100";
        int compareToRes = intStr1.compareTo(intStr2);  // 1
        System.out.println(compareToRes);



        /*
            value?
            private final char value[];  => 11
            value = ['1','1']

            public int compareTo(String anotherString) {
                int len1 = value.length;  ['1','1'] => 2
                int len2 = anotherString.value.length; ['1','0','0'] => 3
                int lim = Math.min(len1, len2); // 取长度最小值 2
                char v1[] = value;  ['1','1']
                char v2[] = anotherString.value; ['1','0','0']

                int k = 0; // 下标
                while (k < lim) {
                    // 取出对应下标中的字符
                    char c1 = v1[k];
                    char c2 = v2[k];
                    // k=1 => c1=1,c2=0
                    if (c1 != c2) {
                        // 将两个char类型的数据通过ASC码值进行比较 返回其差值
                        // c1表示当前字符串  c2表示传入比较的字符串
                        return c1 - c2;
                    }
                    k++;
                }
                return len1 - len2;
            }
         */

        //实现字符串abc的逆序输出
        String str4 = "abc";
        String res = "";
        char[] chars = str4.toCharArray();
        for (int i = chars.length-1; i >= 0 ; i--) {
            res += chars[i];
        }
        System.out.println(res);



        //从下方字符串中匹配”java“的数量
        String javaStr = "oaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
         //TODO 法一：
        //        int num = 0;
    //        for (int i = 0; i < javaStr.length(); i++) {
    //            if (i + 4 < javaStr.length()){
    //                String substring = javaStr.substring(i, i + 4);
    //                if (substring.equals("java")) {
    //                    num ++;
    //                }
    //            }
    //        }
    //        System.out.println("num:"+num);

        int num = 0;
        // TODO 法二：
       //        while (javaStr.contains("java")){
//            返回下标
//            int javaStartIndex = javaStr.indexOf("java");
//            进行javaStartIndex+4，越过此次找到的“java”来进行下一次的查找
//            javaStr = javaStr.substring(javaStartIndex+4);
//            num ++;
       //        }
       //        System.out.println("num:"+num);

        // TODO 法三(相对于法二进行了优化)： indexOf当获取不到值对应返回结果为 -1
        //        javaStr = "hello";
        //        System.out.println(javaStr.indexOf("java"));

        int javaStartIndex = 0;
        while ((javaStartIndex = javaStr.indexOf("java")) != -1){
            javaStr = javaStr.substring(javaStartIndex+4);
            num ++;
        }
        System.out.println("num:"+num);

        // 当前String类型的字符长度是不可更改的 => 字符串底层做数据存储是 char[] 定义后长度不可发生变化
        String st = "a";
        String b = st.concat("b");
        System.out.println(b);


    }
}