10/8学习总结-CSDN博客

本文链接：https://blog.csdn.net/monlyy/article/details/133689694

一、学习内容

1.创建伪聊天室登录界面

（1）使用javafx程序创建登录界面

创建用户界面： 在start方法中，创建JavaFX用户界面的各个组件，例如窗口、按钮、标签、文本框、表格等。将它们添加到一个布局容器中，如Pane、VBox、HBox等。

设置事件处理程序：为用户界面组件添加事件处理程序，以响应用户的交互操作。例如，为按钮添加点击事件处理程序。

用户验证方法： - 编写用户验证方法，通常与数据库或服务器进行交互，验证用户名和密码是否匹配。 - 在示例中，使用简单的硬编码验证。

用户验证逻辑：

在事件处理程序中，编写验证逻辑，例如检查用户名和密码是否正确。
如果验证成功，可以打开应用程序的主界面或执行其他操作。

（2）idea和数据库的连接

在使用IntelliJ IDEA进行Java应用程序开发时，与数据库连接通常涉及以下步骤：

1. 导入数据库驱动程序：

首先，你需要为你的数据库选择并下载合适的数据库驱动程序（JDBC驱动）。这个驱动程序将允许你的Java应用程序与数据库通信。将驱动程序的JAR文件添加到你的项目中。

2. 建立数据库连接：

在你的Java代码中，使用JDBC API来建立与数据库的连接。通常，你需要提供数据库的URL、用户名和密码。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DatabaseConnection {
    public static Connection getConnection() throws SQLException {
        String url = "jdbc:mysql://localhost:3306/your_database_name";
        String username = "your_username";
        String password = "your_password";
        
        return DriverManager.getConnection(url, username, password);
    }
}

3. 执行SQL查询：

使用连接对象创建Statement或PreparedStatement对象，然后使用它们来执行SQL查询或更新数据库。

4.异常处理：

在与数据库连接的过程中，要处理可能出现的异常，例如数据库连接失败或SQL语句执行错误。

二、多线程

（1）定义

多线程是指在一个程序中同时执行多个独立的线程，每个线程都有自己的执行路径和执行状态。多线程的目的是充分利用计算机的多核处理器或多任务处理能力，以提高程序的性能和响应速度。在Java中，多线程是通过java.lang.Thread类来实现的。

(2)创建线程

在Java中，有两种主要创建线程的方式：

继承Thread类：创建一个类并继承自Thread类，然后重写run()方法，将要并行执行的代码放在run()方法中。
实现Runnable接口：创建一个类并实现Runnable接口，然后实例化一个Thread对象，将Runnable对象传递给Thread构造函数，并调用start()方法启动线程。

（3）线程生命周期

线程具有不同的生命周期阶段，包括新建、就绪、运行、阻塞和终止。线程可以在这些阶段之间切换，取决于操作系统和线程调度器的管理。

三、学习中遇到的问题

1.用javafx设置用户登录界面时，插入不了图片，查询了浏览器和csdn，并没有找到解决的方法，然后问了带我的学姐，搜寻到的方法为在项目中创建一个文件夹，用来专门存放图片，然后图片从该文件中插入。

2.进行数据库连接时，发现数据库版本过低，不能获取到数据库信息，然后就去问了其他实验室的朋友，在项目中加入了新的数据库；

二、每日一题

60. 排列序列

困难

811

相关企业

给出集合 [1,2,3,...,n]，其所有元素共有 n! 种排列。

按大小顺序列出所有排列情况，并一一标记，当 n = 3 时, 所有排列如下：

"123"
"132"
"213"
"231"
"312"
"321"

给定 n 和 k，返回第 k 个排列。

示例 1：

输入：n = 3, k = 3输出："213"

示例 2：

输入：n = 4, k = 9输出："2314"

示例 3：

输入：n = 3, k = 1输出："123"

提示：

1<=n<=9
1<=k<=n!

思路：

集合是按照大小顺序列出所有排列情况，所以有n个数，就有n个位置，放入一个数之后，右面还有n-1个位置，所以共有(n-1)!个方案，想得到第k个排列数，先获取到以某个数字开头，若k大于第（n-1)!个排列数，并且该数没有被使用过，说明第k个数的开头不可能为这个数，之后更新k=k-（n-1)!，用于下一次判断，如果小于第（n-1）！个数，说明第一位就是这个数字。数字不能重复使用。

class Solution {
    public String getPermutation(int n, int k) {
        int[] ks=new int[10];
        ks[0]=1;
            for(int i=1;i<n;i++)
         ks[i]=ks[i-1]*i;
       StringBuilder str=new StringBuilder();
        boolean[] flag=new boolean[10];
  
        for(int i=0;i<n;i++)
        {
            for(int j=1;j<=n;j++)
            if(!flag[j])
            {
            if(k>ks[n-i-1])
              k=k-ks[n-i-1];
            else 
            {
           str.append((char)('0'+j));
             flag[j]=true;
             break;
            }
        }
        
    }
            return str.toString();
}
}

提示

中等

32

相关企业

给你一个包含若干星号 * 的字符串 s 。

在一步操作中，你可以：

选中

s

移除星号左侧非星号

返回移除所有星号之后的字符串。

注意：

生成的输入保证总是可以执行题面中描述的操作。
可以证明结果字符串是唯一的。

示例 1：

输入：s = "leet**cod*e"输出："lecoe"解释：从左到右执行移除操作：- 距离第 1 个星号最近的字符是 "leet**cod*e" 中的 't' ，s 变为 "lee*cod*e" 。- 距离第 2 个星号最近的字符是 "lee*cod*e" 中的 'e' ，s 变为 "lecod*e" 。- 距离第 3 个星号最近的字符是 "lecod*e" 中的 'd' ，s 变为 "lecoe" 。不存在其他星号，返回 "lecoe" 。

示例 2：

输入：s = "erase*****"输出：""解释：整个字符串都会被移除，所以返回空字符串。

提示：

1<=s.length<=10^5
s 由小写英文字母和星号* 组成
s 可以执行上述操作

思路：
本体使用栈解决，如果不是“*”就入栈；是“*”就出栈，知道字符串末尾，最后输出栈中剩余的元素即可。

class Solution {
    public String removeStars(String s) {
          int len=s.length();
          Character[] ch=new Character[len];

          String str="";
          for(int i=0;i<len;i++)
          {
              if(s.charAt(i)!='*')
              {
                 ch[top++]=s.charAt(i);
              }
              else 
               ch[--top]=null;
                      
          }
           for(int i=0;i<top;i++)
            {
            if(ch[i]!=null)
              str+=ch[i];
            }
          return str;
        
       
    }

LCR 085. 括号生成

中等

78

相关企业

正整数 n 代表生成括号的对数，请设计一个函数，用于能够生成所有可能的并且有效的括号组合。

示例 1：

输入：n = 3输出：["((()))","(()())","(())()","()(())","()()()"]

示例 2：

输入：n = 1输出：["()"]

提示：

1<=n<=8

思路：

采用dfs递归。左右括号合法性：

1.左括号数量大于等于右括号数量，只要还有右括号就能填左括号

2.左右括号数量相等

class Solution {
    List<String> list=new ArrayList<>();
    public List<String> generateParenthesis(int n) {
        String str="";
        dfs(0,0,n,str);
        return list;
    }

    public void dfs(int left,int right,int n,String str)
    {
        if(left==n&&right==n)
          list.add(str);
        if(left<n) dfs(left+1,right,n,str+'(');
        if(right<n&&right<left)
        dfs(left,right+1,n,str+')');
    }
}

890. 查找和替换模式

中等

211

相关企业

你有一个单词列表 words 和一个模式 pattern，你想知道 words 中的哪些单词与模式匹配。

如果存在字母的排列 p ，使得将模式中的每个字母 x 替换为 p(x) 之后，我们就得到了所需的单词，那么单词与模式是匹配的。

（回想一下，字母的排列是从字母到字母的双射：每个字母映射到另一个字母，没有两个字母映射到同一个字母。）

返回 words 中与给定模式匹配的单词列表。

你可以按任何顺序返回答案。

示例：

输入：words = ["abc","deq","mee","aqq","dkd","ccc"], pattern = "abb"输出：["mee","aqq"]解释："mee" 与模式匹配，因为存在排列 {a -> m, b -> e, ...}。"ccc" 与模式不匹配，因为 {a -> c, b -> c, ...} 不是排列。因为 a 和 b 映射到同一个字母。

提示：

1<=words.length<=50
1<=pattern.length=words[i].length<=20

思路：

我们可以将要匹配的单词转换为数字再和words中字符串进行比较

例如：pattren中“abb”可以转换为1,2,2

words中“abc”转换为1,2,3；“mee”转换为1,2,2。。。

然后再与pattern作比较，只要有一个数组不匹配，就说明不匹配。

class Solution {
    public List<String> findAndReplacePattern(String[] words, String pattern) {
          int[][] fn=new int[100][100];
          int[] a=new int[100];
          int num=0,i,j,k;
          int count;
          List<String> qs=new ArrayList<>();
          for(i=0;i<words.length;i++)
          {
              char[] str=words[i].toCharArray();
              count=0;

              for(j=0;j<words[i].length();j++)
            {
                for(k=0;k<j;k++)
                 if(str[j]==str[k])
                   {
                    fn[i][j]=fn[i][k];
                   break;
                   }
                if(k>=j) { fn[i][j]=++count;}
            
                
            }
          }
          char[] str1=pattern.toCharArray();
          count=0;
          for(i=0;i<pattern.length();i++)
           {
            for(j=0;j<i;j++)
           {
               if(str1[i]==str1[j])
                 {
                   a[i]=a[j];
                 break;
                 }
           }
           if(j>=i) a[i]=++count;
           
           }
           for(i=0;i<words.length;i++)
            {
            for(j=0;j<a.length;j++)
              if(fn[i][j]!=a[j])
               break;
              
            if(j>=a.length)
             qs.add(words[i]);
            }
             return qs;
    }
}

92. 反转链表 II

中等

1.7K

相关企业给你单链表的头指针

head 和两个整数

left 和

right ，其中

left

left 到位置

right 的链表节点，返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5], left = 2, right = 4输出：[1,4,3,2,5]

示例 2：

输入：head = [5], left = 1, right = 1输出：[5]

提示：

链表中节点数目为 n
1<=n<=500
-500<=Node.val<=500
1<=left<=right<=n

进阶：你可以使用一趟扫描完成反转吗？

思路：

使用暴力解决，分条件：

1.如果left==right，说明链表不需要反转

2.不相等

（1）找到需要反转范围的第一个指针同时保存反转范围的前一个指针，防止链表断链；

（2）在left和right范围进行反转链表，记得保存反转链表的头指针的下一个指针

（3）如果left==1，记得改变原链表头指针指向，不等于就进行连接

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
           ListNode p,pre,q,r,s;
           int l=left;
           p=r=head;
           if(left==right)
           {
               return head;
           }
           for(int i=1;i<l;i++)
           {
              r=p;
              p=p.next;
           }
           s=p;
           q=p.next;
           for(int i=left;i<right;i++)
           {
               pre=q.next;
               q.next=p;
               p=q;
               q=pre;
           }
           if(s==head)
           {
             s.next=q;
             head=p;
           }
           else{ 
               r.next=p;
               s.next=q; 
           }
          return head;

    }
}

1170. 比较字符串最小字母出现频次

提示

中等

103

相关企业

定义一个函数 f(s)，统计 s 中（按字典序比较）最小字母的出现频次，其中 s 是一个非空字符串。

例如，若 s = "dcce"，那么 f(s) = 2，因为字典序最小字母是 "c"，它出现了 2 次。

现在，给你两个字符串数组待查表 queries 和词汇表 words 。对于每次查询 queries[i] ，需统计 words 中满足 f(queries[i]) < f(W) 的词的数目，W 表示词汇表 words 中的每个词。

请你返回一个整数数组 answer 作为答案，其中每个 answer[i] 是第 i 次查询的结果。

示例 1：

输入：queries = ["cbd"], words = ["zaaaz"]输出：[1]解释：查询 f("cbd") = 1，而 f("zaaaz") = 3 所以 f("cbd") < f("zaaaz")。

示例 2：

输入：queries = ["bbb","cc"], words = ["a","aa","aaa","aaaa"]输出：[1,2]解释：第一个查询 f("bbb") < f("aaaa")，第二个查询 f("aaa") 和 f("aaaa") 都 > f("cc")。

提示：

1<queries.length<=2000
1<=words.length<=2000
1<=queries[i].length,words[i].length<=10
queries[i][j]、words[i][j] 、都由小写英文字母组成

思路：

1.将所有的words字符串数组的最小字母出现频次分别统计出来，然后用一个整形数组保存；

2.使用for循环，对每一串queries[i]进行统计满足f(queries[i]) < f(words)的数目

这个方法执行时间有点长，对于数据量少的题目可以通过

class Solution {
    public int[] numSmallerByFrequency(String[] queries, String[] words) {
      int[] n=new int[queries.length];
      int[] s=new int[words.length];
      int fx;
      for(int i=0;i<words.length;i++)
       s[i]=f(words[i]);
      for(int i=0;i<queries.length;i++)
      {
         fx=f(queries[i]);
         for(int j=0;j<words.length;j++)
         {
           if(fx<s[j])
             n[i]++;
         }

      }
      return n;
    }
    public int f(String s)
    {
         int count=0;
         char[] ch=s.toCharArray();
         Arrays.sort(ch);
         for(int i=0;i<ch.length;i++)
         {
           if(ch[i]==ch[0])
            count++;
         }
         return count;
    }
}