Java 面向对象（八）

最新推荐文章于 2024-09-16 20:08:29 发布
最新推荐文章于 2024-09-16 20:08:29 发布
阅读量83 收藏
点赞数
文章标签： java 人工智能
原文链接：http://www.cnblogs.com/xzh0717/p/11239511.html
版权

常用类之String

String字符串类

什么是字符串？就是把多个字符，串连一起。

String字符串的本质

其实是一个char[]数组

/**该值用于字符存储。*/
private final char value [];

1472533-20190724172352569-916609366.png

String字符串分类

（1）不可变字符串：String ：定义好之后，就不能再去改变了（内存地址不可变，一旦修改了，就会创建一个新的内存地址）

（2）可变字符串：StringBuilder/StringBuffer ：定义好之后，还可以进行修改， 改变时，不会创建新的内存地址。

String, StringBuffer, StringBuilder 都实现了 CharSequence 接口。

String字符串创建

（1）直接赋值：String str = "myxq";

（2）通过构造器来创建：String str2 = new String("myxq");

两种创建的区别

方法区当中有一个常量池，存放常量。

（1）String str = "ABCD";

  • 这种创建字符串方式，要么创建一个对象，要么不创建。

  • 创建时会先到常量池当中看一下有没有存在该字符串常量。

  • 如果已经有了，就直接使用，不会创建新的地址。（不创建对象）

  • 如果常量池当中没有的话，就会在常量没当中创建一个对象。

（2）String str2 = new String("ABCD");

  • 这种创建字符串方式，至少得要创建一个对象（因为使用了new，至少要在堆当中创建一个对象）

  • 看一下，常量池当中，有没有传入的字符串常量。

  • 如果没有，会创建一个字符串常量，放到常量池当中。

1472533-20190724172346094-160220730.png

String字符串对象值为空

（1）表示引用为空：String str = null; 还没有初始化，没有分配内存空间。（地址为空）

（2）表示空字符串：String str = ""; 已经创建了对象，已经分配了内存。（内容为空）

String字符串判等（判断是否相等）

比较两个字符串相不相等。

（1） == ：比较两个内存地址是否相等。

（2）使用equals ：它是object的方法。在object中和 == 相同，都是比较两个内存地址是否相等。

public boolean equals(Object obj) {
    return (this == obj);
}

建议子类，自己去覆盖此方法，自己在内部当中去根据自己的需求来去判断两个值是否相等。

String 已经覆盖了 equals：

public boolean equals(Object anObject) {

    // 1.判断传入的值是否与当前字符串地址相同，如果相同就直接返回true
    if (this == anObject) {
        return true;
    }
    
    // 2.如果不相等，再去判断传入的字符串是否为String类型。如果不，直接返回false
    if (anObject instanceof String) {
    
        // 是String，逐个判断每一个字符相不相等，如果全部相等返回true  
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

实例：

public static void main(String[] args) {
    // 在内存当中不能再去修改了，修改，就会创建新的地址
    String str = "ABC";

    String str2 = new String("ABC");

    // 比的是对象的地址
    if (str == str2) {
        System.out.println("地址相等");
    } else {
        System.out.println("地址不相等");
    }

    // 因为String 覆盖了equals，比的是对象的内容
    if (str.equals(str2)) {
        System.out.println("内容相等");
    } else {
        System.out.println("内容不相等");
    }
}

/* 输出结果：
 * 地址不相等
 * 内容相等
 */

String字符串编译优化

public static void main(String[] args) {
    String str1 = "ABCD";
    String str2 = "A" + "B" + "C" + "D";
    String str3 = "AB" + "CD";
    String str4 = new String("ABCD");
    String temp = "AB";
    String str5 = temp + "CD";
    System.out.println(str1 == str2);       // true
    System.out.println(str1 == str3);       // true
    System.out.println(str1 == str4);       // false
    System.out.println(str1 == str5);       // false
}

反编译后；

public static void main(String args[])
{
    String str1 = "ABCD";
    String str2 = "ABCD";
    String str3 = "ABCD";
    String str4 = new String("ABCD");
    String temp = "AB";
    String str5 = (new StringBuilder(String.valueOf(temp))).append("CD").toString();
    System.out.println(str1 == str2);
    System.out.println(str1 == str3);
    System.out.println(str1 == str4);
    System.out.println(str1 == str5);
}

凡是单独使用 "" 引用起来，都是直接量，在编译时期就已经确定好了。编译器会自动编译优化。

String与char[]之间的转换

public static void main(String[] args) {
    // char[] -> String
    char[] cs = new char[] { 'A', 'B', 'C' };
    String str = new String(cs);
    System.out.println(str);

    // 字符串 -> char[]
    char[] cs2 = str.toCharArray();
    for (char c : cs2) {
        System.out.print(c + " ");
    }
}

获取字符串当中的信息

（1）返回字符串长度

String str = "myxq";
int length = str.length();
System.out.println("字符串长度：" + length);

/*
 * 字符串长度：4
 */

（2）返回字符串当中的某一个（索引处的）字符

String str = "myxq";
char c = str.charAt(2);
System.out.println("字符串中的第三个字符：" + c);

/*
 * 字符串中的第三个字符：x
 */

（3）返回指定字符或子字符串在字符串当中第一次出现的位置（索引）

如果此字符串中没有这样的字符或子字符串，则返回 -1。

String str = "ABCDEFG ABCD ABCD";
char c = 'C';
String sub = "BCD";
int i1 = str.indexOf(c);
int i2 = str.indexOf(sub);
int i3 = str.indexOf(c, 7);
int i4 = str.indexOf(sub, 7);
System.out.println("字符 c 在字符串中从头开始第一次出现的索引：" + i1);
System.out.println("子字符串 sub 在字符串中从头开始第一次出现的索引：" + i2);
System.out.println("字符 c 在字符串中从索引7之后（包括7）第一次出现的索引：" + i3);
System.out.println("子字符串 sub 在字符串中从索引7之后（包括7）第一次出现的索引：" + i4);

/*
 * 字符 c 在字符串中从头开始第一次出现的索引：2
 * 子字符串 sub 在字符串中从头开始第一次出现的索引：1
 * 字符 c 在字符串中从索引7之后（包括7）第一次出现的索引：10
 * 子字符串 sub 在字符串中从索引7之后（包括7）第一次出现的索引：9
 */

（4）返回指定字符或子字符串在字符串当中最后一次出现的位置（索引）

如果此字符串中没有这样的字符或子字符串，则返回 -1。

String str = "ABCDEFG ABCD ABCD";
char c = 'C';
String sub = "BCD";
int i1 = str.lastIndexOf(c);
int i2 = str.lastIndexOf(sub);
int i3 = str.lastIndexOf(c, 12);
int i4 = str.lastIndexOf(sub, 12);
System.out.println("字符 c 在字符串中从头开始最后一次出现的索引：" + i1);
System.out.println("子字符串 sub 在字符串中从头开始最后一次出现的索引：" + i2);
System.out.println("字符 c 在字符串中从索引12之前（包括12）最后一次出现的索引：" + i3);
System.out.println("子字符串 sub 在字符串中从索引12之前（包括12）最后一次出现的索引：" + i4);

/*
 * 字符 c 在字符串中从头开始最后一次出现的索引：15
 * 子字符串 sub 在字符串中从头开始最后一次出现的索引：14
 * 字符 c 在字符串中从索引12之前（包括12）最后一次出现的索引：10
 * 子字符串 sub 在字符串中从索引12之前（包括12）最后一次出现的索引：9
 */

字符串字母大小写转换

String str = "The ABCD";

// 把大写字母转成小写
System.out.println(str.toLowerCase());

// 小写字母转成大写
System.out.println(str.toUpperCase());

/*
 * the abcd
 * THE ABCD
 */

字符串忽略大小写判等（判断是否相等）

String str = "The ABCD";

// 把大写字母转成小写
String lowerCase = str.toLowerCase();

// 小写字母转成大写
String upperCase = str.toUpperCase();

// 比较地址
System.out.println(lowerCase == upperCase);                 // false

// 比较内容
System.out.println(lowerCase.equals(upperCase));            // false

// 忽略大小写的比较内容
System.out.println(lowerCase.equalsIgnoreCase(upperCase));  // true

字符串的比较

// 按字典顺序比较两个字符串。 
int compareTo(String anotherString) 

// 按字典顺序比较两个字符串，不考虑大小写。       
int compareToIgnoreCase(String str)

比较规则：

如果第一个字符和参数的第一个字符不等，结束比较，返回他们之间的差值。
如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推。
直至比较的字符或被比较的字符有一方结束。若之前比较都相等，则返回两字符串的长度差值。

// 获取两字符串的长度
int len1 = str1.length();
int len2 = str2.length();

// 取两字符串的长度的最小值
int lim = Math.min(len1, len2);

// 将两字符串转为字符数组
char[] v1 = str1.toCharArray();
char[] v2 = str2.toCharArray();

/*
 * 比较规则：
 * 如果第一个字符和参数的第一个字符不等，结束比较，返回他们之间的差值。
 * 如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推。
 * 直至比较的字符或被比较的字符有一方结束。若之前比较都相等，则返回两字符串的长度差值。
 */

int k = 0;
while (k < lim) {
    char c1 = v1[k];
    char c2 = v2[k];
    if (c1 != c2) {
        return c1 - c2;
    }
    k++;
}
return len1 - len2;

例子：

String str = "ABCD";
String str2 = "AbCDEF";
String str3 = "ABCDEF";

int i = str.compareTo(str2);
System.out.println(i);          // -32

int i2 = str.compareTo(str3);
System.out.println(i2);         // -2

int i3 = str2.compareToIgnoreCase(str);
System.out.println(i3);         // 2

字符串判断是否包含

// 当且仅当此字符串包含指定的 char 值序列时，返回 true。 
boolean contains(CharSequence s)

底层实现：

public boolean contains(CharSequence s) {
    return indexOf(s.toString()) > -1;
}

例子：

String str = "ABCD";
boolean contains = str.contains("BC");
System.out.println(contains);           // true

字符串的截取

// 截取范围：[beginIndex, 最后]
String substring(int beginIndex) 

// 截取范围：[beginIndex, endIndex)
String substring(int beginIndex, int endIndex)

例子1：

String str = "ABCDEFG-HIJKLMN.OPQRST";
int beginIndex = str.indexOf('-');
int endIndex = str.lastIndexOf('.');
String str1 = str.substring(beginIndex);
System.out.println(str1);                   // -HIJKLMN.OPQRST
String str2 = str.substring(beginIndex, endIndex);
System.out.println(str2);                   // -HIJKLMN

例子2：首字母大写

String name = "myxq";
// 1.获取第一个字母 m
String res = name.substring(0, 1);
// 2.把获取的第一个字母变成大写
res = res.toUpperCase();
// 3.获取除第一个字母外后，后面所有内容yxq
String lastString = name.substring(1);
// 4.把大写的字母与其拼接
System.out.println(res + lastString);

// 整合
String str = name.substring(0, 1).toUpperCase() + name.substring(1);
System.out.println(str);

字符串的前缀和后缀

// 判断是否以指定的后缀结束。 
boolean endsWith(String suffix) 

// 判断是否以指定的前缀开始。  
boolean startsWith(String prefix) 

// 判断从指定索引开始的子字符串是否以指定前缀开始 
boolean startsWith(String prefix, int toffset)

例子：

String str = "Hello.java";
boolean b1 = str.startsWith("Hello");
boolean b2 = str.endsWith(".class");
boolean b3 = str.startsWith("llo", 2);
System.out.println(b1);         // true
System.out.println(b2);         // false
System.out.println(b3);         // true

字符串的分割和合并

// 分割
String[] split(String regex) 

// 分割
String[] split(String regex, int limit)
 
// 合并（1.8之后）
static String join(CharSequence delimiter, CharSequence... elements)

例子：

// 分割
String str = "An-apple-a-day-keeps-the-doctor-away";
String[] split = str.split("-");
System.out.println(Arrays.toString(split));

// limit 参数控制模式应用的次数，如果该限制 n>0，则模式将被最多应用 n-1 次，数组的长度将不会大于 n，
String[] split2 = str.split("-", 3);
System.out.println(Arrays.toString(split2));

// 合并
String join = String.join(" ", split);
System.out.println(join);
正则分割
// 提取字符串中的数字
String str = "2019年成绩：语文88分，数学98分，英语95分";

// 定义分割符：非数字   ( \D:非数字字符匹配。等效于 [^0-9]。)
String regex = "\\D+";
String[] split = str.split(regex);
System.out.println(Arrays.toString(split));

格式化字符串

// 使用指定的格式字符串和参数返回一个格式化字符串。
static String format(String format, Object... args)

例子：

int i = 25;
double d = 23.456;
String str = String.format("i=%-5d, d=%6.2f", i, d);
System.out.println(str);        // i=25   , d= 23.46

正则表达式

正则表达式定义了字符串的模式。

正则表达式可以用来搜索、编辑或处理文本。

正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。

正则表达式定义

正如他的名字一样，是描述了一个规则，通过这个规则可以匹配一类字符串。

学习正则表达式很大程度上就是学习正则表达式的语法规则。

正则表达式语法

（1）普通字符

字母、数字、汉字、下划线，以及没有特殊意义的标点符号，都是普通字符，表达式中的普通字符，在匹配一个字符串的时候，匹配与之相同的一个字符。

（2）简单的转义字符

转义字符说明
\n换行符
\t制表符
\\\本身
\^, \$, \., \(, \), \{, \}, \?, \+, \*, \[, \] \|匹配这些字符本身

（3）标准字符集合

能够与 “多种字符” 匹配的表达式。

注意区分大小写，大写是相反的意思。

字符集合说明
.任何字符（与行结束符可能匹配也可能不匹配）
\d数字：[0-9]
\D非数字： [^0-9]
\s空白字符（空格，制表符，换行符等）：[ \t\n\x0B\f\r]
\S非空白字符：[^\s]
\w单词字符（任意一个字母或数字或下划线）：[a-zA-Z_0-9]
\W非单词字符：[^\w]

小数点（.）可以匹配任意一个字符，如果要匹配包括 "\n" 在内的所有字符，一般用 [\s\S]

（4）自定义字符集合

[]方括号匹配方式，能够匹配方括号中任意一个字符。

字符集合说明
[abc]a、b 或 c（简单类）
[^abc]任何字符，除了 a、b 或 c（否定）
[a-zA-Z]a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]]a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]]d、e 或 f（交集）
[a-z&&[^bc]]a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]]a 到 z，而非 m 到 p：[a-lq-z]（减去）

正则表达式的特殊符号，被包含到中括号中，则失去特殊意义，除了^,-之外。

标准字符集合，除小数点外，如果被包含于中括号中，自定义字符集合将包含该集合，比如

[\d.\-+]将匹配：数字、小数点、-、+

（5）量词

修饰匹配次数的特殊符号

量词说明
X?X，零次或一次
X*X，零次或多次
X+X，一次或多次
X{n}X，恰好 n 次
X{n,}X，至少 n 次
X{n,m}X，至少 n 次，但是不超过 m 次

匹配次数中的贪婪模式（默认的，匹配字符越多越好）

1472533-20190726190346030-1500228929.png

匹配次数中的非贪婪模式（匹配字符越少越好，修饰匹配次数的特殊符号后，再加上一个 "?" 问号

量词说明
X??X，零次或一次
X*?X，零次或多次
X+?X，一次或多次
X{n}?X，恰好 n 次
X{n,}?X，至少 n 次
X{n,m}?X，至少 n 次，但是不超过 m 次

1472533-20190726190342996-1982404822.png

（6）字符边界

本组标记匹配的不是字符而是位置，符合某种条件的位置

字符边界说明
^与字符串开始的地方匹配
$与字符串结束的地方匹配
\b匹配一个单词边界

（7）选择符和分组

符号说明
XYX 后跟 Y
XY
(X)X，作为捕获组
(?:X)X，作为非捕获组

反向引用：

每一对()，会分配一个编号，使用()的捕获，根据左括号的顺序，从1开始自动编号，通过反向引用，可以对分组已捕获的字符串进行引用。

1472533-20190726190338648-654569512.png

（8）零宽断言

符号说明
(?=X)断言自身出现的位置的后面能匹配表达式X
(?!X)断言此位置的后面不能匹配表达式X
(?<=X)断言自身出现的位置的前面能匹配表达式X
(?<!X)断言此位置的前面不能匹配表达式X

1472533-20190726190334361-503576894.png

java 正则表达式

java.util.regex 包主要包括以下三个类：

（1）Pattern 类

pattern 对象是一个正则表达式的编译表示。

Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。

（2）Matcher 类

Matcher 对象是对输入字符串进行解释和匹配操作的引擎。

与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。

（3）PatternSyntaxException

PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

例子1：正则匹配

// 创建 Pattern 对象
String regex = "\\d+";      // 定义正则表达式：注意\变成\\
Pattern p = Pattern.compile(regex);

// 创建 Matcher 对象
String input = "123456";    // 目标字符串
Matcher m = p.matcher(input);

// 给定正则表达式与给定的整个输入匹配
boolean b = m.matches();
System.out.println(b);

例子2：正则查找

String str = "2019年成绩：语文88.5分，数学98.5分，英语95分";
String regex = "\\d+\\.\\d+";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(str);
while (m.find()) {
    System.out.println(str.substring(m.start(), m.end()));
    // System.out.println(m.group());
}

字符串匹配

// 返回此字符串是否匹配给定的正则表达式。
boolean matches(String regex)

例子：判断字符串是否全是数字（正则匹配）

// 定义正则表达式：注意\变成\\
String regex = "\\d+";

// 目标字符串
String input = "123456";

boolean b = input.matches(regex);
System.out.println(b);      // true

字符串的替换

// 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String replace(char oldChar, char newChar) 

// 使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
String replace(CharSequence target, CharSequence replacement) 

// 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。        
String replaceAll(String regex, String replacement) 

// 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。    
String replaceFirst(String regex, String replacement)

例子：正则替换

// 定义正则表达式
String regex = "[a-zA-Z]+";

// 目标字符串
String str = "第一节String 第二节Object 第三节Collection";

String newStr = str.replaceAll(regex, "***");
System.out.println(newStr);     // 第一节*** 第二节*** 第三节***

字符串去空格

（1）去首尾空格

// 返回字符串的副本，忽略前导空白和尾部空白。 
String trim()

（2）去全部空格（用字符串替换）

例子：

String str = "  A  B   CD E   ";

// 去首尾空格
String trim = str.trim();
System.out.println(trim);

// 去全部空格
String replace = str.replace(" ", "");
System.out.println(replace);

常用类之StringBuilder

可变的字符串和不可变字符串

（1）不可变字符串String ： 定义好之后，就不能再去改变了。（内存地址不可变）

（2）可变的字符：定义好之后，还可以进行修改。改变时，不会创建新的内存地址。

StringBuilder ：方法前面没有synchronized ，效率比StringBuffer高一些

StringBuffer ：方法前面多了一个synchronized 加锁，更安全，但效率会比StringBuilder低了一些

可变的字符串比不可变字符串性能高很多。

效率：String < StringBuffer < StringBuilder

性能测试：

static int N = 10000;

static void testString() {
    long begin = System.currentTimeMillis();

    String str = "";
    for (int i = 0; i <= N; i++) {
        str += i;
    }

    long last = System.currentTimeMillis();
    System.out.println(last - begin);
}

static void testBuilder() {
    long begin = System.currentTimeMillis();

    StringBuilder str = new StringBuilder();
    for (int i = 0; i <= N; i++) {
        str.append(i);
    }

    long last = System.currentTimeMillis();
    System.out.println(last - begin);
}

static void testBuffer() {
    long begin = System.currentTimeMillis();

    StringBuffer str = new StringBuffer();
    for (int i = 0; i <= N; i++) {
        str.append(i);
    }

    long last = System.currentTimeMillis();
    System.out.println(last - begin);
}

public static void main(String[] args) {
    testString();
    testBuilder();
    testBuffer();
}

StringBuilder 构造器和常用方法

构造方法
// 构造一个其中不带字符的字符串生成器，初始容量为 16 个字符。
StringBuilder() 

// 构造一个其中不带字符的字符串生成器，初始容量由 capacity 参数指定。 
StringBuilder(int capacity) 

// 构造一个字符串生成器，包含与指定的 CharSequence 相同的字符。
StringBuilder(CharSequence seq) 

// 构造一个字符串生成器，并初始化为指定的字符串内容。
StringBuilder(String str)
常用方法
// 字符串追加
StringBuilder append(Object obj) 

// 字符串插入
StringBuilder insert(int offset, Object obj) 

// 删除此序列的子字符串中的字符
StringBuilder delete(int start, int end) 

// 删除此序列中指定位置的字符。
StringBuilder deleteCharAt(int index) 

// 用指定String中的字符替换此序列的子字符串中的字符。
StringBuilder replace(int start, int end, String str) 

// 字符串反转
StringBuilder reverse() 

// 设置指定索引处的字符
void setCharAt(int index, char ch) 

// 返回指定索引处的此序列中的char值 
char charAt(int index)

// 返回当前容量
int capacity()

// 返回指定子字符串第一次出现的字符串中的索引
int indexOf(String str) 

// 从指定的索引处开始，返回指定子字符串第一次出现的字符串中的索引。
int indexOf(String str, int fromIndex) 

// 返回指定子字符串最后一次出现的字符串中的索引
int lastIndexOf(String str) 

// 从指定的索引处之前，返回指定子字符串最后一次出现的字符串中的索引。
int lastIndexOf(String str, int fromIndex) 

// 返回长度（字符数）
int length() 

// 字符串截取，截取范围：[beginIndex, 最后]
String substring(int start) 

// 字符串截取，截取范围：[beginIndex, endIndex)
String substring(int start, int end)

例子：

// 创建的可变字符串，初始容量为16
// 如果超过的话，它会自动扩容
StringBuilder builder = new StringBuilder();
System.out.println(builder.capacity());

// 链式编程
builder.append("ABCDeFG").append("123");

System.out.println(builder);
System.out.println(builder.charAt(4));
builder.setCharAt(4, 'E');
System.out.println(builder);

builder.insert(7, 0);
System.out.println(builder);

builder.deleteCharAt(7);
System.out.println(builder);

// 字符串的反转
builder.reverse();

// 可变字符转成不可变
String s = builder.toString();
System.out.println(s);

StringBuilder 的本质

StringBuilder 的本质还是一个char类的数组

1472533-20190729110607399-1510223053.png

转载于:https://www.cnblogs.com/xzh0717/p/11239511.html

weixin_30911809
关注
Java面向对象（七）
m0_53452634的博客
07-25 89
主要介绍static关键字的使用，单例模式的两种写法，类的成员之四：代码块的使用以及final关键字的使用
JAVA 面向对象 （四）
wzq18845280610的博客
10-16 264
1 JAVA 面向对象中的封装 1. 封装 隐藏类的内部细节，提供外部访问的接口。叫做封装。封装使用get ，set方法。 this: 表示当前对象。 类中拥有构造方法。构造方法是用来构建对象 构造方法是： 方法名称与类名相同，无返回值的方法。 默认一个类中，有一个无参构造方法。 当手动提供了一个有参构造方法。系统将不再提供无参构造方法。 下面展示一些 内联代码片。 ...
学Java的第八天
weixin_53603051的博客
08-03 120
数据类型： 1.字符型： public class DateTest01 { public static void main(String[] args){ char c='a'; System.out.println(c); } } 输出结果为： a public class DateTest01 { public static void main(String[] args){ char c='a';
Java自学开工第二周
qq_51461448的博客
05-20 176
第四章：流程控制 与C语言及其他语言相同，Java语言的复合语句是以整个块区为单位的语句，所以又称为块语句。复合语句由开括号“{”开始，闭括号“}”结束。 1.if条件语句： 虽然if后面的复合语句只有一条语句，省略“{ }”并无语法错误，但是为了增强程序的可读性最好不要省略。 例：给定一个整数，判断它能否被3，5，7整除。 package myproject; public class my { public static void main(String[] args) { int
从源码分析String类中的常用方法
qfchenjunbo的博客
12-21 200
0.构造方法 字符串的构造方法有多种，可以通过String、byte、char、int、StringBuffer 、StringBuilder 等数据类型构造，部分构造方法如下： String()：初始化新创建的 String对象，使其表示空字符序列。 public String() { this.value = "".value; } 复制代码 String(String original):初始化新创建的String对象，使其表示与参数相同的字符序列。 public S
String.Contains（）方法
热门推荐
岁寒松柏
12-12 7万+
返回一个值，该值指示指定的 String 对象是否出现在此字符串中。 下面的代码示例确定字符串“fox”是否为熟悉的引文中的子字符串。 // This example demonstrates the String.Contains() methodusing System; class Sample {  public static void Main() {  str
String的contains方法（indexof方法）源码解析
千羽的博客
09-12 1148
public boolean contains(CharSequence s) { return indexOf(s.toString()) > -1; } public int indexOf(String str) { return indexOf(str, 0); } public int indexOf(String ...
java面向对象编程pdf
04-16
Java面向对象编程PDF 在这篇文章中，我们将对Java面向对象编程的基础知识进行总结和解释。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为...
JAVA面向对象程序设计(期末考试试题及答案)
06-16
JAVA面向对象程序设计知识点总结 JAVA面向对象程序设计是 Java 编程语言的核心 contents，涵盖了面向对象编程的基本概念、语法规则、编程技术和实际应用等方面的知识。本文总结了 JAVA面向对象程序设计的知识点，...
JAVA面向对象程序设计(期末考试试题及答案).pdf
03-28
Java面向对象程序设计是编程领域中的核心概念，它基于面向对象的编程思想，将现实世界中的实体抽象为类，通过类来创建对象，实现代码的复用和模块化。在这个期末考试试题中，我们看到了一系列关于Java编程的问题，...
JAVA面向对象程序设计(期末考试试题及答案).zip
06-05
这个压缩包文件"JAVA面向对象程序设计(期末考试试题及答案).zip"包含了学习和复习Java OOP的关键资源，包括一份详细的资源说明文档和期末考试试题及答案的PDF。 资源说明.docx可能涵盖了学习Java OOP的基础概念、...
Java面向对象程序设计
03-17
Java面向对象程序设计是计算机编程领域中的核心主题，它基于面向对象编程（OOP）理念，使得代码更具有模块化、可复用性和易于维护的特点。以下是对标题和描述中涉及的知识点的详细阐述： 1. **第1章：Java入门** -...
return myArray.constructor.toString().indexOf(“Array“) ＞ -1；这句话怎么解释?
liulang68的博客
09-02 764
https://www.runoob.com/note/49133
关于String类contains(null)报空指针的问题
qq_38238217的博客
09-15 5557
先上结论：String类contains()方法的参数不能为null，否则会报NullPointerException异常。 示例代码： System.out.println("str".contains(null)); 输出： Exception in thread "main" java.lang.NullPointerException at java.lang.String.contains(String.java:2133) 分析一下String类contains()方法源...
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1111
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 153
");
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 919
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 346
spirng security中的几大组件的差异和执行顺序
计算机毕业设计 网上书店系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
最新发布
weixin_19164791635
09-16 840
本文介绍了一款基于Java、SpringBoot和Vue.js技术的网上书店系统。该系统为管理员、用户和卖家提供了图书信息浏览、订单管理、个人中心管理等功能，旨在打造一个便捷、高效的在线购书平台。系统通过优化图书销售流程，提升用户体验，推动出版行业的数字化转型，促进知识传播和文化交流。
Java面向对象基础解析
"Java面向对象（基础）" Java面向对象编程是Java语言的核心特性，它使得程序设计更加灵活和模块化。本课程是面向对象的基础入门，适合初学者学习，旨在帮助学生掌握面向对象的基本概念和技能。 1、Java可移植性 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值