Java第一部分学习总结

最新推荐文章于 2024-07-23 21:45:09 发布
最新推荐文章于 2024-07-23 21:45:09 发布
阅读量216 收藏
点赞数
分类专栏： 学习笔记 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47467922/article/details/122927843
版权

目录

一、基础知识

1.JDK、JVM、JRE

2.标识符、保留字、关键字

3.数据类型

4.变量及命名规范

5.运算符

6.基本结构

6.1顺序结构

6.2选择结构

6.3 循环结构

7.方法

8.面向对象与面向过程

二、进阶知识

1.内存分析

1.1 栈

1.2 堆

1.3 方法区

2.内存管理、垃圾回收机制

3.构造方法、继承、重载、重写

3.1 构造器（构造方法）

3.2 重载

3.3 继承

3.4 重写

4.封装、多态

5.抽象类、接口

7.内部类

8.数组

9.包装类

10.异常处理

11.File类

12.日期处理

三、框架学习总结

1.需求分析

 2.步骤总结：

2.1 建立并配置实体类TestItem

2.2 建立并配置TestItemManager

 2.3 界面建立

2.4 界面按钮配置

一、基础知识

1.JDK、JVM、JRE

JDK是 Java 语言的软件开发工具包(SDK)。在JDK的安装目录下有一个jre目录，里面有两个文件夹bin和lib，在这里可以认为bin里的就是JVM（Java Virtual Machine），lib中则是jvm工作所需要的类库，而jvm和lib合起来就称为JRE（Java Runtime Environment，Java运行环境）。                                                                                                                                          

2.标识符、保留字、关键字

Java标识符用作给变量、类和方法命名。
Java 关键字又称为保留字，是 Java 语言保留供内部使用的 , 如 class 用于定义类，因此不能使用关键字作为变量名或方法名。
不合法的标识符： 
int 1a = 3; //不能用数字开头
int a# = 3; //不能包含#这样的特殊字符
int int = 3; //不能使用关键字

3.数据类型

Java 是一种强类型语言，每个变量都必须声明其类型。类型的分类如图所示：

各类型的关键字及占用如下表所示：
类型名称关键字占用内存取值范围
字节型byte1 字节-128~127
短整型short2 字节-32768~32767
整型int4 字节-2147483648~2147483647
长整型long8 字节-9223372036854775808L~9223372036854775807L
单精度浮点型float4 字节+/-3.4E+38F（6~7 个有效位）
双精度浮点型double8 字节+/-1.8E+308 (15 个有效位）
字符型char2 字节ISO 单一字符集
布尔型boolean1 字节true 或 false

自动类型转换：容量小的数据类型可以自动转换为容量大的数据类型。

强制类型转换，转换一个数值的类型 .， 有可能丢失信息，可能造成精度降低或溢出。
强制类型转换的语法： 
double x = 3.14;
 
int nx = (int)x; //值为 3

4.变量及命名规范

Java 变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
变量在使用前必须对其声明 , 只有在变量声明以后，才能为其分配相应长度的存储单元。
命名规范：
1. 所有变量、方法、类名：见名知意
2. 类成员变量：首字母小写和驼峰原则 : monthSalary
3. 局部变量：首字母小写和驼峰原则
4. 常量：大写字母和下划线： MAX_VALUE
5. 类名：首字母大写和驼峰原则 : Man, GoodMan
6. 方法名：首字母小写和驼峰原则 : run(), runRun()
示例如下： 
public interface YtAsnManager  extends BaseManager {

	void storeYtAsn(YtAsn asn);

	void addDetail(Long asnId ,Integer qty,YtAsnDetail asnDetail);

5.运算符

6.基本结构

6.1顺序结构

顺序结构在程序流程图中的体 现就是用流程线将程序框自上而地连接起来，按顺序执行算法步骤。

6.2选择结构

  • if...else
  • switch...case

示例如下：

   int x = 30;
 
      if( x == 10 ){
         System.out.print("Value of X is 10");
      }else if( x == 20 ){
         System.out.print("Value of X is 20");
      }else if( x == 30 ){
         System.out.print("Value of X is 30");
      }else{
         System.out.print("这是 else 语句");
      }

      switch(x){
        case 10:System.out.print("10");break;
        case 20:System.out.print("20");break;
        case 30:System.out.print("30");break;
        case 40:System.out.print("40");break;
        case 50:System.out.print("50");break;
      }

6.3 循环结构

  • while
  • do…while
  • for

示例如下：

int i = 0; 
int sum = 0; 
while (i <= 100) { 
    sum += i; 
    i++; 
}
System.out.println("Sum= " + sum); }

do { 
sum += i;
i++; 
} while (i <= 100); 
System.out.println("Sum= " + sum); }


for(int i = 1;i<=100;i++){ 
    System.out.println(i); 
}

与其他两者不同，do while是先执行再判断，do内的内容至少执行一次。因而使用相对较少。

7.方法

Java方法是语句的集合，它们在一起执行一个功能。

  • 方法是解决一类问题的步骤的有序组合
  • 方法包含于类或对象中
  • 方法在程序中被创建，在其他地方被引用

方法类似于C语言中的函数。同样具有形参和实参。有返回值等参数.

8.面向对象与面向过程

面向对象：

  • 结构清晰，程序是模块化和结构化，更加符合人类的思维方式；
  • 易扩展，代码重用率高，可继承，可覆盖，可以设计出低耦合的系统；
  • 易维护，系统低耦合的特点有利于减少程序的后期维护工作量。

二、进阶知识

1.内存分析

1.1 栈

  • 每个线程私有，不能实现线程间的共享！
  • 局部变量放置于栈中。
  •  栈是由系统自动分配，速度快！栈是一个连续的内存空间！

1.2 堆

  • 放置 new 出来的对象！
  • 堆是一个不连续的内存空间，分配灵活，速度慢！

1.3 方法区

  • 本质也是堆
  • 被所有线程共享！
  • 用来存放程序中永远是不变或唯一的内容。（类代码信息、静态变量、字符串常量）

2.内存管理、垃圾回收机制

JAVA 的内存管理实际上指的就是对象的管理，其中包括对象空间的分配和释放。
  • 对象空间的分配 ：使用 new 关键字创建对象即可
  • 对象空间的释放 ：将对象赋值 null，即该对象没有引用指向时。垃圾回收器将负责回收所有”不可达”对象的内存空间

注意事项： 

  • 程序员无权调用垃圾回收器。
  • 程序员可以通过 System.gc()。通知 GC 运行，但是 JAVA 规范并不能保证立刻运行。
  • finalize 方法，是 JAVA 提供给程序员用来释放对象或资源的方法，但是尽量少用。

3.构造方法、继承、重载、重写

3.1 构造器（构造方法）

构造器用于构造该类的实例，如果我们没有定义构造器，则系统会自动定义一个无参的构造函数。如果已定义则编译器不会添加。 构造器的方法名必须和类名一致

public class Car {
    int speed; 
    public Car(){ 
        System.out.println("构造一个车"); 
    } 
}

3.2 重载

方法的重载是指一个类中可以定义有相同的名字，但参数不同的多个方法。 调用时，会根据不同的参数表选择对应的方法。构造方法也可以重载。

3.3 继承

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

3.4 重写

子类可以继承父类的对象方法，在继承后，重复提供该方法，就叫做方法的重写，又叫覆盖 override

示例如下：

public class Human {
     String name = "Human";
     final static String aim="alive";
     static String need;
     public String getName(){
         return this.name;
     }
    public void sleep() {
        System.out.println("Human sleep..");
    }

    public static void main(String[] args) {
    	Human.need="food";
    	System.out.println(Human.need);
    	
    }
}

class Male extends Human {
    String name = "Male";
    public String getName(){
        return this.name;
    }
    @Override
    public void sleep() {
        System.out.println("Male sleep..");
    }

    public void speak() {
        System.out.println("I am Male");
    }
}

class Female extends Human {
    String name = "Female";
    
    public String getName(){
        return this.name;
    }
    @Override
    public void sleep() {
        System.out.println("Female sleep..");
    }

    public void speak() {
        System.out.println("I am Female");
    }
}

4.封装、多态

  • 封装的意义在于保护或者防止代码（数据）被我们无意中破坏。
  • 保护成员属性，不让类以外的程序直接访问和修改；
  • 隐藏方法细节

 

多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

 示例如下：

public class Hero {
    public String name;
    protected float hp;
 
    public void useItem(Item i){
        i.effect();
    }
 
    public static void main(String[] args) {
         
        Hero garen =  new Hero();
        garen.name = "盖伦";
     
        LifePotion lp =new LifePotion();
        MagicPotion mp =new MagicPotion();
         
        garen.useItem(lp);
        garen.useItem(mp);     
         
    }
       
}

5.抽象类、接口

只声明了方法，同时使用了 abstract 修饰，没有方法体，必须要子类来重写的方法称为抽象方法。
具有抽象方法的类称为抽象类。
接口是比 “ 抽象类 ” 还 “ 抽象 ” 的 “ 抽象类 ”，可以更加规范的对子类进行约束。实现了：规范和具体实现的分离。
  • 抽象类提供某些具体实现
  • 接口不提供任何实现
接口中所有方法都是抽象方法。接口是完全面向规范的，规定了一批类具有的公共方法规范。
示例如下： 
package animalworld;

public interface Pet {
public String getName();
public void setName(String name);
public void play();
}



package animalworld;

public class Spider extends Animal {
	
	public Spider(){
		super(8);
		System.out.println("Here is a spider ohhhhhh\n");
	}
	public void eat(){
		System.out.println("spider eat\n");
	}
	

}

package animalworld;
public abstract class Animal{
	protected int legs;
	protected Animal(int legs){
		this.legs=legs;
	}
	public void walk(){
		System.out.println("This animal use "+legs+" legs walked");
	}
	public abstract void eat();
	public static void main(String []args){
		Cat a=new Cat("喵喵");
		a.getName();
		a.eat();
		a.play();
		a.walk();
		
	}
}

package animalworld;

public class Cat extends Animal implements Pet {

	String name;
	public Cat(String name){
		super(4);
		this.name=name;
		System.out.println("there is a cat called"+name+".How quite it is.\n");
	}
	public Cat(){
		//this("");
		super(4);
	}
	@Override
	public String getName() {
		// TODO Auto-generated method stub
		return name;
	}
	@Override
	public void setName(String name){
		// TODO Auto-generated method stub
		this.name=name;
	}
	@Override
	public void play() {
		// TODO Auto-generated method stub
		System.out.println("huluhulu\n");
	}
	@Override
	public void eat() {
		// TODO Auto-generated method stub
		
	}

}

7.内部类

把一个类放在另一个类的内部，即为内部类。
  • 内部类只让外部类访问，封装更好。
  • 内部类可以访问外部类的私有属性，外部类不能访问内部类的私有属性。

8.数组

数组是一个固定长度的，包含了相同类型数据的容器。数组的元素可以是任何数据类型，也可以看成是对象。

示例如下：

public class test1 {
    public static void main(String[] args) {
        int[] a = new int[5];
 
        a[0] = (int) (Math.random() * 100);
        a[1] = (int) (Math.random() * 100);
        a[2] = (int) (Math.random() * 100);
        a[3] = (int) (Math.random() * 100);
        a[4] = (int) (Math.random() * 100);
        int min=a[0];
        int max=a[0];

        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
            if (min>a[i])
               min=a[i];
            if (max<a[i])
                max=a[i];
        }
        System.out.println("min: "+min);
        System.out.println("max: "+max);
    }
}

9.包装类

包装类即为将原始数据类型转换为对象，以及将对象转换为原始数据类型的机制。

 包装类提供了大量的方法便于对各种情况的处理，详见此博文：

Java包装类 - Java教程™ (yiibai.com)

示例如下：

public class WrapperExample1 {
    public static void main(String args[]) {
        // Converting int into Integer
        int a = 20;
        Integer i = Integer.valueOf(a);// converting int into Integer
        Integer j = a;// autoboxing, now compiler will write Integer.valueOf(a)
                        // internally

        System.out.println(a + " " + i + " " + j);
    }
}

10.异常处理

JAVA 是采用面向对象的方式来处理异常的。处理过程：
  • 1. 抛出异常
  • 2. 捕获异常

 

 try执行语句，抛出异常时catch捕获异常，无论是否catch，最终都执行finally中的代码块。

示例如下：

// 文件名称 CheckingAccount.java
import java.io.*;
 
//此类模拟银行账户
public class CheckingAccount
{
  //balance为余额，number为卡号
   private double balance;
   private int number;
   public CheckingAccount(int number)
   {
      this.number = number;
   }
  //方法：存钱
   public void deposit(double amount)
   {
      balance += amount;
   }
  //方法：取钱
   public void withdraw(double amount) throws
                              InsufficientFundsException
   {
      if(amount <= balance)
      {
         balance -= amount;
      }
      else
      {
         double needs = amount - balance;
         throw new InsufficientFundsException(needs);
      }
   }
  //方法：返回余额
   public double getBalance()
   {
      return balance;
   }
  //方法：返回卡号
   public int getNumber()
   {
      return number;
   }
}

//文件名称 BankDemo.java
public class BankDemo
{
   public static void main(String [] args)
   {
      CheckingAccount c = new CheckingAccount(101);
      System.out.println("Depositing $500...");
      c.deposit(500.00);
      try
      {
         System.out.println("\nWithdrawing $100...");
         c.withdraw(100.00);
         System.out.println("\nWithdrawing $600...");
         c.withdraw(600.00);
      }catch(InsufficientFundsException e)
      {
         System.out.println("Sorry, but you are short $"
                                  + e.getAmount());
         e.printStackTrace();
      }
    }
}

// 文件名InsufficientFundsException.java
import java.io.*;
 
//自定义异常类，继承Exception类
public class InsufficientFundsException extends Exception
{
  //此处的amount用来储存当出现异常（取出钱多于余额时）所缺乏的钱
  private double amount;
  public InsufficientFundsException(double amount)
  {
    this.amount = amount;
  } 
  public double getAmount()
  {
    return amount;
  }
}

11.File类

File 类可以实现在程序中操作文件和目录，如新建、删除、重命名文件和目录等。

Java File类（文件操作类）详解 (biancheng.net)icon-default.png?t=M0H8http://c.biancheng.net/view/1133.html示例如下：

package file;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FilePractice {
	public static void copyFile(String srcFile,String destFile){
		File src = new File(srcFile);
		File dest = new File(destFile);
		try{
			FileInputStream read = new FileInputStream(src);
			FileOutputStream write = new FileOutputStream(dest);
			byte a[] = new byte[(int)src.length()];
			read.read(a);
			write.write(a);
		}
		catch(IOException e){
			e.printStackTrace();
		}
	}
	public static void copyFolder(String srcFolder, String destFolder){
		
		String []filelist = testab.bianli(srcFolder);
		
	}
	public static void main(String []args){
		FilePractice.copyFile("d:/1.PNG","d:/xyz/1.PNG");
		
	}
	
}

12.日期处理

java.util 包提供了 Date 类来封装当前的日期和时间。

常用的时间类还包括：SimpleDateFormat、Calander、GregorianCalendar等，提供了不同当时强大的功能。

示例如下;

import java.util.Calendar;

public class Test {
    public static void main(String[] args) {
            Calendar c1 = Calendar.getInstance();
            c1.set(2017, 2, 1);
            System.out.println(c1.get(Calendar.YEAR)
                    +"-"+c1.get(Calendar.MONTH)
                    +"-"+c1.get(Calendar.DATE));
            c1.set(2017, 2, -10);
            System.out.println(c1.get(Calendar.YEAR)
                    +"-"+c1.get(Calendar.MONTH)
                    +"-"+c1.get(Calendar.DATE));
    }
}

三、框架学习总结

1.需求分析

 

 2.步骤总结：

2.1 建立并配置实体类TestItem

该目录下创建两个文件夹和两个文件：

 在TestItem.java文件中，定义code、name属性，并定义相应的get、set方法：

  创建test数据库，设置ID为主键，表结构如图

 根据表结构和表名称，在hbm文件夹下使用TestItem.hbm.xml文件配置与TestItem.java 关联的表。

 在该文件中，配置TestItem.hbm.xml文件

2.2 建立并配置TestItemManager

在该目录下创建两个文件夹和两个文件：

 

 在TestItemManager.java中构造方法

 

 在DefaultTestItemManager.java中实现相应的方法

 在该文件中对服务进行配置：

 2.3 界面建立

在该注册文件中注册所需的界面。

注册菜单 menuconfig.xml

在该目录中新建文件：

 

maintainTestItemPage.xml是TestItem的主界面配置文件，如图所示：

 利用HQL语句查询数据库内容，利用column配置界面显示的方式

 maintainTestItemPage_zh.properties配置主界面的国际化

 

editTestItemPage.xml是新建界面的配置文件，如图：

  editTestItemPage_zh.properties配置新建界面的国际化

 

2.4 界面按钮配置

新在建流新建流程文件程文件

在该路径下新建流程文件 testProcess.xml

 

该路径下，对按钮进行配置：maintainTestItemPage.wf.xml

editTestItemPage.wf.xml

 

 

 

Meta physika
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 第一节课 总结
g529739784的专栏
03-27 834
第一节课Java总结 概述          Java语言是由Sun公司于1995年推出的一种新的编程语言，它是一种跨平台、适合于分布式计算环境的纯面向对象语言。 JVM:Java虚拟机； API：Java应用程序编程接口。 获取和安装Java开发工具集（JDK） 网址：http://www.oracle.com/cn ¯       JDK6.0组成结构
Java基础学习总结
农村小白的博客
02-21 3244
Java基础知识总结，在学习这一门语言新知识点新技术的过程中很枯燥很不容易很有压力，但它必须要经历这些过程，它就是要从认识、模仿、练习、总结、理解与掌握并实际运用的历程；废话少说，请看以下详细文档： 一、基本概念： 1、java语言特点：简单、面向对象、分布式、解析型、稳定、安全、结构中立、易移值、高性能、多线程、动态语言.... 2、java环境的搭建 cmd运行java文件 jdk与...
Java基础整理（二）
SilenceSpeaks的博客
11-15 237
6 线程与异常 线程 线程的生命周期 新建状态: 使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。 就绪状态: 当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。 运行状态: 如果就绪状态的线程获取 CPU 资源，...
java基础第一阶段的学习总结。
zgz15515397650的博客
07-19 1899
经过在尚学堂的一周的学习，不仅学到了非常多的东西，也让自己知道了明确的学习目标。 下面我就具体来总结一下这周的所学到的知识点： 学了逻辑运算符，&、| 逻辑与和逻辑或。还有他们两个的短路运算符 &&、||。 三目运算符： x>y?x:y; 运算符的优先级：赋值三目逻辑关系算术单目。 强制类型转换：（转换类型）变量名 +=、-=、/=、*=是赋值运算符。 三种基本流程控制：顺序、选择、
java学习总结_java学习的第一阶段总结
weixin_39553156的博客
02-16 151
前言：在大一学习了C语言之后，基本掌握了一门面向过程的程序设计语言，本学期所学习的java是一门面向对象的语言，在问题的解决方面不像C一样是以过程来思考问题，而是要以面向对象的思维来解决问题。此篇文章是对于本学期前三次Java作业的一个阶段性总结，第一次作业花费了最多的时间，有一个测试点没有过，第二次花费了大概3.5小时，第三次大概花费了8小时，作业难度不大，只是需要自主学习的知识还有很多。1.作...
java学习总结.doc
01-07
理解如何定义类和创建对象是学习Java的第一步。 2. 常量定义 常量是不可改变的值，可以使用关键字`final`来定义。例如，`final int MAX_VALUE = 100;`表示一个最大值为100的常量。 3. 变量及声明 变量是用来存储...
Java实现常见排序算法总结
05-02
我们首先假定数组的第一个元素已经是有序的，然后从第二个元素开始，依次将其与已排序的部分进行比较，找到合适的位置插入。这个过程会将数组分为已排序和未排序两部分，直到所有元素都被插入到正确的位置。 ```...
Java之IO流学习总结.pdf
10-03
Java的IO流是编程中不可或缺的一部分，主要用于数据的输入和输出操作。在Java中，流（Stream）是一个抽象的概念，它代表了一个数据序列，可以是从硬盘、内存、键盘读取数据，也可以向这些地方写入数据。流的机制使得...
Java零基础小白学习重点难点总结老杜
07-07
理解它们的区别和用法是学习Java的第一步。 - 控制流：包括条件语句（if-else）、循环（for、while、do-while）以及switch-case，这些都是程序逻辑的基础。 - 方法（Method）：用于封装代码，实现功能重用。 2. *...
Java第三周总结图片
12-01
以上就是Java第三周学习中涉及的主要知识点。通过深入理解和实践这些概念，开发者能够构建出功能强大且健壮的Java应用程序。在这个过程中，不断练习和解决问题将是巩固知识、提升技能的有效途径。
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1077
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java内存模型
weixin_44267758的博客
07-19 761
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 736
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1293
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
java算法day19
TOMOT77的博客
07-20 293
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
springboot之自动装配
weixin_50153914的博客
07-23 210
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1179
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 946
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
[Jenkins]jenkins-cli.jar调用用户token启动任务
最新发布
China_Yanhy的博客
07-23 518
jenkins-cli.jar调用用户token启动任务
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值