Java（十五）

知识点一：枚举属性及理解

package com.atgugui.javase.homework;


import com.atgugui.javase.exer.MyDate;

/**
  * enum Week {
  *     MON, TUE, WED, THU, FRI, SAT, SUN
  * }
  *
  * 给Week枚举加上属性,String feel;
 */

enum Week{
     MON("hope"), TUE("sad"), WED("boring"), THU("good"), FRI("happy"), SAT("beautiful"), SUN("sad");
     private String feel;
     private Week(){

     }

     Week(String feel) {
         this.feel = feel;
     }

     @Override
     public String toString() {
         return "Week{" +
                 "feel='" + feel + '\'' +
                 '}';
     }
 }
public class WeekTest {
    public static void main(String[] args) {
        Week week = Week.values()[2];
        System.out.println(week);
    }
}

枚举类型一开始我们仅仅是将其类型列举到类中，上面的添加了属性，其有添加了构造器，但是枚举类型不能声明对象，其每种类型都是一个全局常量，所以我们需要在添加完构造器后对其进行赋值操作（这也是之前我们没有进行的操作）可参考下面截图理解，这样对枚举的定义： 对象可数的类型，可以有更好的理解。

知识点二：String类的常用方法

* String : 内容不可改变的Unicode字符序列. 所以任何对于字符串内容的修改都会导致产生新对象.
* 内部使用一个char[]来保存所有字符, 所以每个字符都有下标.
* 字符串常量 包括字面量, 都是默认保存在常量区中. 为的是提高效率,多次使用方便快捷.

* String string = "  abcQYz12 我喜欢你,你喜欢我吗? 我不喜欢你, zzQQyy  ";
字符串实验

1.$length()字符串的长度, 字符个数

* public int length() 
 *      string.length() => 38

2.$charAt() 获取参数指定下标处的字符

* public char charAt(int index)
    string.charAt(13) => '欢',  string.charAt(27) => '你'

3.toCharArray()返回字符串内部的char[]的副本

$public char[] toCharArray()
char[] ch = string.toCharArray();

以下是toCharArray 的源代码解析

char result[] = new char[value.length];
 *
 *      for (int i = 0; i < value.length; i++) {
 *          result[i] = value[i];
 *      }
 *
 *      第一个参数value是源数组对象, 第二个参数0是源数组准备复制的开始下标
 *      第三个参数result是目标数组对象, 第四个参数0是目标数组复制元素的开始下标.
 *      第五个参数value.length是复制的元素的个数.
 *      System.arraycopy(value, 0, result, 0, value.length);

4.$equals方法的重写

 public boolean equals(Object anObject)
     参考下面代码
     

5.$equalsIgnoreCase

* public boolean equalsIgnoreCase(String anotherString)

忽略大小写对字符串进行比较

6.$$返回参数中的子串s在当前字符串中首次出现的下标

* String string = "  abcQYz12 我喜欢你,你喜欢我吗? 我不喜欢你, zzQQyy  ";
*  public int indexOf(String s)
    string.indexOf("喜欢") => 12
 *              string.indexOf("hello") => -1

7.返回参数中的子串s在当前字符串中首次出现的下标, 但是是从startPoint下标开始搜索

* public int indexOf(String s ,int startpoint)
     string.indexOf("喜欢", 13) => 17, string.indexOf("喜欢", 18) => 25

8.返回参数中的子串s在当前字符串中首次出现的下标, 但是是从右向左搜索的,与indexOf相反

 * public int lastIndexOf(String s)
      string.lastIndexOf("喜欢") => 25

9.返回参数中的子串s在当前字符串中首次出现的下标, 但是是从右向左搜索的,并且从指定下标开始

* public int lastIndexOf(String s ,int startpoint)
    string.lastIndexOf("喜欢", 24) => 17, string.lastIndexOf("喜欢", 16) => 12

10.判断当前字符串是否以参数中的子串为前缀

* public boolean startsWith(String prefix)
    string.startsWith("  abc") => true

11.判断当前字符串是否以参数中的子串为后缀

* public boolean endsWith(String suffix)
     string.endsWith("zzQQyy") => false

12.$$从当前字符串中获取子串, 从start开始(包含) ,到end结束(不包含).

* public String substring(int start,int end)
    string.substring(11, 15) => "我喜欢你";

13.从当前字符串中获取子串, 从start开始(包含) 到末尾

* public String substring(int startpoint)

14.替换当前字符串中的所有oldChar字符为newChar字符.

 * public String replace(char oldChar,char newChar)

15.替换字符串的所有old为new串 支持正则表达式

 * public String replaceAll(String old,String new)

16.修剪首尾的空白字符, 码值小于等于32的所有字符.

* public String trim()

17.其他

 * public String concat(String str) --> string.concat("yyy") => "....yyy"
 * public String toUpperCase() 把所有小写字母变成大写字母
 * public String toLowerCase() 把所有大写字母变成小写字母
 * public String[] split(String regex) 以参数中的子串为切割器,把字符串切割成多个部分

public class StringTest {

    @Test
    public void test11() {
        String s1 = "abc";
        String s2 = "ABC";

        //s2 = null;

        System.out.println(s1.equals(s2));
        System.out.println(s1.equalsIgnoreCase(s2));

        System.out.println(s1.toLowerCase().equals(s2.toLowerCase()));

        String s = String.valueOf(2.22); // "" + 2.22
        System.out.println(s);
    }

    @Test
    public void test10() {
        String s = "abc,你和他,yyy,111,333";
        String[] split = s.split(",");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }

        String path = "C:\\Program Files\\Java\\jdk1.8.0_251\\bin;C:\\Program Files (x86)\\NetSarang\\Xftp 6\\;C:\\Program Files (x86)\\NetSarang\\Xshell 6\\;D:\\MyProgram\\Database\\Oracle\\MyOracle11G\\product\\11.2.0\\dbhome_1\\bin;C:\\MyProgram\\_MyBin;C:\\Windows\\system32;C:\\Windows;C:\\Windows\\System32\\Wbem;C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\;D:\\MyProgram\\LLVM\\bin;D:\\MyProgram\\CMake\\bin;C:\\Program Files\\Git\\cmd;C:\\Program Files\\Bandizip\\";
        String[] split1 = path.split(";");
        for (int i = 0; i < split1.length; i++) {
            System.out.println(split1[i]);
        }
    }

    @Test
    public void test9() {
        String string = "  abcQYz12 我喜欢你,你喜欢我吗? 我不喜欢你, zzQQyy  ";
        String s = string.toUpperCase();
        System.out.println(s);

        String s1 = string.toLowerCase();
        System.out.println(s1);
    }

    @Test
    public void test8() {
        String string = "  \r\n\t\n\b abcQYz12 我喜欢你,你喜欢我吗? 我不喜欢你, zzQQyy  \b\r\n\t\n";
        System.out.println(string);
        String trim = string.trim();
        System.out.println(trim);

    }

    @Test
    public void test7() {
        String string = "  abcQYz12 我喜欢你,你喜欢我吗? 我不喜欢你, zzQQyy  ";
        String replace = string.replace(' ', '#');
        System.out.println(replace);
        String string2 = string.replaceAll("喜欢", "讨厌");
        System.out.println(string2);
        // 消除所有空格
        String string3 = string.replaceAll(" ", "");
        System.out.println(string3);
        // 下面的行为很诡异, 会导致 大量的替换
        String string4 = string.replaceAll("", "@");
        System.out.println(string4);
    }

    //将一个字符串进行反转。将字符串中指定部分进行反转。比如将“abcdefg”反转为”abfedcg”
    @Test
    public void exer3() {
        String string = "abcdefghijklmn";
        int begin = 2;
        int end = 8;
        String s1 = string.substring(0, begin);
        String s2 = string.substring(begin, end);
        String s3 = string.substring(end);
        // 反转中间的s2
        char[] chars = s2.toCharArray();
        for (int i = 0; i < chars.length / 2; i++) {
            char tmp = chars[i];
            chars[i] = chars[chars.length - 1 - i];
            chars[chars.length - 1 - i] = tmp;
        }
        String result = s1 + new String(chars) + s3;
        System.out.println(result);
    }

    @Test
    public void test6() {
        String string = "  abcQYz12 我喜欢你,你喜欢我吗? 我不喜欢你, zzQQyy  ";
        boolean b1 = string.startsWith("  abc");
        System.out.println("b1 = " + b1);
        boolean b2 = string.endsWith("zzQQyy");
        System.out.println("b2 = " + b2);

        String substring = string.substring(11, 15);
        System.out.println("substring = " + substring);

        String substring1 = string.substring(16, string.length());
        System.out.println("substring1 = " + substring1);

        String substring2 = string.substring(16);
        System.out.println("substring2 = " + substring2);
    }

    /*获取一个字符串在另一个字符串中出现的次数。
    比如：获取"ab"在 "abkkcadkabkebfkabkskab"中出现的次数*/
    @Test
    public void exer2() {
        String s1 = "abkkcadkabkebfkabkskab";
        String s2 = "ab";

        int count = 0;
        int index = 0;
        while (true) {
            index = s1.indexOf(s2, index);
            if (index == -1) {
                break;
            }
            count++;
            index++;
        }
        System.out.println("count = " + count);
    }

    @Test
    public void test5() {
        String string = "  abcQYz12 我喜欢你,你喜欢我吗? 我不喜欢你, zzQQyy  ";
        int i1 = string.indexOf("喜欢");
        System.out.println("i1 = " + i1);
        int i2 = string.indexOf("喜欢", i1 + 1);
        System.out.println("i2 = " + i2);
        int i3 = string.indexOf("喜欢", i2 + 1);
        System.out.println("i3 = " + i3);
        int i4 = string.indexOf("喜欢", i3 + 1);
        System.out.println("i4 = " + i4);

    }

    // 反转字符串
    @Test
    public void exer13() {
        String string = "  abcQYz12 我喜欢你,你喜欢我吗? 我不喜欢你, zzQQyy  ";
        char[] chars = string.toCharArray();
        for (int i = 0; i < chars.length / 2; i++) {
            // i, length - 1 - i
            char tmp = chars[i];
            chars[i] = chars[chars.length - 1 - i];
            chars[chars.length - 1 - i] = tmp;
        }
        String s = new String(chars);
        System.out.println(s);

        System.out.println(string);
    }

    @Test
    public void exer12() {
        String string = "  abcQYz12 我喜欢你,你喜欢我吗? 我不喜欢你, zzQQyy  ";
        String string2 = "";
        for (int i = 0; i < string.length(); i++) {
            //char ch = string.charAt(string.length() - 1  - i);
            //string2 += ch;
            char ch = string.charAt(i);
            string2 = ch + string2;
        }
        System.out.println(string2);
    }

    @Test
    public void exer1() {
        String string = "  abcQYz12 我喜欢你,你喜欢我吗? 我不喜欢你, zzQQyy  ";
        String string2 = "";
        // 反向遍历字符串, 把字符串接在string2后面, 循环结束就OK.
        for (int i = string.length() - 1; i >= 0; i--) {
            char ch = string.charAt(i);
            string2 = string2 + ch;
        }
        System.out.println(string2);
    }

    @Test
    public void test4() {
        String string = "  abcQYz12 我喜欢你,你喜欢我吗? 我不喜欢你, zzQQyy  ";
        int length = string.length();
        System.out.println("length = " + length);

        char c1 = string.charAt(11);
        System.out.println("c1 = " + c1);
        char c2 = string.charAt(20);
        System.out.println("c2 = " + c2);

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

        // 遍历字符串
        for (int i = 0; i < string.length(); i++) {
            char c = string.charAt(i); // string[i]
            System.out.println(c);
        }
    }

    @Test
    public void test3() {
        String s1 = "atguigu";
        String s2 = "java";
        String s4 = "java"; // 常量区
        String s3 = new String("java"); // gc
        System.out.println(s2 == s3); // false
        System.out.println(s2 == s4); // true
        System.out.println(s2.equals(s3)); // true

        String s5 = "atguigujava"; // 常量区
        // intern方法的作用就是把字符串强制保存在常量区中
        String s6 = (s1 + s2).intern(); // 字符串拼接时,如果有变量参与, 它一定生成在GC堆中.
        System.out.println(s5 == s6); // true
        System.out.println(s5.equals(s6)); // true


    }

    @Test
    public void test2() {
        String s1 = new String(); // ""
        String s2 = ""; // 和上面一样

        String s3 = null; // null表示完全没有地址, 没有对象.

        String s4 = new String("abc"); // "abc"是常量, s4指向的对象在gc堆.
        System.out.println(s4.equals("abc"));

        char[] arr = {'a', 'X', '你', '好', '5'};
        String s5 = new String(arr);
        System.out.println(s5);

        // 把字符数组的一部分转换成字符串对象.
        String s6 = new String(arr, 2, 2);// 第2个参数是数组从下标多少开始, 第3个参数是取几个字符
        System.out.println(s6);
    }

    @Test
    public void test1() {
        String str = "abc";
        str += 100;
        str += "qqq";
        System.out.println(str);

        Integer m = 1; // 自动装箱
        Integer n = 1;
        System.out.println(m == n);

    }
}

知识点三：链表的介绍

package com.atguigu.link;

import com.sun.org.apache.regexp.internal.REUtil;

import java.util.ListResourceBundle;

/**
 * @author ltc
 * @create 2020-08-13 8:57
 */
//*********************oneTime*********************
public class LinksTest {
    public class Node{
        Object val;//数据域
        Node next;//指针域
        private Node(Object val){
            this.val = val;
        }
    }

    private Node head;//头结点
    private Node tail;//尾结点
    private int size;
    public void add(Object val){
        Node newNode = new Node(val);
        if(head == null){//若空，直接插入
            head = newNode;
            tail = newNode;
        }else {//头部的尾结点连接新的结点，并刷新尾结点
            tail.next = newNode;
            tail = newNode;
        }
        size++;
    }
    public int getSize(){
        return size;
    }
    public void remove(Object val){
        if(head == null){
            return;
        }
        //删除头部
        if(head.val.equals(val)){
            head = head.next;
            size--;
            return;
        }
        //删除中间
        Node pre = head;
        while (pre.next != null){
            if(pre.next.val.equals(val)){
                if(pre.next == tail){//删除尾结点
                    tail = pre;
                }
                //删除里面的结点
                pre.next = pre.next.next;
                size--;
                return;
            }
            pre = pre.next;
        }
    }

    public void travel(){
        Node temp = head;
        while (temp != null){
            System.out.println(temp.val);
            temp = temp.next;
        }
    }

    public static void main(String[] args) {
        LinksTest linksTest = new LinksTest();
        linksTest.add(23);
        linksTest.add(10);
        linksTest.add(15);
        linksTest.add(22);
        linksTest.add(24);
        linksTest.remove(15);
        linksTest.travel();
    }
}
//*****************twoTime************************
class LinkTest1{
    class Node{
        Object val;//数据域
        Node next;//指针域
        private Node(Object val){
            this.val = val;
        }
    }

    private Node head;//头部结点
    private Node tail;//尾部节点
    private int size;
    public void add(Object val){
        Node newNode = new Node(val);
        if(head == null){
            head = newNode;
            tail = newNode;
        }else {
            tail.next = newNode;
            tail = newNode;
        }
        size++;
    }
    public void remove(Object val){
        if(head == null){
            return;
        }
        if(head.val.equals(val)){
            head = head.next;
        }
        Node pre = head;
        while (pre.next != null){
            if(pre.next.val.equals(val)){
                if(pre.next == tail){
                    pre = tail;
                }
                pre.next = pre.next.next;
                size--;
                return;
            }
            pre = pre.next;
        }
    }

    public int getSize(){
        return size;
    }

    public void travel(){
        if(head == null){
            return;
        }
        Node temp = head;
        while (temp != null){
            System.out.println(temp.val);
            temp = temp.next;
        }
    }

    public static void main(String[] args) {
        LinkTest1 linkTest1 = new LinkTest1();
        linkTest1.add(10);
        linkTest1.add(12);
        linkTest1.add(13);
        linkTest1.add(14);
        linkTest1.add(15);
        linkTest1.add(16);
        linkTest1.add(17);
        linkTest1.travel();
    }

}