一、学习内容
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.进行数据库连接时，发现数据库版本过低，不能获取到数据库信息，然后就去问了其他实验室的朋友，在项目中加入了新的数据库；
二、每日一题
困难
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;
}中等
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+')');
}
}中等
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;
}
}中等
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;
}
}提示
中等
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;
}
}
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
