Lane
java的初步学习

java的初步学习

2024年07月03日 5.8k 字 大概 30 分钟

java的下载与配置

下载java

配置环境变量

  • 右击此电脑，点击属性，找到高级系统设置

  • 点击环境变量

  • 新建系统变量 变量名取为 JAVA_HOME 变量值为安装java的路径

  • 在用户变量的path进行编辑并新增加一行 输入**%JAVA_HOME%\bin**

测试

按下win+R，点击cmd进入命令行，输入java察看是否安装完毕

vscode配置java环境

安装扩展

  • debugger for java
  • language support for java
  • extension pack for java

新建一个Java文件进行运行就好啦

java基础知识(基于MIT 6.092: Introduction To Programming In Java)

给一个课程网站的链接叭:smile:

chapter1-types,variables,operators

first programme

1
2
3
4
5
class Hello{
    public static void main(String[] arguments){
        System.out.println("Hello,world.");
    }
}

分析一下基本结构

1
2
3
4
5
class CLASSNAME{
    public static void main(String[] arguments){
        Statements
    }
}

second programme

1
2
3
4
5
6
class hello1{
    public static void main(String[] arguments){
        System.out.println("what can i say");
        System.out.println("mamba out");
    }
}

type

  1. boolean:真值(true or false)
  2. int:整数
  3. double:Real number(3.14,-2.1)
  4. String:字符串

variables

变量名称

assignment

用”=”进行赋值

third programme

1
2
3
4
5
6
7
class third{
    public static void main(String[] arguments){
        String foo;
        foo="mamba out";
        system.out.println(foo);
    }
}

operators

  1. assignments =
  2. addition +
  3. subtraction -
  4. multiplication *
  5. division /
  6. 使用时的优先级遵守数学中的优先级

string contcation

1
2
3
String foo="man"+"what";
foo=foo+"i"+6;
System.out.println(foo);

hw1

第一次作业设计一个计算最终位置的小程序

1
2
3
4
5
6
7
8
9
10
11
12
public class Gravitycalculator {
    public static void main(String[] arguments)
    {
        double gravity=9.81;
        double initialVelocity=0.0;
        double fallingTime=10.0;
        double initialPosition=0.0;
        double finalPosition=initialPosition+initialVelocity*fallingTime-0.5*gravity*fallingTime*fallingTime;
        System.out.println("The objects position after "+fallingTime+"seconds is"+finalPosition+"m.");
    }
}

chapter2-more types,methods,conditions

more types

  • division(在整数和小数中使用存在差异，这和C语言是相符的)
  • 也存在类型转化，这也和C语言相符合

methods

  • adding methods

for example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class newline {
    public static void Newline(){
        System.out.println("");
    }
    public static void threelines(){
        Newline();Newline();Newline();
    }
    public static void main(String[] arguments){
        System.out.println("line1");
        threelines();
        System.out.println("line2");
    }
}
//通过观察不难发现，本质上类似于C语言中函数的调用
  • parameters
1
2
3
public static void Name(TYPE NAME){
    statement;
}

example

1
2
3
4
5
6
7
8
9
10
public class parameter {
    public static void printsquare(int x){
        System.out.println(x*x);
    }
    public static void main(String[] arguments){
        int value=2;
        printsquare(value*3);
    }
}
//需要注意的是这里引入的变量要与所定义的method相符，然而若定义为double变量输入进的int变量自动转化为double变量
  • multiple parameters

即类似C语言中引入多个参数进行传入

  • return values

同样运用类似的方法，即public static (void=>type name) name()

  • variable scope

变量的作用域就在它们所定义的{}中

1
2
3
4
5
6
7
8
9
10
11
12
public class scope {
    public static void main(String[] arguments){
        int x=6;
        if(x==6){
            x=7;
            int y=8;
            System.out.println("x="+x+"y="+y);
        }
        System.out.println("x="+x+"y="+y);
    }
}
//这段程序就会出现报错，因为y的作用域被限制在if语句的那个括号中

  • methods:building blocks

  • 数学函数(形如Math.+函数进行引用)

conditionals

  • if statement(和C语言中一样)

  • comparision operator(> < >= <= ==)

  • boolean operator(&& ||)

  • else 和 else if

hw2

设计一个计算薪资的程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class foocorporation {
    public static void calculate(double base,double hour){
        if(hour>60)
          {System.out.println("error.");}
        else{
        if(base<8)
          {System.out.println("error.");}
        else
          {
            if(hour>40)
              {System.out.println(40*base+(hour-40)*1.5*base);}
            else
              {System.out.println(base*hour);}
          }
        }
    }
    public static void main(String[] arguments){
        calculate(7.50,35);
        calculate(8.20,47);
        calculate(10.00,73);
    }
}

chapter3-Loops,arrays

good programming style

  • 目的是为了让你的代码可读性更强

  • 在定义变量名时尽量使之与程序本身有关系

  • 用好缩进来表示程序的层次结构

  • 在一行较长的代码中间可适当多加空格

loops

  • the while operator(用法与C语言相同)

  • the for operator(用法与C语言相同)

  • loop的其余用法也都与C语言相同

array

  • create an array
1
2
int [] values=new int [5];
//运用new这个operator
  • initiallize an array
1
2
int [] values={1,2,3,4};
//注意如果已经创立完成后，则此时不能进行初始化操作，只能一个元素进行赋值
  • length of an array
1
int size=values.length;
  • string array
1
2
3
4
5
6
7
8
9
public class string {
    public static void main (String[] arguments){ 
        String[] ceshi=new String[5];
        ceshi[0]="man";
        System.out.println(ceshi[0]+" "+ceshi.length);

        }
}
//String类型能够存储一系列字符串

hw3

寻找一个最大值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class marathon {
    public static void main(String[] arguments)
    {
        String[] names = {
            "Elena", "Thomas", "Hamilton", "Suzie", "Phil", "Matt", "Alex",
            "Emma", "John", "James", "Jane", "Emily", "Daniel", "Neda",
            "Aaron", "Kate"
            };
            int[] times = {
            341, 273, 278, 329, 445, 402, 388, 275, 243, 334, 412, 393, 299,
            343, 317, 265
            };
        int min=1000;int mini=0;
        for(int i=0;i<names.length;i++)
          {
            if(times[i]<min)
            {
               mini=i;
               min=times[i];
            }
          }
        System.out.println("fast runner is "+names[mini]+" his or her time is "+times[mini]);
        int [] flag=new int[times.length];
        flag[mini]=1;min=1000;
        for(int i=0;i<names.length;i++)
        {
            if(times[i]<min&&flag[i]==0)
            {
                mini=i;
                min=times[i];
            }
        }
        System.out.println("second fast runner is "+names[mini]+" his or her time is "+times[mini]);
    }
}

chapter4-class and objects

object oriented programming(面向对象编程)

defining classes

class definition

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package courses;
public class tryclass
{
public class baby {
    //class fields
    String name;
    double weight;
    boolean ismale;
    int numpoops=0;
    //class constructor
    baby(String myname,double myweight,boolean myismale){
        name=myname;
        weight=myweight;
        ismale=myismale;
    }
    //class method
    void sayhi(){
        System.out.println("hi,my name is "+name);
    }
}
}

using classes

example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// 定义外部类 tryclass
public class tryclass {

    // 定义内部类 baby
    public class baby {
        String name;
        double weight;
        boolean ismale;
        int numpoops = 0;

        // 构造方法
        public baby(String myname, double myweight, boolean myismale) {
            name = myname;
            weight = myweight;
            ismale = myismale;
        }

        // 实例方法
        public void poop() {
            numpoops += 1;
            System.out.println("poop.");
        }

        public void sayhi() {
            System.out.println("hi, my name is " + name);
        }
    }

    // 在外部类中使用内部类
    public static void main(String[] args) {
        // 创建内部类的实例
        tryclass outer = new tryclass();
        baby mynewbaby = outer.new baby("kobe", 4.5, true);

        // 访问内部类的成员变量
        System.out.println(mynewbaby.name);

        //调用class中的method
        mynewbaby.sayhi();
    }
}

reference vs values

  • primitives vs references
    primitive type就是java中最基本的如:int,double,float
    reference type是数组和对象

  • references
    object的位置在java中称作reference
    下面的这张图能够比较好解释
    reference
    并使用=update the reference

static methods and types

  • 静态内部类
    特点:不依赖于外部类的实例，可以直接通过外部类的类名访问。
    静态内部类只能访问外部类的静态成员和静态方法，不能直接访问外部类的实例变量或方法。

example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class OuterClass {
    private static int staticVar = 10;
    private int instanceVar = 20;

    static class StaticInnerClass {
        void innerMethod() {
            System.out.println("Static variable in OuterClass: " + staticVar);
            // System.out.println("Instance variable in OuterClass: " + instanceVar); // 编译错误，无法访问实例变量
        }
    }

    public static void main(String[] args) {
        OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();
        inner.innerMethod();
    }
}
  • 静态方法(不需要创造类的实例则可以调用,不能直接访问变量实例或实例方法)与实例方法(必须先创立类的实例再进行调用)

example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//静态
public class MyClass {
    private static int staticVar = 10;
    private int instanceVar = 20;
    
    public static void staticMethod() {
        System.out.println("Static method: " + staticVar);
        // System.out.println("Instance variable: " + instanceVar); // 编译错误，无法访问实例变量
    }
}
//实例
public class MyClass {
    private static int staticVar = 10;
    private int instanceVar = 20;
    
    public void instanceMethod() {
        System.out.println("Instance method: " + instanceVar);
        System.out.println("Static variable: " + staticVar);
    }
}
  • 两者的优劣

静态方法适合那些不依赖于实例变量状态的操作，例如实用程序方法、工具方法或者仅仅对输入参数进行处理的方法。

实例方法适合需要访问和操作实例变量、实现对象特定行为的方法，例如修改对象状态、调用对象的其他方法等。

hw4

这一次的程序涉及两个java程序Book.java和Library.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
package hw;

public class Book {
    String title;
boolean borrowed;
// Creates a new Book 
public Book(String bookTitle) { 

title=bookTitle;
borrowed=false;
} 
// Marks the book as rented 
public void borrowed() { 
borrowed=true;
} 
// Marks the book as not rented 
public void returned() { 
borrowed=false;
} 
// Returns true if the book is rented, false otherwise 
public boolean isBorrowed() { 
return borrowed;
} 
// Returns the title of the book 
public String getTitle() { 
return title;
} 
public static void main(String[] arguments) { 
// Small test of the Book class 
Book example = new Book("The Da Vinci Code");
System.out.println("Title (should be The Da Vinci Code): " + example.getTitle());
System.out.println("Borrowed? (should be false): " + example.isBorrowed());
example.borrowed();
System.out.println("Borrowed? (should be true): " + example.isBorrowed());
example.returned();
System.out.println("Borrowed? (should be false): " + example.isBorrowed());
}
}



public class Library { 
    // Add the missing implementation to this class 
    String address;
    Book []books;
    int num=0;
    int i=0;
    //constructor 还需要熟练
    public Library(String myaddress){
     address=myaddress;
     books=new Book[100];
     num=0;
    }
    //必须声明为实例方法(这一段代码存在问题)
    public void addBook(Book newbook){
    books[i]=newbook;
    i=i+1;
    num=num+1;
    }
    //调用时无须先创建类的实例
    public static void printOpeningHours(){
        System.out.println("hours");
    }
    public void printAddress(){
        System.out.println(address);
    }
    public void borrowBook(String name){
    for(int j=0;j<num;j++){
        if(books[j].title==name){
         if(books[j].borrowed==true){
            System.out.println("the book has been borrowed");
         }
         else{
            books[j].borrowed=true;
            System.out.println("successful");
         }
        }
    }
    }
    public void printAvailableBooks(){
        int flag=0;
        for(int j=0;j<num;j++){
            if(books[j].borrowed==false){
                System.out.println(books[j].title );
                flag=1;
            }
        }
        if(flag==0){
            System.out.println("NO AVALIABLEBOOKS");
        }
    }
    public void returnBook(String name){
        for(int j=0;j<num;j++){
            if(books[j].title==name){
                books[j].borrowed=false;
                System.out.println("successful return the book");
            }
        }
    }
    public static void main(String[] args) { 
    // Create two libraries
     Library firstLibrary = new Library("10 Main St.");
     Library secondLibrary = new Library("228 Liberty St."); 
    // Add four books to the first library 
    firstLibrary.addBook(new Book("The Da Vinci Code"));
    firstLibrary.addBook(new Book("Le Petit Prince"));
    firstLibrary.addBook(new Book("A Tale of Two Cities"));
    firstLibrary.addBook(new Book("The Lord of the Rings"));
    // Print opening hours and the addresses 
    System.out.println("Library hours:");
    printOpeningHours();
    System.out.println();
    System.out.println("Library addresses:");
    firstLibrary.printAddress();
    secondLibrary.printAddress();
    System.out.println();
    // Try to borrow The Lords of the Rings from both libraries 
    System.out.println("Borrowing The Lord of the Rings:");
    firstLibrary.borrowBook("The Lord of the Rings");
    firstLibrary.borrowBook("The Lord of the Rings");
    secondLibrary.borrowBook("The Lord of the Rings");
    System.out.println();
    // Print the titles of all available books from both libraries 
    System.out.println("Books available in the first library:");
    firstLibrary.printAvailableBooks();
    System.out.println();
    System.out.println("Books available in the second library:");
    secondLibrary.printAvailableBooks();
    System.out.println();
    // Return The Lords of the Rings to the first library 
    System.out.println("Returning The Lord of the Rings:"); 
    firstLibrary.returnBook("The Lord of the Rings"); 
    System.out.println(); 
    // Print the titles of available from the first library 
    System.out.println("Books available in the first library:"); 
    firstLibrary.printAvailableBooks(); 
    } 
    }

chapter5-access control,class scope,packages,java api

access control

  • public vs private
    public:其他class都能用
    private:只有这个class可以用

class scope

  • “this” keyword(意味着此对象)
1
2
3
4
5
6
class example{
    int membervariable;
    void setvariable(int newval){
        this.memebervariable+=newval;
    }
}

packages

  • 每一个class若属于一个package目的相同
  • classes若在其他package中，则需要import

example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//隶属于parenttools的java程序
package parenttools;
public class babyfood{

}
//隶属于parenttools的java程序
package parenttools;
public class baby{

}
//隶属于adult的java程序
package adult;
//调用其他package的java程序
import parenttools.babyfood;
import parenttools.baby;
public class parent{
    public static void main(String[] arguments){
        baby mybaby=new baby();
        mybaby.feed(new babyfood());
    }
}

  • 为什么使用package(将相似的函数结合在一起)

  • special package(java.lang 所有的class都能“看见”java.lang中的class)

java API(应用程序接口)

  • array list
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package courses;
import java.util.ArrayList;
public class array {
    public static void main(String[] arguments){
        //创立
        ArrayList<String>myarray=new ArrayList<String>();
        //添加
        myarray.add("湖人");
        myarray.add("勇士");
        //打印
        System.out.println(myarray.size());
        //移除
        myarray.remove(0);
        System.out.println(myarray.get(0));
    }
}
  • Sets(Treeset 和 hashset) 没有下标
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package courses;
import java.util.Treeset;
public class array {
    public static void main(String[] arguments){
        //创立
        Treeset<String>myarray=new Treeset<String>();
        //添加
        myarray.add("湖人");
        myarray.add("勇士");
        //打印
        System.out.println(myarray.size());
        //移除
        myarray.remove("湖人");
        System.out.println(myarray.first());
    }
}
  • maps(存储一组值，通过寻找key返回value)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Map<String, Integer> studentScores = new HashMap<>();

// 添加键值对
studentScores.put("Alice", 85);
studentScores.put("Bob", 90);

// 获取值
int scoreAlice = studentScores.get("Alice");
System.out.println("Alice's score: " + scoreAlice);

// 遍历键值对
for (Map.Entry<String, Integer> entry : studentScores.entrySet()) {
    System.out.println(entry.getKey() + " -> " + entry.getValue());
}

// 检查是否包含某个键
if (studentScores.containsKey("Charlie")) {
    // 如果存在，获取值
    int scoreCharlie = studentScores.get("Charlie");
    System.out.println("Charlie's score: " + scoreCharlie);
} else {
    System.out.println("Charlie's score not found.");
}

  • 补充
1
2
3
4
5
6
7
for (type variable : collection) {
    // 循环体
}
type 是集合中元素的数据类型，例如 Map.Entry<String, Integer> 表示集合中的元素类型为 Map.Entry，键类型为 String，值类型为 Integer。
variable 是在每次循环迭代时，用来表示集合中当前元素的变量名，这里是 entry。
collection 是要进行迭代的集合或数组，例如 studentScores.entrySet() 返回的是一个包含 Map.Entry<String, Integer> 对象的集合。
因此，Map.Entry<String, Integer> entry : studentScores.entrySet() 的意思是，对于 studentScores 这个 Map 中的每一个键值对，将其表示为 Map.Entry<String, Integer> 类型的 entry，然后在循环体中可以使用 entry 来访问每个键值对的键和值。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//java中读取的方式
import java.util.Scanner;

public class ReadInput {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter an integer: ");
        int number = scanner.nextInt(); // 读取整数

        System.out.print("Enter a double: ");
        double decimal = scanner.nextDouble(); // 读取浮点数

        System.out.print("Enter your name: ");
        String name = scanner.next(); // 读取字符串（以空格为分隔符）

        System.out.println("You entered: " + number + ", " + decimal + ", " + name);

        scanner.close(); // 关闭Scanner对象
    }
}

hw5

设计一个动画，但是主程序已经给出，主要修改一个副程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package hw;

import java.awt.Color;
import java.awt.Graphics;
public class DrawGraphics {
BouncingBox box;
/** Initializes this class for drawing. */ 
public DrawGraphics() {
box = new BouncingBox(200, 40, Color.RED);

}
/** Draw the contents of the window on surface. Called 20 times per second. */ 
public void draw(Graphics surface) {
surface.drawLine(50, 50, 250, 250);
box.draw(surface);
}
}

//最终版本
package hw;
import java.util.ArrayList;
import java.awt.Color;
import java.awt.Graphics;
public class DrawGraphics {
BouncingBox box;
ArrayList<BouncingBox>boxes=new ArrayList<BouncingBox>();
/** Initializes this class for drawing. */ 
public DrawGraphics() {
boxes.add(new BouncingBox(200,40,Color.RED));
boxes.add(new BouncingBox(10,100,Color.BLUE));
boxes.add(new BouncingBox(30,120,Color.WHITE));
boxes.get(0).setMovementVector(0,1);
boxes.get(1).setMovementVector(0,-1);
boxes.get(2).setMovementVector(1,1);
}
/** Draw the contents of the window on surface. Called 20 times per second. */ 
public void draw(Graphics surface) {
surface.drawLine(50, 50, 250, 250);
for(int i=0;i<boxes.size();i++){
    boxes.get(i).draw(surface);
}
}
}

chapter6-design,debugging,interfaces

good programme designing

debugging

  • assert(感觉比较类似python中的assert)
1
2
3
4
5
6
7
8
9
10
11
12
public class assertjava {
    public static void main(String[] args) {
        int x = 10;
        assert x == 10 : "x should be equal to 10"; // 简单断言

        int y = 5;
        assert y == 1 : "y should be equal to 10"; // 失败的断言，将会抛出 AssertionError
        
        System.out.println("Assertions passed."); // 如果所有断言通过，会执行到这里
    }
}

interfaces

java内置常见方法

List类

1
2
3
4
5
6
7
8
9
10
11
12
13
在 Java 中，List<Integer> 的常用方法包括：

get(int index): 获取指定索引处的元素。
set(int index, Integer element): 替换指定索引处的元素。
remove(int index): 删除指定索引处的元素。
size(): 返回列表中的元素数量。
isEmpty(): 检查列表是否为空。
clear(): 清空列表中的所有元素。
contains(Object o): 检查列表是否包含指定的元素。
indexOf(Object o): 返回第一次出现指定元素的索引。
subList(int fromIndex, int toIndex): 获取指定范围内的子列表。
toArray(): 转换为数组。
clone(): 适用于一维数组

Stringbuilder(处理大量字符串时可以使用)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 创建 StringBuilder 对象
StringBuilder sb = new StringBuilder();
可以选择在构造函数中传入初始字符串：
StringBuilder sb = new StringBuilder("Initial String");
2. 添加字符串
使用 append() 方法向 StringBuilder 对象添加内容：
sb.append("Hello");
sb.append(" ");
sb.append("World");
3. 插入字符串
使用 insert() 方法可以在指定位置插入字符串：
sb.insert(5, "Awesome ");
在这种情况下，将在位置5之前插入字符串"Awesome "。

4. 删除字符串
使用 delete() 方法可以删除指定位置范围内的字符串：
sb.delete(5, 13);
这将从位置5开始删除8个字符(13-5).

5. 替换字符串
使用 replace() 方法可以替换指定位置范围内的字符串：
sb.replace(5, 12, "Goodbye");
这将从位置5到12之间的字符串替换为"Goodbye".

6. 反转字符串
使用 reverse() 方法可以反转 StringBuilder 对象中的内容：
sb.reverse();
7. 获取字符串
使用 toString() 方法可以将 StringBuilder 对象转换为 String 类型：
String result = sb.toString();
8. 获取长度和容量
length() 方法用于获取当前字符序列的长度。
capacity() 方法用于获取 StringBuilder 对象当前的容量。

String类(字符串处理方式)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
length(): 返回字符串的长度。
charAt(int index): 返回指定索引处的字符。
substring(int beginIndex, int endIndex): 返回从 beginIndex 到 endIndex 之间的子字符串。
indexOf(String str): 返回指定子字符串第一次出现的位置。
lastIndexOf(String str): 返回指定子字符串最后一次出现的位置。
contains(CharSequence sequence): 判断字符串是否包含指定的字符序列。
startsWith(String prefix): 判断字符串是否以指定前缀开始。
endsWith(String suffix): 判断字符串是否以指定后缀结束。
replace(CharSequence target, CharSequence replacement): 替换所有出现的指定子字符串。
trim(): 去除字符串两端的空白字符。
toLowerCase(): 将字符串转换为小写。
toUpperCase(): 将字符串转换为大写。
split(String regex): 根据正则表达式分割字符串。
concat(String str): 将指定字符串连接到当前字符串的末尾。
equals(Object anObject): 比较两个字符串的内容是否相同。
compareTo(String anotherString): 按字典顺序比较两个字符串。
toCharArray(): 字符串转化为字符数组
valueOf(): 将整数转化为字符串

hashmap

1
2
3
4
5
6
7
8
9
10
11
12
13
14
HashMap 主要方法包括：
put(K key, V value): 添加或更新键值对。
get(Object key): 获取指定键的值。
remove(Object key): 删除指定键的键值对。
containsKey(Object key): 检查是否包含指定键。
containsValue(Object value): 检查是否包含指定值。
keySet(): 返回所有键的集合。
values(): 返回所有值的集合。
entrySet(): 返回所有键值对的集合。
size(): 返回映射中键值对的数量。
clear(): 清空映射。
getOrDefault(K key, V defaultValue) 是 Java Map 接口中的一个方法，用于在指定键不存在时提供一个默认值。它的作用是：
如果指定的键存在于映射中：返回与该键关联的值。
如果指定的键不存在于映射中：返回提供的默认值。

leetcode记录

滑动窗口

209 长度最小的子数组（中等）

  • 最开始利用java语言尝试用暴力法进行解决但是运行超时，现在准备用滑动窗口的思路进行解决。
  • 解决此问题的大体思路是利用双指针的思想，头尾进行向右移动的操作，如果此时的sum>=target，则start向右移动，否则end向右移动。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.util.List;
import java.util.ArrayList;
class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int  n=nums.length;
        int start=0;int end=0;
        int sum=nums[0];
        int ans=1;int flag=0;int min=1000000;
        while(true)
        {
           if(sum>=target)
              {
                sum=sum-nums[start];start++;flag=1;
               if(ans<min) min=ans;
               if(start>n-1) break;
               ans--;
            }
           else
                {
                if(end==n-1) break;
                end++;sum=sum+nums[end];ans++;
                }
        }
        if(flag==1) return min;
        else return 0;
    }
}

30 串联所有单词的子串（困难）

  • 最开始的思路就是从给定的字符串入手一个一个往前找，
    但是检测到178项时出现超时的情况，只有再进一步结合滑动窗口的特性进行算法的优化。这样的时间复杂度为$o(n^2)$

  • 改进算法:根据题解可以知道需要利用哈希表加上滑动窗口对算法进行优化

  1. 我们首先使用一个哈希表map来记录words中单词与其相应的出现的次数
  2. 然后我们可以对于输入的字符串s进行分析，每次进行取长度为mxn的子串
  3. 但是这样写出来的程序仍然存在超时的可能，我们可以进行取余的优化
  4. 也就是通过单词长度的余数进行分类的区划，在每一个区划中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import java.util.List;
import java.util.ArrayList;
import java.lang.StringBuilder;
class Solution {
      public List<Integer> findSubstring(String s, String[] words) {
    int n=s.length(),m=words.length,w=words[0].length();
    Map<String,Integer> map=new HashMap<>();
    for(String str:words) map.put(str,map.getOrDefault(str,0)+1);
    List<Integer> ans=new ArrayList<>();
    for(int i=0;i<w;i++)
    {
         Map<String,Integer> temp=new HashMap<>();
         for(int j=i;j+w<=n;j=j+w)
         {
            String cur=s.substring(j,j+w);
            temp.put(cur,temp.getOrDefault(cur,0)+1);
            if (j >= i + (m * w)) {
                    int idx = j - m * w;
                    String prev = s.substring(idx, idx + w);
                    if (temp.get(prev) == 1) temp.remove(prev);
                    else temp.put(prev, temp.get(prev) - 1);
                    if (!temp.getOrDefault(prev, 0).equals(map.getOrDefault(prev, 0))) continue;
                }

              if(!temp.getOrDefault(cur,0).equals(map.getOrDefault(cur,0))) continue;
              if(temp.equals(map)) ans.add(j-(m-1)*w);
         }

    }
    return ans;
}
}

76 最小覆盖子串（困难）

动态规划

3259 最大化的能量（中等）

698 划分为k个相等的子集（中等）

  • 感觉每日一题得坚持下去

字符串

3265 统计近似相等数对（中等）

  • 这是一场周赛的题目，当时我作答时最开始使用哈希表思路有误
  • 后面发现可以通过将整数转化为字符串，再将字符串转化为字符数组
  • 然后进行暴力交换进行枚举应该能通过测试，因为这道题的数量级并不是很大
  • 在暴力修改的过程中发现出现问题，最重要的问题就是每个整数都会存在一个前导零，所以交换后可能存在0的情况
  • 一个多小时的缝缝补补，终于结束了，码力还得练
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
class Solution {
    public int countPairs(int[] nums) {
           int n=nums.length;
           int ans=0;
            int[][] flag=new int[nums.length][nums.length];//用来记录当前数与后面的数是否已经配对
           for(int i=0;i<n;i++)
            {
                String temp=String.valueOf(nums[i]);
                char[] tempch=new char[temp.length()];
                tempch=temp.toCharArray();
                if(tempch.length>1)
                {
               
                for(int j=0;j<tempch.length-1;j++)
                   {
                      for(int j1=j;j1<tempch.length;j1++)
                        {
                            char[] tempch1=new char[tempch.length];
                            tempch1=tempch.clone();
                            char zhong=tempch1[j1];
                            tempch1[j1]=tempch1[j];
                            tempch1[j]=zhong;
                            int p=(int)Math.pow(10,tempch1.length-1);
                            int num=0;int t=0;
                            while(p>0)
                              {
                                num=num+(int)(tempch1[t]-'0')*p;
                                t++;
                                p=p/10;
                              }
                              /*for(t=0;t<tempch1.length;t++)
                                System.out.print(tempch1[t]);*/
                             
                             for(t=0;t<n;t++)
                                if(t!=i&&num==nums[t]&&flag[i][t]==0&&flag[t][i]==0)
                                  {ans++;flag[t][i]=1;flag[i][t]=1;System.out.println(num);}
                        }
                   }
                }
                else
                   {
                      int num1=nums[i];
                      int num2=nums[i]*10;
                      for(int t=i+1;t<n;t++)
                         {
                            if(nums[t]==num1||nums[t]==num2)
                              {ans++;flag[t][i]=1;}
                         }
                   }
            }
           return ans;
    }
    
}
本文作者：Lane
本文链接：https://lakerswillwin.github.io/2024/07/03/java/
版权声明：本文采用 CC BY-NC-SA 3.0 CN 协议进行许可
技术