笔记_from_Java编程思想（第十三章 字符串）

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量157 收藏
点赞数
分类专栏： Thinking_in_Java 文章标签： java 正则表达式 string 字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/keepkind/article/details/118613014
版权

不可变String

String对象是不可变的。查看JDK文档发现，String类中每一个看似会修改String值的方法实际上是创建了一个全新的String对象，以包含修改后的字符串内容，而最初的String对象则丝毫未动（对于一个方法而言，参数就是为该方法提供信息的，而不是让该方法改变自己）。

重载“+”与StringBuilder

String对象是不可变的，你可以给String对象加任意多的别名。因为String对象具有只读特性，所以指向它的任何引用都不可能改变它的值，因此，也就不会对其他的引用有什么影响。
不可变型会带来一定的效率问题。为String对象重载“+”操作符就是一个例子，用于String的“+”和“+=”是Java中仅有的两个重载过的操作符，而Java不允许程序员重载任何操作符。
编译器自动引入了java.lang.String.StringBuilder类，虽然我们在源代码中并没有使用StringBuilder类，但是编译器却自作主张地使用了它，因为它更高效。
显示地创建StringBuilder还允许你预先为其指定大小，如果已知最终地字符串大概有多长，那预先指定StringBuilder的大小可以避免多次重新分配缓冲。
因此，当为一个类编写toString()方法时，如果字符串比较简单，那就可以信赖编译器，它会合理地构造最终的字符串结果。但是，如果要在toString()方法中使用循环，那么最好创建一个StringBuilder对象，用它来构造最终结果

import java.util.Random;
public class test
{
    public static Random rand= new Random(100);
    public String toString()
    {
        StringBuilder result =new StringBuilder("[");
        for(int i=0;i<5;i++)
        {
            result.append(rand.nextInt(100));
            result.append(". ");
        }
        result.delete(result.length()-2,result.length());
        result.append("]");
        return result.toString();
    }
    public static void main(String[] args) {
        test useStringBuilder= new test();
        System.out.println(useStringBuilder);
    }
}
/*
输出：
[15. 50. 74. 88. 91]
*/

StringBuilder提供了丰富而全面的方法，包括insert()、replace()、substring()甚至reverse()，但是最常用的还是append()和toString()。还有delete()方法，上面的例子中我们用它删除了最后一个句号和空格，以便添加右括号。
StringBuilder是JavaSE5引入的，在这之前Java用StringBuffer。后者是线程安全，因此开销也会大些，因此在JavaSE5/6中，字符串操作应该还会更快些。

无意识的递归调用

Java中的每个类从根本上都是继承自Object，标准容器类自然也不例外。因此容器类都有toString()方法，并且覆盖了该方法，使得它生成的String结果能够表达容器自身，以及容器所包含的对象。例如ArrayList.toString()，它会遍历ArrayList中包含的所有对象，调用每个元素上的toString()方法：

import java.util.ArrayList;
import java.util.Random;
public class test
{
    public static void main(String[] args) {
        ArrayList<Integer> Num=new ArrayList<Integer>();
        Random rand= new Random(100);
        for(int i=0;i<10;i++)
            Num.add(rand.nextInt(100));
        System.out.print(Num.toString());
    }
}
/*
输出：
[15, 50, 74, 88, 91, 66, 36, 88, 23, 13]
*/

public class test
{
    /*以下注释的toString()部分打印时，会得到一串非常长的异常（几千行）
    如果要获取对象的内存地址应该调用Object.toString()方法，
    因此不是this，而是super.toString()*/
    /*
    public String toString()
    {
        return "test's address:"+this;
    }
    */
    public String toString()
    {
        return "test's address:"+super.toString();
    }
    public static void main(String[] args) {
        test temp=new test();
        System.out.print(temp.toString());
    }
}
/*
输出：
test's address:test@8efb846
*/

String上的操作

在这里插入图片描述
从表中也可以看出，当需要改变字符串内容时，String类的方法都会返回一个新的String对象。同时，如果内容没有改变，String的方法只是返回原对象的引用而已。这可以节约存储空间以及避免额外的开销。

格式化输出

JavaSE5推出了C语言中printf()风格的格式化输出，用特殊的占位符表示数据将来的位置，这些占位符称作格式修饰符，它们不但说明了插入数据的位置，同时还说明了将插入什么类型的变量，以及如何对其格式化

public class test
{
    public static void main(String[] args) {
        int x=5;
        double y=5.123456;
        //普通的输出
        System.out.println("Row 1:["+x+" "+y+"]");
        //新方法
        System.out.format( "Row 1:[%d %f]\n", x,y);
        System.out.printf("Row 1:[%d %f]\n", x,y);  //C语言怀旧版，与上面那种是等价的
    }
}
/*
//输出：
Row 1:[5 5.123456]
Row 1:[5 5.123456]
Row 1:[5 5.123456]
*/

Formatter类

在Java中，所有新的格式化功能都是由java.util.Formatter类处理。当创建一个Formatter对象时，需要向其构造器传递一些信息，告诉它最终结果将向哪里输出

import java.io.PrintStream;
import java.text.Normalizer.Form;
import java.util.Formatter;
public class test
{
    private String name;
    private Formatter f;
    public test(String name,Formatter f)
    {
        this.name=name; this.f=f;
    }
    public void move(int x,int y)
    {
        f.format("%s The Turtle is at (%d,%d)\n",name,x,y);
    }
    public static void main(String[] args) {
        PrintStream out=System.out;
        test Tom= new test("Tom",new Formatter(System.out));
        test Jerry= new test("Jerry",new Formatter(out));
        Tom.move(0,0);
        Jerry.move(4,8);
        Tom.move(3,4);
        Jerry.move(2,5);
    }
}
/*
输出：
Tom The Turtle is at (0,0)
Jerry The Turtle is at (4,8)
Tom The Turtle is at (3,4)
Jerry The Turtle is at (2,5)
*/

所有的Tom都将输出到System.out，而所有的Jerry则都输出到System.out的一个别名中。Formatter的构造器经过重载可以接受多种输出目的地，不过最常用的还是PrintStream()、OutPutStream和File。

格式化说明符

在插入数据时，如果想要控制空格与对齐，需要更精细复杂的格式修饰符。
最常见的应用是控制一个域的最小尺寸，这可以通过指定的width来实现。Formatter对象通过在必要时添加空格，来确保一个域至少达到某个长度。默认情况下，数据右对齐，可通过使用“-”来改变对其方式。
与width相对的是precision，它用来指明最大尺寸。Width可以应用与各种类型的数据转换，并且行为方式都一样。Precision则不然，precision用于String时，表示最大输出字符数量，用于浮点数时表示小数部分显示的位数（默认为6位），太少则尾部补0。用于整数则触发异常。
在这里插入图片描述

正则表达式

基础：在正则表达式中，用\d表示一位数字。Java中对反斜杠有不同处理。在其它语言中，\表示“我想要在正则表达式中插入一个普通的反斜杠”。而在Java中，\意为“我要插入一个正则表达式的反斜杠，所以其后的字符具有特殊意义”。例如：-?\d+ 表示“可能有一个负号，后面跟着一位或多位数字（+表示）”

public class test
{
    public static void main(String[] args) {
        System.out.println("-1234".matches("-?\\d+"));
        System.out.println("5678".matches("-?\\d+"));
        System.out.println("+911".matches("-?\\d+"));
        System.out.println("+911".matches("(-|\\+)?\\d+"));
    }
}
/*
输出：
true
true
false
true
*/

在正则表达式中，括号有着将表达式分组的效果，而竖直线|则表示或操作。(-|\+)? 表示起始字符可能是一个-或+或二者都没有（因为后面跟着?修饰符）。因为字符+在正则表达式中有特殊意义，所以必须使用\将其转义，使之成为表达式中的一个普通字符。
String自带split()方法，功能：将字符串从正则表达式匹配的地方切开。

import java.util.Arrays;

public class test
{
    public static String knights="Then, when you have found "+
    "the shrubby, you must cut down the mightiest tree in "+
    "the forest... with...a herring!"; 
    public static void split(String regex)
    {
        System.out.println(Arrays.toString(knights.split(regex)));
    }
    public static void main(String[] args) {
        split(" "); //只按空格划分字符串
        split("\\W+");  //非单词字符，将标点字符删除
        split("n\\W+"); //字母n后面跟着一个或多个非单词字符
    }
}
/*
输出：
[Then,, when, you, have, found, the, shrubby,, you, must, cut, down, the, mightiest, tree, in, the, forest..., with...a, herring!]
[Then, when, you, have, found, the, shrubby, you, must, cut, down, the, mightiest, tree, in, the, forest, with, a, herring]
[The, whe, you have found the shrubby, you must cut dow, the mightiest tree i, the forest... with...a herring!]
*/

String.split()还有一个重载版本，允许限制字符串分割次数。
String自带最后一个正则表达式工具是“替换”。可以只替换第一个匹配到的或所有匹配的。

public class test
{
    public static String knights="Then, when you have found "+
    "the shrubby, you must cut down the mightiest tree in "+
    "the forest... with...a herring!"; 
    public static void main(String[] args) {
        //以字母f开头，后面跟一个或多个字母，且只替换第一个匹配部分
        System.out.println(knights.replaceFirst("f\\w+", "located")); 
        //匹配三个单词中的任意一个，以竖线分隔表示“或”，并且替换所有匹配部分
        System.out.println(knights.replaceAll("shrubby|tree|herring", "banana"));
    }
}
/*
输出：
Then, when you have located the shrubby, you must cut down the mightiest tree in the forest... with...a herring!
Then, when you have found the banana, you must cut down the mightiest banana in the forest... with...a banana!
*/

在这里插入图片描述

量词

1、 贪婪型：量词总是贪婪的，除非有其他的选项被设置。贪婪表达式会为所有可能的模式发现尽可能多的匹配。
2、 勉强型：用问号指定，这个量词匹配满足模式所需的最少字符数。因此也叫懒惰的，最少匹配的，非贪婪的，不贪婪的。
3、 占有型：目前只有Java中才可用。当正则表达式被应用于字符串时，它会产生相当多的状态，以便在匹配失败时可以回溯。而“占有的”量词并不保存这些中间状态，因此可以防止回溯。它们常常用于防止正则表达式失控，因此可以使正则表达式执行起来更有效。
在这里插入图片描述

Pattern和Matcher

构造功能强大的正则表达式对象只需导入java.util.regex，然后用static Pattern.compile()来编译所需正则表达式。

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class test
{
    public static void main(String[] args) {
        Matcher m= Pattern.compile("\\w+").matcher("Evening is full of the linnet's wings");
        while(m.find()) System.out.print(m.group()+" ");
        System.out.println();
        int i=0;
        //以一个整数为参数，该整数表示字符串中字符的位置，并以其为搜索起点
        while(m.find(i))
        {
            System.out.print(m.group()+" ");    i++;
        }
    }
}
/*
输出：
Evening is full of the linnet s wings 
Evening vening ening ning ing ng g is is s full full ull ll l of of f the the he e linnet linnet innet nnet net et t s s wings wings ings ngs gs s 
*/

组：组是用括号划分的正则表达式，可以根据组的编号来引用某个组。组好为0表示整个表达式，组好1表示被第一对括号括起的组，以此类推。因此：A(B©)D中有三组：组0：ABCD，组1BC，组2是C。
Matcher对象提供了一系列方法：

  1. public int groupCount() 返回该匹配器的模式中分组数目，第0组不包括。
  2. public String group(int i) 返回前一次匹配操作期间指定的组号，如果匹配成功，但是指定的组没有匹配输入自符串的任何部分，则将返回null。
  3. public int start(int group) 返回前一次匹配操作中寻找到的组的起始索引。
  4. public int end(int group) 返回前一次匹配操作中寻找到的组的最后一个字符索引加1的值。
    在这里插入图片描述
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class test
{
    public static void main(String[] args) {
        //可以通过“或”(|)操作符组合多个标记的功能
        Pattern p= Pattern.compile("^java",Pattern.CASE_INSENSITIVE|Pattern.MULTILINE);
        Matcher m= p.matcher("java has regex\nJava has regex\n"+
        "JAVA has pretty good regular expression;\n"+
        "Regular expressions are in Java");
        while(m.find()) System.out.println(m.group());
    }
}
/*
输出：
java
Java
JAVA
*/

注意：group()方法只返回已匹配部分

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class test
{
    public static void main(String[] args) {
        Matcher m= Pattern.compile("[frb][aiu][gx]").matcher("fix the rug with bags");
        while(m.find()) System.out.print(m.group()+" ");
        System.out.println();
        m.reset("fix the rig with rags");
        while(m.find()) System.out.print(m.group()+" ");
    }
}
/*
输出：
fix rug bag 
fix rig rag
*/

扫描输入

import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class test
{
    /*StringReader将String转化为可读对象，然后用这个对象构造BufferReader对象
    因为我们需要使用BufferReader的nextLine()方法。最终，我们可以使用input对象一次读取一行文本，
    就像是从控制台读入标准输入一样。
    */
    public static BufferedReader input=new BufferedReader(
        new StringReader("Sir Robin of Camelot\n22 1.61830")
    );
    public static void main(String[] args) {
       try
       {
            System.out.println("What is your name?");
            String name= input.readLine();
            System.out.println("How old are you? What is your favorite double?");
            System.out.println("(input:<age> <double>)");
            String numbers=input.readLine();
            System.out.println(numbers);
            String[] numArray= numbers.split(" ");
            int age= Integer.parseInt(numArray[0]);
            double favorite=Double.parseDouble(numArray[1]);
            System.out.format("Hi %s.\n",name);
            System.out.format("In 5 years you will be %d.\n",age+5);
            System.out.format("My favorite double is %f.",favorite/2);
       }
       catch(IOException e){ System.out.println("I/O exception");}
    }
}
/*
输出：
What is your name?
How old are you? What is your favorite double?
(input:<age> <double>)
22 1.61830
Hi Sir Robin of Camelot.
In 5 years you will be 27.
My favorite double is 0.809150.
*/

如果两个输入值在同一行，事情就变得棘手了，我们需要分解此行，在这里使用numArray分解。JavaSE5后，可以使用Scanner类：

import java.io.BufferedReader;
import java.io.StringReader;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class test
{
    /*StringReader将String转化为可读对象，然后用这个对象构造BufferReader对象
    因为我们需要使用BufferReader的nextLine()方法。最终，我们可以使用input对象一次读取一行文本，
    就像是从控制台读入标准输入一样。
    */
    public static BufferedReader input=new BufferedReader(
        new StringReader("Sir Robin of Camelot\n22 1.61830")
    );
    public static void main(String[] args) {
        Scanner stdin =new Scanner(input);
        System.out.println("What is your name?");
        String name= stdin.nextLine();
        System.out.println(name);
        System.out.println("How old are you? What is your favorite double?");
        System.out.println("(input:<age> <double>)");
        int age=stdin.nextInt();
        double favorite=stdin.nextDouble();
        System.out.println(age);
        System.out.println(favorite);
        System.out.format("Hi %s.\n",name);
        System.out.format("In 5 years you will be %d.\n",age+5);
        System.out.format("My favorite double is %f.",favorite/2);
       stdin.close();
    }
}
/*
输出：
What is your name?
Sir Robin of Camelot
How old are you? What is your favorite double?
(input:<age> <double>)
22
1.6183
Hi Sir Robin of Camelot.
In 5 years you will be 27.
My favorite double is 0.809150.
*/

Scanner会在输出结束时会抛出IOException，所以Scanner会把IOException吞掉。不过通过ioException()方法可以找到最近的异常。
Scanner定界符
Scanner根据空白字符对输入进行分词，但是可以根据正则表达式指点自己所需定界符：

import java.util.Scanner;

public class test
{
    public static void main(String[] args) {
        Scanner scanner= new Scanner("12,42,78,99,42");
        scanner.useDelimiter("\\s*,\\s*");
        while(scanner.hasNextInt()) System.out.println(scanner.nextInt());
        scanner.close();
    }
}
/*
输出：
12
42
78
99
42
*/

这里使用了逗号作为分隔符（包括逗号前后任意的空白字符）。
除了能够扫描基本类型外，还可以自定义正则表达式进行扫描。下面的例子为防火墙日志文件中记录的威胁数据。

import java.util.Scanner;
import java.util.regex.MatchResult;

public class test
{
    static String threatData=
    "12.23.34.45@01/01/2001\n"+
    "23.34.45.56@02/01/2002\n"+
    "34.45.56.67@03/02/2003\n"+
    "45.56.67.78@04/04/2003\n"+
    "56.67.78.789@12/12/2009\n"+
    "[Next log section with different data format]";
    public static void main(String[] args) {
        Scanner scanner=new Scanner(threatData);
        String pattern="(\\d+[.]\\d+[.]\\d+[.]\\d+)@"+
        "(\\d{2}/\\d{2}/\\d{4})";
        while(scanner.hasNext(pattern))
        {
            scanner.next(pattern);
            MatchResult match=scanner.match();
            String ip= match.group(1);
            String data=match.group(2);
            System.out.printf("Threat on %s from %s\n",data,ip);
        }
        scanner.close();
    }
}
/*
输出：
Threat on 01/01/2001 from 12.23.34.45
Threat on 02/01/2002 from 23.34.45.56
Threat on 03/02/2003 from 34.45.56.67
Threat on 04/04/2003 from 45.56.67.78
Threat on 12/12/2009 from 56.67.78.789
*/

StringTokenizer

在Java引入正则表达式（J2SE1.4）和Scanner类（Java SE5）之前，分割字符串的唯一办法是使用StringTokenizer来分词。现在基本上StringTokenizer已废弃不用了。

[1] Bruce Eckel.Java编程思想[M].陈昊鹏,北京:机械工业出版社出版社.2007

20230716
关注
专栏目录
javaWeb学习第二天-------from表单和css
有些路是要自己走的
12-07 602
这里写自定义目录标题javaWeb学习第二天form 表单：input标签：文本域:CSS样式：css之块状与行状元素相互转换练习： javaWeb学习第二天 今天的知识点： HTML：form表单和和属性，table标签布局常用属性，div，input标签和其属性，select标签，textarea标签和其属性 CSS：css引入方式，css选择器，常规使用的css样式，css盒子模型，行内元素...
《Java编程思想》读书笔记
lt_xiaodou的博客
09-06 542
除了@符号以外，@Test的定义很像一个空的接口。定义注解时，会需要一些元注解（meta-annotation），如@Target和@Retention。@Target用来定义你的注解将应用于什么地方（例如是一个方法或者一个域）。@Rectetion用来定义该注解在哪一个级别可用，在源代码中（SOURCE）、类文件中（CLASS）或者运行时（RUNTIME）。没有元素的注解称为标记注解，例如上例种的@Test。
Java 互联网工程师要具备哪些技能或技术？
11-08 1175
Java技术的世界是个无底洞，永远也学不完，不废话了，我就简单的说一下自己的看法（偏重Java方面，什么html、css、js这些不在这次的讨论之内，虽然JavaServer开发有时候也都需要懂点）： 1.Core Java，就是Java基础、JDK的类库，很多童鞋都会说，JDK我懂，但是懂还不足够，知其然还要知其所以然，JDK的源代码写的非常好，要经常查看，对使用频繁的类，比如String
JAVA编程思想学习总结：第十三章字符串
kkk6285137的专栏
05-31 481
（1）String,StringBuilder,StringBuffer （2）Formatter类 （3）正则表达式 （4）Scanner类
Java编程思想 第十三章 字符串
name_sakura的博客
03-18 739
文章目录
Java编程思想第四版读书笔记——第十三章 字符串
severusyue的博客
06-30 2002
Java编程思想第四版读书笔记——第十三章 字符串 1、不可变String 2、重载“+”与StringBuilder 3、无意识的递归 4、String上的操作 5、格式化的输出 printf() System.out.format() Formatter类 格式化说明符 Formatter转换
Java编程思想重点笔记（Java开发必看）
程序媛想事儿
12-09 2万+
Java学习必读经典，不管是初学者还是大牛都值得一读，这里总结书中的重点知识，这些知识不仅经常出现在各大知名公司的笔试面试过程中，而且在大型项目开发中也是常用的知识，既有简单的概念理解题（比如is-a关系和has-a关系的区别），也有深入的涉及RTTI和JVM底层反编译知识。
B站---【狂神说Java】JavaWeb入门到实战---笔记
热门推荐
bell_love的博客
04-23 18万+
JavaWebJava Web 1、基本概念web开发： ·web，网页的意思，www.baidu.com· 静态web 。html,sss 。提供给所有人看的数据始终不会发生变化！ 动态web 。淘宝，几乎是所有的网站； 。提供给所有人看的数据始终会发生变化，每个人在不同的时间，不同的地点看到的信息各不相同！ 。技术栈：Servlet/ISP，ASP，PHP ...
Java初级笔记-第三章
aidrv.com
04-04 669
第三章 程序设计基础 3.1 流程图 3.1.1 什么是流程图： 流程图是通过箭头（流程线）相互连接的几何图形来表达程序运行的方法。 流程图是算法的一种图形化描述，比较直观的表达了一件事务的处理过程。相对于代码来讲容易理解。 3.1.2 流程图的组成：画流程图的方法是：从左到右、从上到下。根据问题的需要，确定解决问题的先后处理顺序以及前提条件，将流程线将各图形符号连接起来，直观的表达自己的
Java核心技术· 卷二（11版）笔记（第1-4章）
weixin_43647460的博客
11-10 271
Java8 中的流库是一个新的API，它提供了一种简便的方式来对数据进行操作和处理。它包括了一些基础的接口和类，可以用来处理集合，数组等数据结构。下面是 Java8 中的流库的一些主要接口和类：Stream：流的主要接口，提供了一些常用的方法，如 filter、map、reduce 等，用于对数据进行操作。Optional：可选值类型，用于处理缺失的值，防止出现 NullPointerException。Collector：收集器，用于将流中的元素收集到指定的集合中，也可以用于分组、分区等操作。Splite
From_Java_Tutorials
KeepSlience的博客
05-19 169
Using Underscore Characters in Numeric Literals char —-> ‘\u0000’ Copying Arrays public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length
笔记 ：java性能优化 (from-JAVA程序性能优化)
yd137730268的专栏
02-26 581
1. java性能调优概述 1.1 性能概述  程序性能： 执行速度，内存分配，启动时间， 负载承受能力。 性能指标： 执行时间，CPU时间，内存分配，磁盘吞吐量，网络吞吐量，响应时间。  优化策略： 木桶原理，优化性能瓶颈。 1.2 性能调优的层次 设计调优， 代码调优， JVM调优， 数据库调优， 操作系统调优。 2. 设计优化 2.1 善用设计模式　 单例模式：
Java基础from《Java从入门到精通》第六版第八章学习总结
qq_51553982的博客
07-28 378
包和内部类 Java类包 在Java中定义好的每一个类通过编译器编译后会生成一个.class的文件，当程序规模大时很有可能会出现类名称冲突的情况（即：项目中有两个同名为Project_for_Java的类），Java提供了一个管理类文件的机制：类包 1.类名冲突 当程序规模大时出现相同类名的情况 2.完整的类路径 完整的类名：包名+类名 3.创建包 演示（IDEA）： 包的命名为全小写英文半角字母 4.导包 使用import关键字导包 语法： import 包名.* //表示导入包中所有的类 imp
《From Java To Kotlin》-Kotlin与Java的简单对比
Jason_Lee155的博客
02-06 290
前言： 原文来自https://github.com/MindorksOpenSource/from-java-to-kotlin 本文也只是简单比较kotlin与java的不同之处，实际学习kotlin还是去官网学习比较好。我个人学习的一个网站贴出来：Kotlin中文网 打印日志 Java System.out.print("Amit Shekhar"); System.out.println("Amit Shekhar"); Kotlin print("Amit Shek
Java中Http接受from提交方式
weixin_34122604的博客
03-06 1120
2019独角兽企业重金招聘Python工程师标准>>> ...
JAVA学习笔记（一）（from菜鸟教程）
weixin_42680686的博客
03-19 840
编写Java程序时，应注意以下几点： 大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如MyFirstJavaClass 。 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。 源文件名：源文件名必...
Java基础from《Java从入门到精通》第六版第六章学习总结
qq_51553982的博客
07-18 901
类与对象 面向对象概述 面向对象是把所有预处理的问题抽象为对象，通过了解这些对象具有的相应属性以及展示这些对象的行为，来解决这些对象面临的一些实际问题。 其实际上是对现实世界中的对象进行建模操作 1.对象 现实生活中可以说一切皆对象，通常我们把对象划分为两个部分，静态部分和动态部分。 静态部分 <=> 属性 动态部分 <=> 对象可执行的动作行为 计算机的世界中面向对象程序设计的思想要以对象来思考问题，把现实世界的实体抽象为对象，考虑这个对象具备的属性和行为。 步骤： 1.识别对
Java面试笔试-003-public static void main(String[] args)
qq_33605778的博客
04-23 5387
描述1）publicpublic是权限修饰符，表明任何类或对象都可以访问这个方法。2）staticstatic表明main()方法是一个静态方法，即方法中的代码是存储在静态存储区的，只要类被加载后，就可以使用该方法而不需要通过实例化对象来访问，可以直接通过类名.main()直接访问，JVM在启动时就是按照上述方法的签名（必须有public与static修饰，返回值为void,且方法的参数为字符中数组
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 541
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
Java编程：CCF相关字符串与日期操作笔记
"这篇笔记主要涉及Java编程语言中与字符操作、数值转换、字符串处理、日期和时间相关的知识点。" 在Java中，`charAt(int index)` 方法是用于获取字符串中指定下标`index`位置的字符。这个方法是`String`类的一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值