Java常用类

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量99 收藏
点赞数
分类专栏： Java工程师 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47432345/article/details/128346454
版权

常用类

包装类(Wrapper)

为什么要有包装类

java在面向对象的路上越走越远 连基本数据类型都不放过 为他们都添加了包装类 在使用时不用担心有自动的装箱拆箱使用包装类的目的是让基本数据类型也享有Object的方法 当用到包装类的时候就知道问什么基本数据类型会用到object的方法了 因为java就是按照万物皆object的想法构思的 基本数据类型如果没有包装类的话就会在java里格格不入 迟早陷入尴尬的局面

自动拆装箱如何使用 这没啥好讲的 无非就是编译过程中去除了相关的检查 在编译时自动将对应的两个类型转换一下罢了 没啥好讲的

数包装类型都继承自number类 number作为一个抽象类存在的目的就是为了被继承作为一个父类

统领所有的包装数类给他们添加了转换为基本数据类型的方法 但其实质也就是强制转换罢了 难道强制转换还不配你去学习吗

自动拆装箱不仅擦除了编译时异常 在两者出现的任何时间任何地点都做了智能处理 如时智能处理并不会拘泥于引用类型与基本数据类型为false的情况 就如string重写equals方法一样智能 自动拆装箱的存在你可以完全将integer看做int而不用担心任何事情 甚至Integer a=1;a==1时为true;看到有多智能了没

包装类的分类

  1. 针对八种基本数据类型相应的引用类型 - 包装类
  2. 有了类的特点，就可以调用类中的方法
基本数据类型包装类
booleanBoolean
charCharacter
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble

表格中后面 6 中类型都继承了 Number 类，如下图所示

image-20221116142728874

image-20221116142754030

image-20221116142807736

包装类和基本数据的转换

装箱：基本类型 -> 包装类型，反之，拆箱

  1. 在 jdk5 前的手动装箱和拆箱方式

    以 int 和 Integer 为例

    //手动装箱 int->Integer
int n1 = 100;
Integer integer = new Integer(n1); // 方式一
Integer integer1 = Integer.valueOf(n1);// 方式二
//手动拆箱
//Integer -> int
int i = integer.intValue()

  2. jdk5（含）以后是自动装箱和拆箱

int n2 = 200;
//自动装箱 int->Integer
Integer integer2 = n2; //底层使用的是 Integer.valueOf(n2)
//自动拆箱 Integer->int
int n3 = integer2; //底层仍然使用的是 intValue()方法

包装类型和 String 类型的相互转换

以 Integer 和 String 转换为例

//包装类(Integer)->String
Integer i = 100;//自动装箱
//方式 1
String str1 = i + "";
//方式 2
String str2 = i.toString();
//方式 3
String str3 = String.valueOf(i);
//String -> 包装类(Integer)
String str4 = "12345";
Integer i2 = Integer.parseInt(str4);//使用到自动装箱
Integer i3 = new Integer(str4);//构造器

Integer 类和 Character 类的常用方法

System.out.println(Integer.MIN_VALUE); //返回最小值
System.out.println(Integer.MAX_VALUE);//返回最大值
System.out.println(Character.isDigit('a'));//判断是不是数字
System.out.println(Character.isLetter('a'));//判断是不是字母
System.out.println(Character.isUpperCase('a'));//判断是不是大写
System.out.println(Character.isLowerCase('a'));//判断是不是小写
System.out.println(Character.isWhitespace('a'));//判断是不是空格
System.out.println(Character.toUpperCase('a'));//转成大写
System.out.println(Character.toLowerCase('A'));//转成小写

输出结果：

-2147483648
2147483647
false
true
false
true
false
A
a

Integer 类面试题

Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j); //False

因为是 new 出来的，==比较的是两个是否为同一个对象，故此题为错

Integer m = 1; //底层 Integer.valueOf(1); -> 阅读源码
Integer n = 1;//底层 Integer.valueOf(1);
System.out.println(m == n); // True

Integer x = 128;//底层 Integer.valueOf(1);
Integer y = 128;//底层 Integer.valueOf(1);
System.out.println(x == y);// False

关于上面两个结果，必须要阅读源码

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
    	return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

如果 i 在 IntegerCache.low(-128) ~ IntegerCache.high(127),就直接从数组返回

注意：IntegerCache.cache[]里存的值为 -128 ~ 127

如果不在 -128~127,就直接 new Integer()

//示例一
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2);//F
//示例二
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3 == i4);//F
//示例三
Integer i5 = 127;//底层 Integer.valueOf(127)
Integer i6 = 127;//-128~127
System.out.println(i5 == i6); //T
//示例四
Integer i7 = 128;
Integer i8 = 128;
System.out.println(i7 == i8);//F
//示例五
Integer i9 = 127; //Integer.valueOf(127)
Integer i10 = new Integer(127);
System.out.println(i9 == i10);//F，第 18 行是 cache 数组里的，19 行是 new 的，肯定不是同一个对象
//示例六
Integer i11=127;
int i12=127;
//只有有基本数据类型，判断的是值是否相同
System.out.println(i11==i12); //T
//示例七
Integer i13=128;
int i14=128;
System.out.println(i13==i14);//T

String🚩

String 类的介绍

image-20221127113854983

  1. String 对象用于保存字符串，也就是一组字符序列

  2. 字符串常量对象是用双引号括起的字符序列

  3. 字符串的字符使用 Unicode 字符编码，一个字符（不区分字母还是汉字）占两个字节

  4. String 类常用的构造器

    • String s1 = new String();

    • String s2 = new String(String original);

    • String s3 = new String(char[] a);

    • String s4 = new String(char[] a,int startIndex,int count)

    • String s5 = new String(byte[] b

    1. String 类实现了接口 Serializable【String 可以串行化：可以在网络传输】，接口 Comparable【String 对象可以比较大小】

    2. String 是 final 类，不能被其它类继承

    3. String 有属性 private final char value[];用于存放字符串内容(String 底层是用 char 数组实现的)

      千万注意：value 是一个 final 类型，不可以修改：即 value 不能指向新的地址，但是单个字符内容是可以变化的

      final char[] value = {'a','b','c'};
char[] v2 = {'t','o','m'};
value[0] = 'H';
//value = v2; 不可以修改 value 地址

创建 String 对象的两种方式

  1. 直接赋值：String s = “bestpig”
  2. 调用构造器 String s2 = new String(“bestpig”)

以上两种方式的区别：第一种是先从常量池中查看是否有 “bestpig” 数据空间，如果有，直接指向；如果没有，则重新创建，然后再指向。s 最终指向的是常量池的空间地址。第二种是先在堆中创建空间，里面维护了 value 属性，value 再指向常量池的 “bestpig” 空间。如果常量池中没有 “bestpig”，重新创建；如果有，直接通过 value 指向。

内存分布图：

image-20221127154526103

判断下面代码的对错

String a = "abc";
String b = "abc";
System.out.println(a.equals(b)); //T
System.out.println(a == b; //T

String a = new String("abc");
String b = new String("abc");
System.out.println(a.equals(b)); //T
System.out.println(a == b); //F
System.out.println(a == b.intern()); //T
System.out.println(b == b.intern()); //F

知识点：当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（用 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并返回此 String 对象的引用。即 b.intern() 方法最终返回的是常量池的地址（对象）。

String s1 = "bsetpig"; // 指向常量池 “bestpig”
String s2 = "java"; // 指向常量池 “java”
String s4 = "java"; // 指向常量池 "java"
String s3 = new String("java"); // 指向堆中对象
System.out.println(s2 == s3); //F
System.out.println(s2 == s4); //T
System.out.println(s2,equals(s3)); //T
System.out.println(s2 == s2);// F

Person p1 = new Person();
p1.name = "bestpig";
Person p2 = new Person();
p2.name = "bestpig";

System.out.println(p1.name.equals(p2.name)); // T
System.out.println(p1.name == p2.name);// T，二者都指向 "bestpig"
System.out.println(p1.name == "bestpig");// T

image-20221127163831554

字符串的特性

  1. String 是一个 final 类，代表不可变的字符序列
  2. 字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的。（就是说在常量池中创建了字符串 “bestpig”，创建了之后就不可以更改了）

问：以下语句创建了几个对象？画出内存布局图

String s1 = "bestpig";
s1 = "pig1";

创建了两个对象

image-20221127193809958

String a = "best" + "pig";

创建了几个对象？

千万注意：不要认为创建了 “best” 、“pig”、“bestpig” 三个对象

创建了一个对象，编译器不是傻子，会做一个优化，判断创建的常量池对象，是否有引用指向，上式中的 “best” 和 “pig” 都没有被引用。故上式等价于‘

String a = "bestpig";

String a = "best";
String b = "pig";
String c = a + b;

创建了几个对象？画出内存图。关键就是要分析 String c = a + b；是如何执行的

答：一共有 3 个对象

debug可知 String c = a + b;的执行过程是

// 1.
StringBuilder sb = new StringBuilder();
// 2.
sb.append("best");
// 3. 
sb.append("pig");
// 4.
sb.toString()

千万注意：第 4 步的 toString() 方法就是在堆中 new 了一个对象，所以内存图如下

image-20221127200411790

强烈建议：

String s = "best" + "pig";常量相加，看的是池

String s = a + b;变量相加，是在堆中

下列程序运行额结果是什么，尝试画出内存布局图

public class Test{
    String str = new String("pig");
    final char[] ch = {'j', 'a', 'v', 'a'};
    public void change(String str, char ch[]){
        str = "java";
        ch[0] = 'h';
    }
    public static void main(String[] args){
        Test ex = new Test();
        ex.change(ex.str, ex.ch);
        System.out.print(ex.str + "and");
        System.out.print(ex.ch);
    }
}

执行一个方法会创建一个栈，执行完之后会销毁

数组是放在堆里的

ex.str 是指向 value 的，所以 change 方法里的 str 也是指向 value

image-20221128175730242

执行结果：

pig and hava

String 常用方法

方法说明
equals区分大小写，判断内容是否相等
equalslgnoreCase忽略大小写的判断内容是否相等
length获取字符的个数，字符串长度
indexOf获取字符在字符串中第1次出现的索引，找不到返回 -1
lastInedxOf获取字符在字符串中最后1次出现的索引，
substring截取指定范围的字串
trim去前后空格
charAt获取某索引处的字符
toUpperCase
toLowerCase
concat
replace替换字符串中的字符
split分割字符串，对于某些分割字符，需要转义
compareTo
toCharArray转换成字符数组
format格式字符串，%s字符串、%c字符、%d整型

StringBuffer🚩

StringBuffer介绍

  • StringBuffer 代表可变的字符序列，可以对字符串内容进行增删

  • 很多方法与 String 相同，但 StringBuffer 是可变长度的

  • StringBuffer 是一个容器

  • StringBuffer 实现了 Serializable，即 StringBuffer 的对象可以串行化

  • StringBuffer 是一个 final 类，不能被继承

  • StringBuffer 的直接父类是 AbstractStringBuffer，在父类中 AbstractStringBuffer 有属性 char[] value，不是 final，该 value 数组存放字符串内容，是存放在堆中的

  • String 保存的是字符串常量，里面的值不能更改，每次 String 类的更新实际上就是更改地址，效率低。StringBuffer 保存的是字符串变量，里面的值可以更改（因为 char[] value 是放在堆中的）。

String 和 StringBuffer 相互转换

String 👉 StringBuffer

String str = "bestpig";
  1. 使用构造器
StringBuffer stringBuffer = new StringBuffer();
  1. 使用的是 append 方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str)

StringBuffer → String

StringBuffer stringBuffer3 = new StringBuffer("bestpig")
  1. 使用 StringBuffer 提供的 toString() 方法
String s = stringBuffer3.toString
  1. 使用构造器
String s1 = new String(stringBuffer3)

StringBuffer 常用方法

  • 增 append
  • 删 delete(start,end)
  • 改 replace(start,end,string)
  • 查 indexOf
  • 插 insert
  • 获取长度 length

StringBuilder🚩

基本介绍：

  • StringBuilder 继承 AbstractStringBuilder 类
  • 实现了 Serializable，说明 StringBuilder 对象是可以串行化（对象可以网络传输。可以保存到文件）
  • StringBuilder 是 final 类，不能被继承
  • StringBuilder 对象字符序列仍然是存放在其父类StringBuilder 的 char[] vlaue，因此字符序列是在堆中
  • StringBuilder 方法没有做互斥的处理，即没有 synchronized 关键字，因此在单线程的情况下使用 StringBuilder

String、StringBuffer、StringBuilder 比较

  • StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且方法也一样

  • String：不可变字符序列，效率低，但是复用率高

    image-20221130145703403

  • StringBuffer：可变字符序列，效率较高（增删），线程安全

  • StringBuilder：可变字符序列，效率最高，线程不安全

  • String 使用说明：

    String s = "a";
s += "b";

    执行 s += "b";时，实际上原来的 “a” 字符串对象已经丢弃了，现在又产生了一个字符串 s + “b”（也就是 “ab”）。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能。故如果我们对 String 做大量修改，不要使用 String

三者的选择：

  • 如果字符串存在大量的修改操作，一般使用 StringBuffer 或 StringBuilder
  • 如果字符串存在大量的修改操作，并在单线程的情况，使用 StringBuilder
  • 如果字符串存在大量的修改操作，并在多线程的情况，使用 StringBuffer
  • 如果字符串很少修改，被多个对象引用，使用 String，比如配置信息等

Math类

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数

abs绝对值
pow求幂
ceil向上取整
floor向下取整
sqrt求开方
random求随机数
max求两个数的最大值
min求两个数的最小值

Arrays类

Arrays 里包含了一系列静态方法，用于管理或操作数组（比如排序和搜索）

  1. toString 返回数组的字符串形式 Arrays.toString()

  2. sort 排序

  3. binarySearch 通过二分搜索法进行查找，要求必须排好序

    int index = Arrays.binarySearch(arr, 3);

  4. copyOf 数组元素的复制

    Integer[] newArr = Arrays.copyOf(arr, arr.length)

  5. fill 数组元素的填充

    Integer[] num = new Integer[]{9,3,2}

    Arrays.fill(num,99)

  6. equals 比较两个数组元素内容是否完全一致

    boolean equals = Arrays.equals(arr, arr2)

  7. asList 将一组值转换成 list

    List<Integer> asList = Arrays.asList(2,3,4,5,6)

System类

system 类常见方法

  1. exit 退出当前程序
  2. arraycopy：复制数组元素，比较适合底层调用，一般使用 Arrays.copyOf 完成数组赋值
  3. currentTimeMillens：返回当前时间距离1970-1-1的毫秒数
  4. gc：运行垃圾回收机制

BigInteger 和 BigDecimal类

应用场景：

  1. BigInteger 适合保存比较大的整型
  2. BigDecimal 适合保存精度更高的浮点型（小数）

BigInteger 和 BigDecimal 常用方法

  1. add 加
  2. subtract 减
  3. multiply 乘
  4. divide 除

日期类

第一代日期类

  1. Date：精确到毫秒，代表特定的时间

    Date d1 = new Date();
System.out.println(d1);

    输出的格式为

    Thu Dec 08 18:40:15 CST 2022

  2. SimpleDateFormat ：格式和解析日期的类，SimpleDateFormat 格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy 年 MM 月 dd 日 hh:mm:ss E");
String format = sdf.format(d1); // format:将日期转换成指定格式的字符串
System.out.println("当前日期=" + format);

    当前日期=2022 年 12 月 08 日 06:42:56 周四

    把一个格式化的 String 转成对应的 Date

    String s = "1996 年 01 月 01 日 10:20:30 星期一";
Date parse = sdf.parse(s);
System.out.println("parse=" + sdf.format(parse));

    parse=1996 年 01 月 01 日 10:20:30 周一

第二代日期类

第二代日期类主要就是 Calendar

Calendar 是一个抽象类，并且构造器是 private，可以通过 getInstance()类获取

Calendar c = Calendar.getInstance(); //创建日历类对象//比较简单，自由
System.out.println("c=" + c);
//2.获取日历对象的某个日历字段
System.out.println("年：" + c.get(Calendar.YEAR));
// 这里为什么要 + 1, 因为 Calendar 返回月时候，是按照 0 开始编号
System.out.println("月：" + (c.get(Calendar.MONTH) + 1));
System.out.println("日：" + c.get(Calendar.DAY_OF_MONTH));
System.out.println("小时：" + c.get(Calendar.HOUR));
System.out.println("分钟：" + c.get(Calendar.MINUTE));
System.out.println("秒：" + c.get(Calendar.SECOND));
//Calender 没有专门的格式化方法，所以需要程序员自己来组合显示
System.out.println(c.get(Calendar.YEAR) + "-" + (c.get(Calendar.MONTH) + 1) + "-" +
c.get(Calendar.DAY_OF_MONTH) +
" " + c.get(Calendar.HOUR_OF_DAY) + ":" + c.get(Calendar.MINUTE) + ":" + c.get(Calendar.SECOND) );

如果我们需要按照 24 小时进制来获取时间， Calendar.HOUR ==改成=> Calendar.HOUR_OF_DAY

第三代日期类🚩

LocalDate（日期/年月日）

LocalTime（时间/时分秒）

LocalDateTime（日期时间/年月日时分秒）

DateTimeFormatter 格式日期类

//1. 使用 now() 返回表示当前日期时间的 对象
LocalDateTime ldt = LocalDateTime.now(); //LocalDate.now();//LocalTime.now()
System.out.println(ldt);
//2. 使用 DateTimeFormatter 对象来进行格式化
// 创建 DateTimeFormatter 对象
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String format = dateTimeFormatter.format(ldt);
System.out.println("格式化的日期=" + format);
System.out.println("年=" + ldt.getYear());
System.out.println("月=" + ldt.getMonth());
System.out.println("月=" + ldt.getMonthValue());
System.out.println("日=" + ldt.getDayOfMonth());
System.out.println("时=" + ldt.getHour());
System.out.println("分=" + ldt.getMinute());
System.out.println("秒=" + ldt.getSecond());

时间戳

类似于 Date

//1.通过 静态方法 now() 获取表示当前时间戳的对象
Instant now = Instant.now();
System.out.println(now);
//2. 通过 from 可以把 Instant 转成 Date
Date date = Date.from(now);
//3. 通过 date 的 toInstant() 可以把 date 转成 Instant 对象
Instant instant = date.toInstant()

第三代日期类更多方法

  • 是否为闰年
  • 增加日期的某个部分
  • 使用 plus 方法测试增加时间的某个部分
  • 使用 minus 方法测试查看一年前和一年后的日期
bestpig@1314
关注
专栏目录
Java 常用类Date
chen2745213271的博客
05-18 4515
这次介绍Java中常用类中的一种Date，一般常用的Date的包名为util即java.util.Date。还有一种Date类的包名为spl即java.spl.Date，这次不做介绍。 包名为spl的Date类作用于和spl数据库打交道，其内容只包括日期，没有时间，包名为util的Date类作用于平常日期使用其内容包括日期和时间，且大部分的构造器和方法已经过时了，下面介绍的是平时还可以使用的方法和构造器。 1、Date()构造器 定位到现在的时间 ...
Java常用类方法总结
一个真ikun
09-06 1299
本篇总结Java常用类中的各种方法，适合快速入门和复习。
java常用类之Calendar类
Walker_sis的博客
02-22 9144
java常用类之Calendar类 Calendar类提供了获取或者设置各种日历的字段的方法。 构造方法 protected Calendar():由于修饰符是prodected;所以无法直接创建该对象 其他方法 方法名 说明 static Calendar getInstance() 使用默认时区或区域获取日历 void set(int year,int month,int date,int hourofday,int minute,int second) 设置日历的时分秒
java常用类及常用方法总结
qq_48917054的博客
05-27 3189
java中一些常用的类及常用类方法的汇总
Java常用类（详细）总结
m0_64799972的博客
06-20 6460
目录一、String类二、BigDecimal类三、Date 类四、Calendar 类五、SimpleDateFormat 类六、Math类七、Random类八、System类 1.String创建方式。 2.String 常用的方法。 3.String案例 4.StringBuffer与StringBuilder 5.StringBuffer与StringBuilder跟String类的对比
头歌上有关java作业：java常用类
热门推荐
weixin_62075168的博客
11-09 1万+
有关头歌上针对初学java的作业，java常用类。
java常用类实验报告总结_【Java基础】java常用类实验总结
weixin_36328527的博客
02-25 3707
1、ObjectObject类是所有类的父类，也就是说任何一个类在定义时如果没有明确地继承一个父类，那它就是Object类的子类2、String表示的是字符串，字符串是常量(值定义了之后，不可修改)字符串可以看出是多个字符的连接3、StringBuilder类线程不安全的可变字符序列4、Scanner1)构造方法Scanner(InputStream is)构造一个文本扫描器，它生成的值是从指定的...
java常用类
2301_77221290的博客
05-07 1546
常用类
学习-Java常用类之Calendar类
没事发发博客
04-30 2141
第1关：学习-Java常用类之Calendar类 任务描述 本关任务：获取给定年月的最后一天。 相关知识 我们通过之前的学习已经能够格式化并创建一个日期对象了，但是我们如何才能设置和获取日期数据的特定部分呢，比如说小时，日，或者分钟? 我们又如何在日期的这些部分加上或者减去值呢? calendar类是一个抽象类，是 Java 日期处理的核心类之一。Calendar 类为操作日历字段，及其与特定瞬间之间的转换提供了方法。日历字段包含 YEAR、MONTH、DAY_OF_MONTH、HOUR 等，它.
【Java常用类】DateTimeFormatter
Ekertree的博客
08-12 3376
DateTimeFormatter 方式一：预定义的标准格式 实例化 如：ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME; 格式化:日期–>字符串 LocalDateTime localDateTime = LocalDateTime.now(); String str1 = formatter.f
实验5 JAVA常用类.doc
05-02
实验5的Java常用类主要涵盖了Java编程中的一些核心概念和常用工具类的使用。以下是这些知识点的详细说明： 1. **String、StringBuffer(StringBuilder)**： - **String** 类在Java中是不可变的，这意味着一旦创建了...
JAVA常用类总结
12-22
JAVA常用类,java封装类,String类和StringBuffer类......
Java常用类总结
03-16
总的来说，熟练掌握这些Java常用类对于提升编程效率和编写高质量代码至关重要。它们涵盖了数据存储、输入输出、并发控制、日期时间处理等多个方面，是Java程序员的基础技能。了解并精通这些类的使用，能帮助开发者更...
JAVA常用类与内部类
12-22
什么是内部类？ 在类中定义的类，称之为内部类。 Java中有几种内部类？ 1、成员内部类：定义在类中的类，...Object类是所有类的父类（超类，根类，基类），Java中所有类都是Object类的子类 Object类中所定义的方法是所
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 223
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 282
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
2024.10月12日--- SpringMVC异常处理
whisper_Java 的博客
10-12 906
*** 用户【】 IP[]* 在【时间】* 操作【Controller.find】 发生如下异常*/@OverrideSystem.out.println("---------执行了自定义异常处理器------------");// 根据不同的异常类型，设置不同的响应状态码// 可以添加更多的自定义处理逻辑//}else {// 记录日志或其他处理逻辑// 可以将异常信息放入模型中供视图展示。
Backend - Java 基础
是萝卜干呀的博客
10-11 833
知识量决定了未来能走多远
Java常用类详解：封装类与String类对比
“Java常用类总结涵盖了Java语言中常见的类和方法，包括基本类型的封装类、String类和StringBuffer类的使用，以及这些类的一些核心方法。” 在Java编程中，了解和熟练使用常用类是非常重要的。以下是对标题和描述中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值