Java每日demo

–2023.03.04–
tips: 注释（ctrl shift /）
待解决：当输入一个单词的时候，“jiang”，报错

/**
 * 58. 最后一个单词的长度
 * 给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。
 * 单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
 */
public class lengthOfLastWord {
    //句子字符串str
    public String str;
    //构造函数
    lengthOfLastWord(){
        System.out.println("请输入你想要输入的句子或单词：");
    }
    //实现方法
    public int fucToLengthOfLastWord(String s){
        int index = s.length() - 1;
        while (s.charAt(index) == ' '){
            index--;
        }
        int wordLength = 0;
        while (s.charAt(index) != ' ' && index >= 0){
            wordLength++;
            index--;
        }
        return wordLength;
    }

    //主方法接口
    public static void main(String[] args) {
        lengthOfLastWord le = new lengthOfLastWord();
        //屏幕输入
        Scanner sca = new Scanner(System.in);
        //调用赋值
        le.str = sca.nextLine();
        System.out.println(le.fucToLengthOfLastWord(le.str));
    }
}

———————————————
–2023.03.06–
知识点：
String.toCharArray 方法，就是将字符串对象中的字符转换为一个字符数组。
Integer.parseInt(arg);将string类型强制转化为整形
参考blog：string数组转int数组、String数组转int数组的几种方法、在Java中如何将String字符串转换为int类型？
待解决：return new int[]{i,j};失败

import java.util.Scanner;

/**
 * 1. 两数之和
 * 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。
 *你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
 * 你可以按任意顺序返回答案。
 */

public class twoSun {
    private String str;
    public String straar[];
    //整形数组
    int[] strtoin;


    
    //构造函数
    twoSun(){
        System.out.println("请输入一串数字，并用‘，’分隔开：");
        Scanner sca = new Scanner(System.in);
        str = sca.next().toString();
    }
    //strToInt转换函数
    public void strToInt(String s){
        String[] st = s.split(",");
        strtoin = new int[st.length];
        for (int i = 0; i < st.length; i++) {
            strtoin[i] = Integer.parseInt(st[i]);
        }
    }
    //toSun函数
    public int[] funcToTwoSun(int[] in,int tager){
        System.out.println("请输入目标值：");
        Scanner scatar = new Scanner(System.in);
        tager = scatar.nextInt();
        //实现求和
        for (int i = 0; i < in.length; i++) {
            for (int j = i+1; j < in.length; j++) {
                if (in[i] + in[j] == tager) {
                    System.out.println("["+i+","+j+"]");
                    return new int[]{i,j};
                }
            }
        }
        return new int[0];
    }
    
    public static void main(String[] args) {
        twoSun ts = new twoSun();
        //先把str转换为int
        ts.strToInt(ts.str);
        //再比较int[]和targer
        int targer = 0;
        ts.funcToTwoSun(ts.strtoin,targer);
    }
}

———————————————
–2023.03.08–
tips：
快捷键ctrl tab编辑窗口切换
shift alt 上下左右换行
1.可能会用到吧IDEA的LeetCode力扣插件设置与使用
2.找到一篇干货IDEA插件
知识点：
1.java没有指针只有引用
2.Array.toString(数组名)，可以直接打印数组
3.String.valueOf(temp)，数字转换成字符串
4.Integer.parseInt？

吐槽：java中常用的数据结构单链表LIstNode，而java类库中没有ListNode类，查了半天是leetcode自定义节点类，意无语凝噎

Cannot resolve symbol 'ListNode'

参考blog：关于ListNode的理解、Java链表 自定义ListNode类、java中有ListNode吗？ListNode与LinkedList的区别是什么呢？、一个可以buy-ChtGPT的网站、Intellij IDEA Cannot resolve symbol XXX 问题解决办法汇总、Java中? : 的含义及用法、一个系统学习java知识点的网站、java里面怎么得到一个数的长度、Java求一个整形数字的长度、在java中如何判断一个整型数字的长度，到底是几位数、Java 实例 - 获取数组长度、自定义实现Java ListNode链表、reserve反转、如何求链表的长度、如何使用循环和递归计算单链表的长度、直接打印数组、java 两个字符相加_两个string,里面存的都是数字该如何相加？、JAVA中字符串如何与整型数字相加、JAVA 两个大字符串数字相加、算法例子:两个String类型相加（java）
待解决：
1.为什么连续用类方法相互调用之后，类变量会是null？缓存这么短暂只存在方法里面吗，我用实例化的变量去做方法的传参都不行。

import java.util.Arrays;
import java.util.Scanner;
/**
 *2. 两数相加
 * 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
 * 请你将两个数相加，并以相同形式返回一个表示和的链表。
 * 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
 * 
 * 我的天，不小心搞得太长了，看起来好复杂……
 */

//A simple ListNode function
class xListNode{
    //vlaue
    int val;
    //pre
    xListNode next;
    //construction function
    xListNode(int va){
        this.val = va;
    }
}

public class addTwoNumbers {
    //屏幕输入数字1
    int temp1;
    //屏幕输入数字2
    int temp2;
    //数字1转换为数组1
    int[] inaar1;
    //数字2转换为数组2
    int[] inaar2;
    //数组1转换为链表1
    xListNode headnode1;
    //数组2转换为链表2 
    xListNode headnode2;
    //将最后的List链表变成数组
    int[] inresult;
    //反转数组，123-321
    int[] inreserve;
    
    //初始化
    addTwoNumbers(){
        Scanner sca1 = new Scanner(System.in);
        System.out.println("请输入数字1（例123）：");
        temp1 = sca1.nextInt();
        Scanner sca2 = new Scanner(System.in);
        System.out.println("请输入数字2（例123）：");
        this.temp2 = sca2.nextInt();
    }
    
    //整形数得到整形数组
    public int[] toIntAar(int temp,int[] inaar){
        System.out.println("我被调用了toIntAar");
        //先转换成String，得到字符串长度
        String strlen = String.valueOf(temp);
        inaar = new int[strlen.length()];
        //利用% /得到整形数组
        for (int i = 0; i < strlen.length(); i++) {
            if (temp != 0) {
                inaar[i] = temp % 10;
                temp = temp/10;
            }
        }
        return inaar;
    }
    
    //整形数组转换为链表
    public xListNode intToList(int[] inaa,xListNode temphead){
        System.out.println("我被调用了intToList");
        temphead = new xListNode(71);
        xListNode nextnode;
        nextnode = temphead;
        for (int i = 0; i < inaa.length; i++) {
            xListNode newnode = new xListNode(inaa[i]);
            nextnode.next = newnode;

            nextnode = nextnode.next;
        }
        nextnode = temphead;
        return nextnode;
    }
    
    //打印链表
    public void print(xListNode tempnode){
        System.out.println("我被调用了print");
        while (tempnode != null){
            if (tempnode.val == 71){
                tempnode = tempnode.next;
            }
            System.out.println(tempnode.val);
            tempnode = tempnode.next;
        }
        System.out.println("结束");
    }
    
    //链表相加
    public void addTwoNumbers(xListNode list1,xListNode list2){
        //判断进位符
        int carry = 0;
        //结果链表
        xListNode result = new xListNode(71);
        //移动引用链表
        xListNode tempnext = result;
        while (list1 != null || list2 != null) {
            System.out.println("进入while");
            if (list1.val == 71){
                list1 = list1.next;
                System.out.println("我被调用了if list1");
            }
            if (list2.val == 71){
                list2 = list2.next;
                System.out.println("我被调用了if list2");

            }
            int inlist1 = list1 != null ? list1.val : 0;
            int inlist2 = list2 != null ? list2.val : 0;
            //单个位求和
            int sum = inlist1 + inlist2 + carry;
            carry = sum/10;
            sum = sum%10;
            //连接下一个新的节点
            tempnext.next = new xListNode(sum);
            tempnext = tempnext.next;

            if (list1 != null)
                list1 = list1.next;
            if (list2 != null)
                list2 = list2.next;
        }

        if (carry > 0){
            tempnext.next = new xListNode(1);
        }
        listToInt(result.next);
    }
    //
    public void printAddTwoNumbers(xListNode tempnode){
        System.out.println("我被调用了printAdd");
        while (tempnode != null){
            System.out.println("我被调用了while");
            System.out.println(tempnode.val);
            tempnode = tempnode.next;
        }
        System.out.println("结束");
    }
    //链表转回整形数组
    public void listToInt(xListNode temphead){
        System.out.println("我被调用了listToInt");
        int incount = 0;
        xListNode result = temphead;
        while (result != null){
            incount++;
            result  = result.next;
        }
        this.inresult = new int[incount];
        for (int i = 0; i < this.inresult.length; i++) {
            inresult[i] = temphead.val;
            temphead = temphead.next;
        }
    }
    //数组数字反转
    public void intToReverse(){
        this.inreserve = new int[this.inresult.length];
        for (int i = this.inresult.length,j = 0; i > 0; i--,j++) {
            this.inreserve[j] = this.inresult[i-1];
        }
    }

    public static void main(String[] args) {
        addTwoNumbers atnum = new addTwoNumbers();
        atnum.inaar1 = atnum.toIntAar(atnum.temp1,atnum.inaar1);
        atnum.inaar2 = atnum.toIntAar(atnum.temp2,atnum.inaar2);
        atnum.headnode1 = atnum.intToList(atnum.inaar1,atnum.headnode1);
        atnum.headnode2 = atnum.intToList(atnum.inaar2,atnum.headnode2);
        atnum.addTwoNumbers(atnum.headnode1,atnum.headnode2);
        atnum.intToReverse();
        System.out.println(atnum.inreserve);
        System.out.println(Arrays.toString(atnum.inreserve));
    }
}

———————————————
–2023.03.11–
tips：
s.charAt(i)取特定的某个char
contains()是否元素存在
remove()删除信息中的元素
知识点：
1.哈希算法：线性结构、在元素的存储位置和其关键字之间建立某种联系，比如，【1，2，3，4】做一个5的队列，如果多了又可以以链表的方式存
2.Java中HashSet的使用：不允许有重复元素
参考Blog：哈希(Hash)和代码实现(详解，)但是是用C++写的、哈希表Java写的、HashSet不允许有重复元素、HashSet的Java使用、很详细的HashSet

待解决：
1.可以考虑输出子串
2.可以考虑去实现HashSet重写

/**
 * 3. 无重复字符的最长子串
 * 给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
 * 
 * 这题意外的简单，滑动窗口
 */

import java.util.HashSet;
import java.util.Scanner;

    public class lengthOfLongestSubstring {
        public String instr;

        lengthOfLongestSubstring(){
            System.out.println("请输入一串连续的字符：");
            Scanner scrstr = new Scanner(System.in);
            instr = scrstr.next();
        }
        public int funPrintStr(){
            HashSet set = new HashSet<>();
            int right=0, left=0, result=0;
            while (right<instr.length()){
                //后加加
                char tempchar = instr.charAt(right++);
                //看这个字母是否己在Set
                while (set.contains(tempchar)){
                    //重复，从左边开始删除
                    set.remove(instr.charAt(left++));
                }
                //不在？,加入
                set.add(tempchar);
                //比较最长子串
                result = Math.max(result, set.size());
            }
            return result;
        }

        public static void lengthOfLongestSubstring(String[] args) {
            lengthOfLongestSubstring lstr = new lengthOfLongestSubstring();
            System.out.println(lstr.funPrintStr());
        }
    }

———————————————
–2023.03.12–
tips: 今天又遇到了之前无论怎么都只能运行同一个Java文件的情况，然后点进了


删除后就解决了。

知识点：
参考blog：二分法在Java中的实现、断点的设置、
待解决：

———————————————
–2023.03.13–
tips: 勉强懂了，用的是动态规划。
参考Blog：动态规划，说得非常好，可惜不是人话、无聊的时候看一下
tips: 勉强懂了，用的是动态规划。
知识点：
1.String.substring( 2，5);//取出字符串里面的2-5的子串
2.动态规划快，用空间换时间。
3.最长回文串指的是“abcdc”中为“cdc”

public class longestPalindrome {
    public String funcLongestPalinddrome(String str){
        //先判断只有一个字符和情况
        if (str == null || str.length()<2) {
            return str;
        }

        //
        int strlen = str.length();
        int maxlpstart = 0;//最长回文串的终点
        int maxlpend = 0;//最长回文串的长度
        int maxlplen = 1;//最长回文串的长

        //注意这里是布尔型
        boolean[][] lp = new boolean[strlen][strlen];
        //从第二个数开始往后做为中间数
        //cenn也许不是中间而是右边
        for (int cenn = 1; cenn < strlen; cenn++) {
            for (int left = 0; left < cenn; left++) {
                //第一个表达式是从左与作为中间的数进行对比、cenn-left是挨着的或者中间隔一个、中间数往后移左边向前移相等旁边的那个
                if (str.charAt(cenn) == str.charAt(left) && ((cenn - left<=2) || lp[left+1][cenn-1])) {
                    lp[left][cenn] = true;
                    if (cenn - left + 1> maxlplen) {
                        //长度等于中间的减去左边的加上本身
                        maxlplen = cenn - left + 1;
                        maxlpstart = left;
                        maxlpend = cenn;
                    }
                }
            }

        }
        return str.substring(maxlpstart,maxlpend+1);
    }

    public static void main(String[] args) {
        dynamictwo dp = new dynamictwo();
  /*      Scanner scain = new Scanner(System.in);
        System.out.println("请输入一串字符（例：abedeg）");
        System.out.println(dp.longestPalindrome(scain.next()));*/
        System.out.println(dp.longestPalindrome(dp.longestPalindrome("abbab")));
    }
}

———————————————
–2023.03.13–
tips:
知识点：
1.StringBuilder、提供一个可变的字符串类型，可以用Append方法连接字符串
2.append（）追加字符串到末尾
3.<>是泛型，是数据类型，有点类似指定
List rows = new ArrayList()
4…add ()：新增一组要查找的元素；append ()：结构上加新的元素。
5.静态Static之后，在主类里面的主方法里面可以直接调用方法。

参考Blog：Java ArrayList、泛型理解和使用、StringBuilder、string、stringBuffer、stringBuilder三者的区别是什么？
待解决：

/**
 *  6. N 字形变换
 * 将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。
 */

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class convert {
    String str;
    Integer in;
    convert(){
        Scanner scanner1 = new Scanner(System.in);
        System.out.println("请输入一串字符串：");
        this.str = scanner1.next();
        Scanner scanner2 = new Scanner(System.in);
        System.out.println("请输入数字：");
        this.in = scanner2.nextInt();
    }

    public String funcConvert(String str,int in){
        //str = this.str;
        if (in<2) {
            return str;
        }

        List<StringBuilder> strbui = new ArrayList<StringBuilder>();
        for (int i = 0; i < in; i++) {
            /*在一个List数组中重新给每一行都变成Lsit链表,.
            add ()：新增一组要查找的元素；
            append ()：结构上加新的元素。*/
            strbui.add(new StringBuilder());
        }
        /*flag是转向标*/
        int i = 0,flag = -1;
        for (char c:str.toCharArray()
             ) {
            strbui.get(i).append(c);
            if (i == 0 || i == in - 1) {
                flag = -flag;
            }
            i = i + flag;
        }
        /*重新初始化一个StringBuilder，装入*/
        StringBuilder strb = new StringBuilder();
        for (StringBuilder sb:strbui
             ) {
            strb.append(sb);
        }
        return strb.toString();
    }

    public static void main(String[] args) {
        convert con = new convert();
        System.out.println(con.funcConvert(con.str, con.in));
    }
}