【原】Java学习笔记022 - 字符串
package cn.temptation;
public class Sample01 {
public static void main(String[] args) {
// 字符串
// 定义：String 类代表字符串。由多个字符组成的一串数据（类比：羊肉串）。字符数组可以由多个字符组成（类比，整型数组由多个整型数字组成）。
// 字符串的声明及赋值
// 1、String类代表字符串
// 2、Java 程序中的所有字符串字面值（如 "abc" ）都作为String类的实例实现。（对比，之前的实例实现通过new关键字进行类的实例化获得类的对象）
// 3、字符串（字符串字面值）是常量，它们的值在创建后不能更改
// 4、因为String对象是不可变得，所以可以共享（"abc"这个字符串字面值可以被不同的String类型的对象拿来引用使用）
// String str = "abc";
// 字符串String类的常用构造函数：
// 1、String() ：初始化一个新创建的 String 对象，使其表示一个空字符序列。
// 2、String(byte[] bytes) ：通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
// 3、String(byte[] bytes, int offset, int length) ：通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。
// 4、String(char[] value) ：分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
// 5、String(char[] value, int offset, int count) ：分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
// 6、String(String original) ：初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。
// 字符串String类的常用成员方法：
// 1、int length() ：返回此字符串的长度。
String string1 = new String();
System.out.println("string1:" + string1); // 显示为：string1: 看到显示的结果为无内容，显然String类是没有使用Object类继承而来的toString方法
System.out.println("string1的长度为：" + string1.length()); //
System.out.println("-------------------------------------------------------");
// byte[] bytes = { 65, 66, 67, 68 };
byte[] bytes = { 97, 98, 99, 100 };
String string2 = new String(bytes);
System.out.println("string2:" + string2);
System.out.println("string2的长度为：" + string2.length()); //
System.out.println("-------------------------------------------------------");
String string3 = new String(bytes, 1, 2);
System.out.println("string3:" + string3); // bc
System.out.println("string3的长度为：" + string3.length()); // 2
// offset参数 或 length参数索引超出bytes数组的范围
// 执行异常：java.lang.StringIndexOutOfBoundsException: String index out of range: 5
// String string4 = new String(bytes, 3, 2);
// System.out.println("string4:" + string4);
// System.out.println("string4的长度为：" + string4.length());
System.out.println("-------------------------------------------------------");
char[] chars = { 'J', 'a', 'v', 'a', '真', '简', '单' };
String string5 = new String(chars);
System.out.println("string5:" + string5); // Java真简单
System.out.println("string5的长度为：" + string5.length()); //
System.out.println("-------------------------------------------------------");
String string6 = new String(chars, 1, 3);
System.out.println("string6:" + string6); // ava
System.out.println("string6的长度为：" + string6.length()); // 3
// offset参数 或 length参数索引超出chars数组的范围
// 执行异常：java.lang.StringIndexOutOfBoundsException: String index out of range: 9
// String string7 = new String(chars, 5, 4);
// System.out.println("string7:" + string7); // ava
// System.out.println("string7的长度为：" + string7.length());
System.out.println("-------------------------------------------------------");
String string8 = new String("中华人民共和国");
System.out.println("string8:" + string8); // 中华人民共和国
System.out.println("string8的长度为：" + string8.length()); //
System.out.println("-------------------------------------------------------");
String string9 = "中华人民共和国";
System.out.println("string9:" + string9); // 中华人民共和国
System.out.println("string9的长度为：" + string9.length()); //
}
}
package cn.temptation;
public class Sample02 {
public static void main(String[] args) {
// 如何理解：字符串是常量，它们的值在创建以后不能更改？
// 1、使用字符串字面值时，首先到堆内存中的方法区的字符串常量池中查找该字符串字面值是否存在，如果存在则直接拿来使用；如果不存在则创建之
// 2、字符串字面量的值是常量，这个值在方法区中的字符串常量池中创建后的确没有发生过改变
String str = "Java"; // 首先到堆内存中的方法区的字符串常量池中查找该字符串字面值是否存在，如果存在则直接拿来使用；如果不存在则创建"Java"字面量
str += "真简单"; // 等价于：str = str + "真简单";
// 分解：str + "真简单" -----> "Java" + "真简单"，因为到字符串常量池中查找"真简单"这个字符串字面值是否存在，不存在则创建"真简单"字面量
// 这里的加号作为字符串的连接 -----> "Java真简单"，因为到字符串常量池中查找"Java真简单"这个字符串字面值是否存在，不存在则创建"Java真简单"字面量
System.out.println(str); // Java真简单
// 上述三行语句，实际上在字符串常量池中创建了3个字符串字面量
}
}
package cn.temptation;
public class Sample03 {
public static void main(String[] args) {
/*
* 1、== 做比较
* A：用在基本数据类型上，比较值是否相等
* B：用在引用数据类型上，比较地址值是否相同
*
* 2、equals 做比较
* A：用在引用数据类型上：如果继承自Object类型的equals，还是比较的是地制值是否相同；有内容比较的要求可以通过重写equals方法来实现比较
*/
// 下句是将字符串字面量赋值给String类型的变量，首先去字符串常量池中查找有没有"Java真简单"字符串实例实现，没有就创建之
String string1 = "Java真简单";
// 下句是通过new关键字在堆内存中开辟一块空间存放String类型的对象，而该构造函数会使用"Java真简单"这个字符串字面量
// 使用这个字符串字面量还是去字符串常量池中查找有没有"Java真简单"字符串实例，这时已经存在该字面量了，就不再创建了，直接拿着用
String string2 = new String("Java真简单");
// 因为string1 和 string2 都是在栈上的声明，string1引用的是字符串字面量"Java真简单"的地址，string2引用的是在堆内存中开辟的空间地址
// 自然不会相同，也就判断为false
// System.out.println(string1 == string2); // false
// System.out.println("string1`s hashCode:" + string1.hashCode()); // string1`s hashCode:-125004366
// System.out.println("string2`s hashCode:" + string2.hashCode()); // string2`s hashCode:-125004366
//
// String类的常用成员方法：
// 1、boolean equals(Object anObject) ：将此字符串与指定的对象比较。
// 将此字符串与指定的对象比较。当且仅当该参数不为 null，并且是与此对象表示相同字符序列的 String 对象时，结果才为 true。
// String类的equals方法重写了继承自Object类的equals方法，比较两个字符串对象的内容
System.out.println(string1.equals(string2)); // true
// instanceof的使用：判断是否为某一类型的实现
System.out.println(string1 instanceof String); // true
System.out.println(string2 instanceof String); // true
}
}
// 查看String类的equals方法的源码
//public boolean equals(Object anObject) {
// if (this == anObject) {
// return true;
// }
// if (anObject instanceof String) {
// 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;
//}
package cn.temptation;
public class Sample04 {
public static void main(String[] args) {
// String string1 = new String("Java真简单");
// String string2 = new String("Java真简单");
// System.out.println(string1 == string2); // false
// System.out.println(string1.equals(string2)); // true
// System.out.println("string1`s hashCode:" + string1.hashCode()); // string1`s hashCode:-125004366
// System.out.println("string2`s hashCode:" + string2.hashCode()); // string2`s hashCode:-125004366
// System.out.println("-----------------------------------------");
//
// String string3 = new String("Java真简单");
// String string4 = "Java真简单";
// System.out.println(string3 == string4); // false
// System.out.println(string3.equals(string4)); // true
// System.out.println("-----------------------------------------");
// string5引用的字符串字面量是字符串常量池中的字面量"Java真简单"（首先也是在常量池中查找是否存在）
String string5 = "Java真简单";
// string6引用的字符串字面量就是字符串常量池中的字面量"Java真简单"
String string6 = "Java真简单";
System.out.println(string5 == string6); // true
System.out.println(string5.equals(string6)); // true
}
}
package cn.temptation;
public class Sample05 {
public static void main(String[] args) {
String string1 = "Java";
String string2 = "真简单";
String string3 = "Java真简单";
System.out.println(string3 == string1 + string2); // false
// 通过反编译.class文件，发现上句其实是：
// System.out.println(string3 == (new StringBuilder(String.valueOf(string1))).append(string2).toString()); 显然地址不一致
System.out.println(string3.equals(string1 + string2)); // true
// 通过反编译.class文件，发现上句其实是：
// System.out.println(string3.equals((new StringBuilder(String.valueOf(string1))).append(string2).toString())); 比较的是内容，显然一致
System.out.println("----------------------------------------");
System.out.println(string3 == "Java" + "真简单"); // true
// 通过反编译.class文件，发现上句其实是：
// System.out.println(string3 == "Java真简单"); 显然地址一致
System.out.println(string3.equals("Java" + "真简单")); // true
// 通过反编译.class文件，发现上句其实是：
// System.out.println(string3.equals("Java真简单")); 比较的是内容，显然一致
System.out.println("----------------------------------------");
System.out.println(string3 == string1 + "真简单"); // false
// 通过反编译.class文件，发现上句其实是：
// System.out.println(string3 == (new StringBuilder(String.valueOf(string1))).append("真简单").toString()); 显然地址不一致
System.out.println(string3 == "Java" + string2); // false
// 通过反编译.class文件，发现上句其实是：
// System.out.println(string3 == (new StringBuilder("Java")).append(string2).toString()); 显然地址不一致
System.out.println(string3.equals(string1 + "真简单")); // true
// 通过反编译.class文件，发现上句其实是：
// System.out.println(string3.equals((new StringBuilder(String.valueOf(string1))).append("真简单").toString())); 比较的是内容，显然一致
System.out.println(string3.equals("Java" + string2)); // true
// 通过反编译.class文件，发现上句其实是：
// System.out.println(string3.equals((new StringBuilder("Java")).append(string2).toString())); 比较的是内容，显然一致
/*
* 结论：
* 1、字符串变量做加法（连接）时，先去做开辟空间的事情，再去做字符串的连接
* 2、字符串字面量（常量）做加法（连接）时，先做字符串的连接，再去常量池中查找是否存在，存在就直接使用，不存在就创建之
* 3、字符串变量 和 字符串字面量做加法（连接）时，先去做开辟空间的事情，再去做字符串的连接
*/
}
}
package cn.temptation;
public class Sample06 {
public static void main(String[] args) {
/*
* String类的常用成员方法：（具有判断功能）
* 1、boolean equals(Object anObject) ：将此字符串与指定的对象比较。
* 2、boolean equalsIgnoreCase(String anotherString) ：将此 String 与另一个 String 比较，不考虑大小写。
* 3、boolean contains(CharSequence s) ：当且仅当此字符串包含指定的 char 值序列时，返回 true。
* 4、boolean startsWith(String prefix) ：测试此字符串是否以指定的前缀开始。
* 5、boolean startsWith(String prefix, int toffset) ：测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
* 6、boolean endsWith(String suffix) ：测试此字符串是否以指定的后缀结束。
* 7、boolean isEmpty() ：当且仅当 length() 为 0 时返回 true。
*/
String string1 = "Java";
String string2 = "java";
String string3 = "Java";
System.out.println(string1.equals(string2)); // false
System.out.println(string1.equals(string3)); // true
System.out.println("-----------------------------------------");
System.out.println(string1.equalsIgnoreCase(string2)); // true
System.out.println(string1.equalsIgnoreCase(string3)); // true
System.out.println("-----------------------------------------");
// CharSequence不是char字符，而是字符序列。
// String类实现了CharSequence接口
// 语法错误：The method contains(CharSequence) in the type String is not applicable for the arguments (char)
// System.out.println(string1.contains('a'));
System.out.println(string1.contains("a")); // true
System.out.println(string1.contains("b")); // false
System.out.println(string1.contains("va")); // true
System.out.println(string1.contains("sb")); // false
System.out.println("-----------------------------------------");
System.out.println(string1.startsWith("J")); // true
System.out.println(string1.startsWith("J", 0)); // true
System.out.println(string1.startsWith("J", 1)); // false
System.out.println(string1.startsWith("ava", 1)); // true
System.out.println("-----------------------------------------");
System.out.println(string1.endsWith("a")); // true
System.out.println(string1.endsWith("va")); // true
System.out.println(string1.endsWith("Java")); // true
System.out.println(string1.endsWith("av")); // false
System.out.println("-----------------------------------------");
String string4 = null; // null值
String string5 = ""; // 空字符串
String string6 = "0"; // 字符串内容为0
String string7 = "null"; // 字符串内容为null
String string8 = " "; // 字符串内容为一个空格
// 执行异常：java.lang.NullPointerException
// System.out.println("string4 isEmpty:" + string4.isEmpty());
System.out.println("string5 isEmpty:" + string5.isEmpty()); // true
System.out.println("string6 isEmpty:" + string6.isEmpty()); // false
System.out.println("string7 isEmpty:" + string7.isEmpty()); // false
System.out.println("string8 isEmpty:" + string8.isEmpty()); // false
}
}
package cn.temptation;
public class Sample07 {
public static void main(String[] args) {
// String类的常用成员方法：
// String intern() ：返回字符串对象的规范化表示形式。
// 一个初始为空的字符串池，它由类 String 私有地维护。
// 当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（用 equals(Object) 方法确定），则返回池中的字符串。
// 否则，将此 String 对象添加到池中，并返回此 String 对象的引用。
// 它遵循以下规则：对于任意两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true。
// 所有字面值字符串和字符串赋值常量表达式都使用 intern 方法进行操作。
String string1 = "Java真简单";
String string2 = new String("Java真简单");
System.out.println(string1 == string2); // false
System.out.println(string1 == string2.intern()); // true
System.out.println(string1.intern() == string2.intern()); // true
System.out.println(string1.equals(string2.intern())); // true
}
}
package cn.temptation;
public class Sample08 {
public static void main(String[] args) {
// String类的使用：涉及开发习惯
// String str = "java";
// 变量str被赋值为null时，如下写法会产生执行异常：java.lang.NullPointerException，因为null值没有equals方法
String str = null;
// 初始写法：
// if (str.equals("javatemptation")) {
// System.out.println("内容一致");
// } else {
// System.out.println("内容不一致");
// }
// 改进写法：因为字符串字面量一定有equals方法，所以把其放在前面，而可能有null的变量作为equals方法的参数，这样就避免了空指针异常
if ("javatemptation".equals(str)) {
System.out.println("内容一致");
} else {
System.out.println("内容不一致");
}
}
}
package cn.temptation;
import java.util.Scanner;
public class Sample09 {
public static void main(String[] args) {
// 需求：模拟用户登录，最多可以登录三次，且每次登录失败的话提示还有几次机会
// 思路：
// 1、有设定好的帐号和密码用来进行对比是否输入正确
// 2、通过Scanner类的方法接收控制台的键盘录入
// 3、将输入的帐号和密码与设置好的帐号和密码进行对比：一致时，登录成功；不一致时（有一个不一致和两个都不一致），登录失败，提示登录失败
// 4、登录次数的限制为3次，且在每次失败时提示还剩的次数
// 设置帐号和密码
String username_default = "admin";
String password_default = "123";
// 设置最多登录次数
int maxCount = 3;
Scanner input = new Scanner(System.in);
for (int i = 0; i < maxCount; i++) {
// 接收键盘录入
System.out.println("输入帐号：");
String username = input.nextLine();
System.out.println("输入密码：");
String password = input.nextLine();
// 判断登录是否成功
if (username_default.equals(username) && password_default.equals(password)) {
System.out.println("登录成功！");
// 登录成功时，就跳出循环
break;
} else {
// 登录失败时
int temp = maxCount - 1 - i;
if (temp == 0) {
System.out.println("登录失败，帐号已锁定！");
} else {
System.out.println("登录失败，还有" + temp + "次机会！");
}
}
}
input.close();
}
}
package cn.temptation;
import java.util.Scanner;
public class Sample10 {
public static void main(String[] args) {
// Sample09的写法还是面向过程的写法，我们应该具备面向对象的思想
// 思考在登录这个事情中，有哪些对象？对象的行为是什么？对象的特征是什么？
// 分析出：有一个用户（对象），他/她有登录这个行为，会操作帐号和密码这两个特征
// 因为是由系统给予用户几次登录的机会，所以登录次数不应该属于用户，而是系统的特征
// 设置最多登录次数
int maxCount = 3;
// 静态方法的调用，注意方法中是否有成员变量，有的话，就必须设置成员变量为静态的
// test(maxCount);
// 非静态方法的调用
// 写法1：常规写法
// Sample10 sample10 = new Sample10();
// sample10.test(maxCount);
// 写法2：匿名对象
(new Sample10()).test(maxCount);
}
/**
* 系统给予用户登录的操作
* @param maxCount
*/
// public static void test(int maxCount) { // 静态写法
public void test(int maxCount) { // 非静态写法
User user = new User();
// 接收键盘录入
Scanner input = new Scanner(System.in);
for (int i = 0; i < maxCount; i++) {
// 接收键盘录入
System.out.println("输入帐号：");
user.setUsername(input.nextLine());
System.out.println("输入密码：");
user.setPassword(input.nextLine());
// 判断登录是否成功
if (user.checkLogin(user)) {
System.out.println("登录成功！");
// 登录成功时，就跳出循环
break;
} else {
// 登录失败时
int temp = maxCount - 1 - i;
if (temp == 0) {
System.out.println("登录失败，帐号已锁定！");
} else {
System.out.println("登录失败，还有" + temp + "次机会！");
}
}
}
input.close();
}
}
// 抽象出一个用户类
class User {
// 成员变量
// 帐号
private String username;
// 密码
private String password;
// 正确的用户帐号
private String username_default = "admin";
// 正确的用户密码
private String password_default = "123";
// 构造函数
public User() {
super();
}
public User(String username, String password) {
super();
this.username = username;
this.password = password;
}
// 成员方法
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
// 自定义的成员方法
// 判断是否登录成功（这个成员方法功能OK，但是不够好，不够好的原因在于不够面向对象，因为这样写可能会有很长的参数列表）
// public boolean checkLogin(String username, String password) {
// // 判断
// if (username_default.equals(username) && password_default.equals(password)) {
// return true;
// } else {
// return false;
// }
// }
// 改进写法
// 判断是否登录成功（传入一般类的对象，这样就可以无视参数个数了，反正都是对象的特征）
public boolean checkLogin(User user) {
if (username_default.equals(user.getUsername()) && password_default.equals(user.getPassword())) {
return true;
} else {
return false;
}
}
}
package cn.temptation;
public class Sample11 {
public static void main(String[] args) {
/*
* String类的常用成员方法：（具有获取功能）
* 1、int length() ：返回此字符串的长度。
* 2、char charAt(int index) ：返回指定索引处的 char 值。
* 3、int indexOf(int ch) ：返回指定字符在此字符串中第一次出现处的索引。
* 4、int indexOf(int ch, int fromIndex) ：返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
* 5、int indexOf(String str) ：返回指定子字符串在此字符串中第一次出现处的索引。
* 6、int indexOf(String str, int fromIndex) ：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
* 7、String substring(int beginIndex) ：返回一个新的字符串，它是此字符串的一个子字符串。
* 8、String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串的一个子字符串。
*/
String string1 = "javatemptation";
System.out.println("string1`s length:" + string1.length()); //
String string2 = "";
System.out.println("string2`s length:" + string2.length()); //
String string3 = null;
// 执行产生异常：java.lang.NullPointerException 空指针异常
// System.out.println("string3`s length:" + string3.length());
String string4 = " ";
System.out.println("string4`s length:" + string4.length()); //
System.out.println("-----------------------------------------------------------");
System.out.println("string1.charAt(7):" + string1.charAt(7)); // p
// 执行产生异常：java.lang.StringIndexOutOfBoundsException: String index out of range: 20 索引越界异常
// System.out.println("string1.charAt(20):" + string1.charAt(20));
System.out.println("string1.charAt(13):" + string1.charAt(13)); // n
System.out.println("-----------------------------------------------------------");
System.out.println("string1.indexOf(106):" + string1.indexOf(106)); // 106表示的是j 0
System.out.println("string1.indexOf(97):" + string1.indexOf(97)); // 97表示的是a 1
// 返回：在此对象表示的字符序列中第一次出现该字符的索引；如果未出现该字符，则返回 -1。
System.out.println("string1.indexOf(98):" + string1.indexOf(98)); // 98表示的是b -1
System.out.println("-----------------------------------------------------------");
System.out.println("string1.indexOf(106, 0):" + string1.indexOf(106, 0)); // 106表示的是j 0
// 返回：在此对象表示的字符序列中第一次出现的大于或等于 fromIndex 的字符的索引；如果未出现该字符，则返回 -1。
System.out.println("string1.indexOf(106, 1):" + string1.indexOf(106, 1)); // j -1
System.out.println("-----------------------------------------------------------");
System.out.println("string1.indexOf(\"av\"):" + string1.indexOf("av")); // av 1
// 返回：如果字符串参数作为一个子字符串在此对象中出现，则返回第一个这种子字符串的第一个字符的索引；如果它不作为一个子字符串出现，则返回 -1。
System.out.println("string1.indexOf(\"vb\"):" + string1.indexOf("vb")); // vb -1
System.out.println("-----------------------------------------------------------");
// 返回：指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
System.out.println("string1.indexOf(\"av\", 0):" + string1.indexOf("av", 0)); // av 1
System.out.println("string1.indexOf(\"av\", 1):" + string1.indexOf("av", 1)); // av 1
System.out.println("string1.indexOf(\"av\", 2):" + string1.indexOf("av", 2)); // av -1
System.out.println("string1.indexOf(\"vb\", 0):" + string1.indexOf("vb", 0)); // vb -1
System.out.println("-----------------------------------------------------------");
// 参数：beginIndex - 起始索引（包括）。
System.out.println("string1.substring(0):" + string1.substring(0)); // javatemptation
System.out.println("string1.substring(5):" + string1.substring(5)); // emptation
// 执行异常：java.lang.StringIndexOutOfBoundsException: String index out of range: -2 字符串索引越界异常
// System.out.println("string1.substring(-2):" + string1.substring(-2));
// 执行异常：java.lang.StringIndexOutOfBoundsException: String index out of range: -6 字符串索引越界异常
// System.out.println("string1.substring(20):" + string1.substring(20));
System.out.println("-----------------------------------------------------------");
// 参数：beginIndex - 起始索引（包括）。 endIndex - 结束索引（不包括）。
System.out.println("string1.substring(0, 1):" + string1.substring(0, 1)); // j
System.out.println("string1.substring(0, 13):" + string1.substring(0, 13)); // javatemptatio
System.out.println("string1.substring(0, 14):" + string1.substring(0, 14)); // javatemptation
// 执行异常：java.lang.StringIndexOutOfBoundsException: String index out of range: 20 字符串索引越界异常
// System.out.println("string1.substring(0, 20):" + string1.substring(0, 20));
// 执行异常：java.lang.StringIndexOutOfBoundsException: String index out of range: -2 字符串索引越界异常
// System.out.println("string1.substring(-2, 14):" + string1.substring(-2, 14));
// 执行异常：java.lang.StringIndexOutOfBoundsException: String index out of range: -2 字符串索引越界异常
// System.out.println("string1.substring(10, 8):" + string1.substring(10, 8));
System.out.println("string1.substring(0, string1.length()):" + string1.substring(0, string1.length())); // javatemptation
System.out.println("string1.substring(0, string1.length() - 1):" + string1.substring(0, string1.length() - 1)); // javatemptatio
}
}
package cn.temptation;
import java.util.Scanner;
public class Sample12 {
public static void main(String[] args) {
// 需求：通过键盘录入，循环获取输入的一个字符串中的每一个字符并显示出来
// 例如：输入：abc，显示出 a b c
String str = "";
System.out.println("输入一个字符串：");
Scanner input = new Scanner(System.in);
if (input.hasNextLine()) {
str = input.nextLine();
} else {
System.out.println("输入的不正确！");
}
input.close();
for (int i = 0; i < str.length(); i++) {
System.out.print(str.charAt(i) + "\t");
}
}
}
package cn.temptation;
import java.util.Scanner;
public class Sample13 {
public static void main(String[] args) {
// 需求：根据键盘录入的一个字符串（仅限于有大写英文、小写英文和数字），统计一下该字符串中大写英文字符有多少个？小写英文字符有多少个？数字字符有多少个？
// 例如："Java123456"：大写1个、小写3个、数字6个
// 思路：（人为控制输入格式的版本）
// 1、接收键盘录入的字符串，循环取得该字符串的每一个字符
// 2、判断每一个字符是大写，还是小写，还是数字
// 3、分类做累加
String str = "";
// 大写英文字符的个数
int upperCount = 0;
// 小写英文字符的个数
int lowerCount = 0;
// 数字字符的个数
int numberCount = 0;
System.out.println("输入一个字符串（仅限于有大写英文、小写英文和数字）：");
Scanner input = new Scanner(System.in);
if (input.hasNextLine()) {
str = input.nextLine();
} else {
System.out.println("输入不正确！");
}
input.close();
for (int i = 0; i < str.length(); i++) {
// 获取单个字符
char temp = str.charAt(i);
// 判断写法1
// if (temp >= 65 && temp <= 90) { // 大写英文字符
// upperCount++;
// } else if (temp >= 97 && temp <= 122) { // 小写英文字符
// lowerCount++;
// } else if(temp >= 48 && temp <= 57) { // 数字字符
// numberCount++;
// }
// 判断写法2
if (temp >= 'A' && temp <= 'Z') { // 大写英文字符
upperCount++;
} else if (temp >= 'a' && temp <= 'z') { // 小写英文字符
lowerCount++;
} else if(temp >= '0' && temp <= '9') { // 数字字符
numberCount++;
}
}
System.out.println("字符串：" + str + "中，大写英文字符有：" + upperCount + "个，小写英文字符有："
+ lowerCount + "个，数字字符有：" + numberCount + "个");
}
}
package cn.temptation;
import java.util.Scanner;
public class Sample14 {
public static void main(String[] args) {
// 需求：根据键盘录入的一个字符串（仅限于有大写英文、小写英文和数字），统计一下该字符串中大写英文字符有多少个？小写英文字符有多少个？数字字符有多少个？
// 例如："Java123456"：大写1个、小写3个、数字6个
// 思路：（程序控制输入格式的版本）
// 1、接收键盘录入的字符串，循环取得该字符串的每一个字符
// 2、判断每一个字符是大写英文、还是小写英文、还是数字，如果都不是，那么就是不正确的输入，应该提示让其重新输入；否则进行统计
// 3、对于输入正确格式的字符串，循环获取每一个字符并进行判断统计
Scanner input = new Scanner(System.in);
String str = "";
// 大写英文字符的个数
int upperCount = 0;
// 小写英文字符的个数
int lowerCount = 0;
// 数字字符的个数
int numberCount = 0;
for(;;) {
// 声明统计执行判断标识
boolean flag = true;
// 1、判断操作，看看输入格式是否正确
System.out.println("输入一个字符串（仅限于有大写英文、小写英文和数字）：");
if (input.hasNextLine()) {
str = input.nextLine();
} else {
System.out.println("输入的内容不是字符串！");
break;
}
// 对输入的字符串的格式进行判断
for (int i = 0; i < str.length(); i++) {
char temp = str.charAt(i);
if (!((temp >= 'A' && temp <= 'Z') || (temp >= 'a' && temp <= 'z') || (temp >= '0' && temp <= '9'))) {
// 大写英文字符、小写英文字符、数字字符之外的都是不正确的格式
System.out.println("输入的字符串格式不正确，仅限有大写英文、小写英文和数字！");
flag = false;
// 考虑：这里使用break？ 还是使用continue？
// 因为只要有一个字符是不合规则的字符，就不用再判断其他字符是否符合规则了，所以使用break跳出内层for循环
break;
}
}
// 2、统计操作
if (flag) {
for (int i = 0; i < str.length(); i++) {
// 获取单个字符
char temp = str.charAt(i);
// 判断写法1
// if (temp >= 65 && temp <= 90) { // 大写英文字符
// upperCount++;
// } else if (temp >= 97 && temp <= 122) { // 小写英文字符
// lowerCount++;
// } else if(temp >= 48 && temp <= 57) { // 数字字符
// numberCount++;
// }
// 判断写法2
if (temp >= 'A' && temp <= 'Z') { // 大写英文字符
upperCount++;
} else if (temp >= 'a' && temp <= 'z') { // 小写英文字符
lowerCount++;
} else if(temp >= '0' && temp <= '9') { // 数字字符
numberCount++;
}
}
System.out.println("字符串：" + str + "中，大写英文字符有：" + upperCount + "个，小写英文字符有："
+ lowerCount + "个，数字字符有：" + numberCount + "个");
// 正确的格式输入后，进行统计操作，操作结束后跳出当前的外层循环（死循环）
break;
}
}
input.close();
}
}
package cn.temptation;
public class Sample15 {
public static void main(String[] args) {
/*
* String类的常用成员方法：（具有转换功能）
* 1、byte[] getBytes() ：使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
* 2、char[] toCharArray() ：将此字符串转换为一个新的字符数组。
* 3、static String valueOf(char[] data) ：返回 char 数组参数的字符串表示形式。
* 4、static String valueOf(int i) ：返回 int 参数的字符串表示形式。
* 5、String toLowerCase() ：使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
* 6、String toUpperCase() ：使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
* 7、String concat(String str) ：将指定字符串连接到此字符串的结尾。
*/
String string1 = "javatemptation";
// 将字符串转换为byte数组
byte[] arrByte = string1.getBytes();
for (byte item : arrByte) {
System.out.println(item);
}
System.out.println("------------------------------------------------------");
// 将字符串转换为char数组
char[] arrChar = string1.toCharArray();
for (char item : arrChar) {
System.out.println(item);
}
System.out.println("------------------------------------------------------");
// 将字符数组转换为字符串（与上述方法是可逆操作）
String string2 = String.valueOf(arrChar);
System.out.println(string2);
System.out.println("------------------------------------------------------");
int i = 97;
// int类型转换成字符串类型的方法1
// String string3 = String.valueOf(i);
// System.out.println(string3); // 97
//
// String string4 = String.valueOf((char)i);
// System.out.println(string4); // a
//
// String string5 = String.valueOf((int)'a');
// System.out.println(string5); // 97
// int类型转换成字符串类型的方法2
System.out.println(i + ""); //
System.out.println("" + i); //
System.out.println(" " + i); // 空格97
System.out.println((String)(i + "")); // 97
// 语法错误：Invalid character constant
// System.out.println(i + '');
// 语法错误：Char cannot be resolved to a type
// System.out.println((char)(i + ""));
System.out.println("------------------------------------------------------");
String string6 = "JAVATEMPTATION";
System.out.println(string6.toLowerCase()); // javatemptation
System.out.println("------------------------------------------------------");
String string7 = "javatemptation";
System.out.println(string7.toUpperCase()); // JAVATEMPTATION
System.out.println("------------------------------------------------------");
String string8 = "offerfirstblood";
System.out.println(string1.concat(string8)); // javatemptationofferfirstblood
}
}
package cn.temptation;
import java.util.Scanner;
public class Sample16 {
public static void main(String[] args) {
// 需求：根据键盘录入一个字符串（仅限大写英文字符和小写英文字符），显示该字符串，且转换该字符串为首字符大写，其他字符均小写，并显示转换后的字符串
// 例如："javaTEMPTATION" ------> "Javatemptation"
String str = "";
System.out.println("录入一个字符串（仅限大写英文字符和小写英文字符）：");
Scanner input = new Scanner(System.in);
if (input.hasNextLine()) {
str = input.nextLine();
} else {
System.out.println("输入的格式不正确！");
}
input.close();
// 思路1：
// 1、获取输入的字符串，循环遍历得到每一个字符
// 2、判断第一个字符是否为大写字符，如果不是，转为大写
// 3、判断从第二个字符到最后一个字符是否为小写字符，如果不是，转为小写
// 4、将转换后的字符组成字符串输出
// char[] arrChar = new char[str.length()];
//
// for (int i = 0; i < arrChar.length; i++) {
// char temp = str.charAt(i);
//
// if (i == 0) { // 第一个字符
// if (temp >= 'a' && temp <= 'z') {
// // 小写字符转换为大写字符
// temp -= 32;
// }
// } else { // 从第二个字符到最后一个字符
// if (temp >= 'A' && temp <= 'Z') {
// // 大写字符转换为小写字符
// temp += 32;
// }
// }
//
// arrChar[i] = temp;
// }
//
// System.out.println("转换后的字符串为：" + String.valueOf(arrChar));
// 思路2：
// 1、获取输入的字符串，直接转为char数组
// 2、判断第一个字符是否为大写字符，如果不是，转为大写
// 3、判断从第二个字符到最后一个字符是否为小写字符，如果不是，转为小写
// 4、将转换后的字符组成字符串输出
// 写法2-1
// char[] arrChar = str.toCharArray();
// if (arrChar[0] >= 'a' && arrChar[0] <= 'z') { // 第一个字符
// // 小写字符转换为大写字符
// arrChar[0] -= 32;
// }
// // 从第二个字符到最后一个字符判断
// for (int i = 1; i < arrChar.length; i++) {
// if (arrChar[i] >= 'A' && arrChar[i] <= 'Z') {
// // 大写字符转换为小写字符
// arrChar[i] += 32;
// }
// }
//
// System.out.println("转换后的字符串为：" + String.valueOf(arrChar));
// 写法2-2
// char[] arrChar = str.toCharArray();
// // 重新定义一个char类型的数组来接收
// char[] arrCharEx = new char[arrChar.length];
//
// // 从第1个字符到最后一个字符（先都拿出来判断），如果是大写字符，转换为小写字符，
// // 因为拿出来的是一个一个的char类型的元素，判断后发生变化的元素自身，然后放入新的数组中
// int i = 0;
// for (char item : arrChar) {
// if (item >= 'A' && item <= 'Z') {
// // 大写字符转换为小写字符
// item += 32;
// }
//
// arrCharEx[i] = item;
// i++;
// }
//
// // 首字符判断，如果是小写字符转换为大写字符
// if (arrCharEx[0] >= 'a' && arrCharEx[0] <= 'z') { // 首字符
// // 小写字符转换为大写字符
// arrCharEx[0] -= 32;
// }
//
// System.out.println("转换后的字符串为：" + String.valueOf(arrCharEx));
// 写法2-3
// char[] arrChar = str.toCharArray();
//
// // 从第1个字符到最后一个字符（先都拿出来判断），如果是大写字符，转换为小写字符，
// // 因为拿出来的是一个一个的char类型的元素，判断后发生变化的元素自身，再放入原数组中
// int i = 0;
// for (char item : arrChar) {
// if (item >= 'A' && item <= 'Z') {
// // 大写字符转换为小写字符
// item += 32;
// }
//
// arrChar[i] = item;
// i++;
// }
//
// // 首字符判断，如果是小写字符转换为大写字符
// if (arrChar[0] >= 'a' && arrChar[0] <= 'z') { // 首字符
// // 小写字符转换为大写字符
// arrChar[0] -= 32;
// }
//
// System.out.println("转换后的字符串为：" + String.valueOf(arrChar));
// 思路3：
// 1、得到字符串
// 2、首字符----->子字符串变为大写
// 3、其他字符----->子字符串变为小写
// 4、拼接两个子字符串
// String string1 = str.substring(0, 1).toUpperCase();
// String string2 = str.substring(1).toLowerCase();
// System.out.println("转换后的字符串为：" + string1.concat(string2));
// 思路4：（链式编程）
// 1、得到字符串
// 2、字符串全部变为小写
// 3、字符串首字符变成大写
// 下面两种写法等价
// System.out.println("转换后的字符串为：" + str.substring(0, 1).toUpperCase().concat(str.substring(1).toLowerCase()));
System.out.println("转换后的字符串为：" + str.toLowerCase().substring(0, 1).toUpperCase().concat(str.substring(1).toLowerCase()));
}
}
package cn.temptation;
public class Sample17 {
public static void main(String[] args) {
/*
* String类的常用成员方法：（具有替换功能）
* 1、String replace(char oldChar, char newChar) ：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
* 2、String replace(CharSequence target, CharSequence replacement) ：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
*/
String string1 = "luck";
System.out.println(string1.replace('l', 'f')); // fuck
System.out.println(string1); // luck
String string2 = "feel";
System.out.println(string2.replace('e', 'o')); // fool
String string3 = "food";
System.out.println(string3.replace('e', 'a')); // food
// 拿着第一个参数字符去查找，找到了就替换，找不到就不替换
System.out.println("--------------------------------------------------");
System.out.println(string1.replace("lu", "clo")); // clock
System.out.println(string1); // luck
// 注意：replace(...)方法替换后得到的是一个新的字符串，原字符串不变
}
}
package cn.temptation;
public class Sample18 {
public static void main(String[] args) {
/*
* String类的常用成员方法：（其他功能）
* 1、String trim() ：返回字符串的副本，忽略前导空白和尾部空白。
* 2、int compareTo(String anotherString) ：按字典顺序比较两个字符串。
* 3、int compareToIgnoreCase(String str) ：按字典顺序比较两个字符串，不考虑大小写。
*/
String string1 = " java temptation ";
System.out.println("string1:" + string1 + "，length：" + string1.length()); // string1: java temptation ，length：17
System.out.println("string1.trim():" + string1.trim() + "，length：" + string1.trim().length()); // string1.trim():java temptation，length：15
System.out.println(string1.trim() + " is good"); // java temptation is good
System.out.println("-----------------------------------------------");
String string2 = "java";
String string3 = "java";
String string4 = "php";
String string5 = "japan";
System.out.println(string2.compareTo(string3)); //
System.out.println(string2.compareTo(string4)); // -6 j - p
System.out.println(string2.compareTo(string5)); // 6 v - p
String string6 = "java";
String string7 = "ja";
String string8 = "jav";
String string9 = "j";
System.out.println(string6.compareTo(string7)); //
System.out.println(string6.compareTo(string8)); //
System.out.println(string6.compareTo(string9)); //
System.out.println("-----------------------------------------------");
String string10 = "java";
String string11 = "javA";
System.out.println(string10.compareTo(string11)); // 32 97 - 65
System.out.println(string10.compareToIgnoreCase(string11)); //
}
}
package cn.temptation;
public class Sample19 {
public static void main(String[] args) {
// 需求：把数组的内容按照一定的格式组成一个字符串
// 例如：int[] arr = { 3, 5, 7, 9 }; -----> 字符串"[3, 5, 7, 9]"
// 数组的内容（元素）的数据类型未知，考虑转换为Object类型
// int[] arr = { 3, 5, 7, 9 };
// double[] arr = { 3.14, 5.26, 7.38 };
boolean[] arr = { true, false, false, true };
// 转换为Object数组
Object[] arrObj = new Object[arr.length];
for (int i = 0; i < arr.length; i++) {
arrObj[i] = arr[i];
}
System.out.println(arrayToString(arrObj));
}
/**
* 数组转字符串
* @param arr
* @return
*/
public static String arrayToString(Object[] arr) {
String result = "[";
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
result += arr[i] + "]";
} else {
result += arr[i] + ",";
}
}
return result;
}
}
package cn.temptation;
import java.util.Scanner;
public class Sample20 {
public static void main(String[] args) {
// 需求：通过键盘录入一个字符串，实现其反转
// 例如："abcd" -----> "dcba"
String str = "";
System.out.println("输入一个字符串：");
Scanner input = new Scanner(System.in);
if (input.hasNextLine()) {
str = input.nextLine();
} else {
System.out.println("输入的格式不正确！");
}
input.close();
// 思路1：
// 1、获取录入的字符串
// 2、将其转换为字符数组
// 3、循环从字符数组的最后一个开始取出字符，再拼接为一个字符串输出
// 写法1：
// char[] arrChar = str.toCharArray();
// String strTemp = "";
// for (int i = arrChar.length - 1; i >= 0; i--) {
// strTemp += arrChar[i];
// }
// System.out.println("反转后，字符串为：" + strTemp);
// 思路2：
// 1、获取录入的字符串
// 2、通过charAt(...)取得每一个字符
// 3、通过反序拼接为一个字符串输出
// 写法2：
// String strTemp = "";
// for (int i = str.length() - 1; i >= 0; i--) {
// char temp = str.charAt(i);
// strTemp = strTemp.concat(str.valueOf(temp));
// }
// System.out.println("反转后，字符串为：" + strTemp);
// 思路3：
// 1、获取录入的字符串
// 2、将其转换为字符数组
// 3、首尾对调，第2个位置和倒数第2个位置对调,....直到中间
// 4、对调后的结果再转换为字符串输出
// 写法3：
char[] arrChar = str.toCharArray();
for (int i = 0; i < str.length() / 2; i++) {
// 对调
char temp = arrChar[i];
arrChar[i] = arrChar[str.length() - 1 - i];
arrChar[str.length() - 1 - i] = temp;
}
System.out.println("反转后，字符串为：" + String.valueOf(arrChar));
}
}
package cn.temptation;
public class Sample21 {
public static void main(String[] args) {
// 需求：从字符串"javagoodjavabetterjavabestjavaamazing"中统计"java"出现的次数
// String str = "javagoodjavabetterjavabestjavaamazing";
// String str = "javajavajava";
// String strTemp = "java";
String str = "lolol";
String strTemp = "lol";
// 声明出现次数变量
int apperCount = 0;
// 思路1：（反复使用indexOf方法和substring方法）
// 1、对原字符串使用indexOf(子字符串)：如果没有的话，返回-1
// 2、第1次出现："|java|goodjavabetterjavabestjavaamazing"，根据出现的位置做截取，形成新的字符串"goodjavabetterjavabestjavaamazing"
// 3、第2次出现："good|java|betterjavabestjavaamazing"，根据出现的位置做截取，形成新的字符串"betterjavabestjavaamazing"...
// 4、重复上述操作，直到返回-1
// 写法1：
// while (str.indexOf(strTemp) != -1) {
// // 找到一次子字符串，就自增一下
// apperCount++;
//
// // 以查找的字符串出现的索引位置 + 查找的字符串的长度 作为substring方法的beginIndex参数的值，用来做字符串的截取
// int beginIndex = str.indexOf(strTemp) + strTemp.length();
// str = str.substring(beginIndex);
// }
//
// System.out.println("原字符串中查找字符串：" + strTemp + "出现的次数为：" + apperCount);
// 思路2：（反复使用charAt）
// 1、反复使用charAt组合出j、a、v、a进行比较
// 2、有满足条件的做累加
// 写法2：
for (int i = 0; i < str.length() - strTemp.length() + 1; i++) {
// if (str.charAt(i) == 'j' && str.charAt(i + 1) == 'a' && str.charAt(i + 2) == 'v' && str.charAt(i + 3) == 'a') {
// apperCount++;
// }
// if (str.charAt(i) == 'l' && str.charAt(i + 1) == 'o' && str.charAt(i + 2) == 'l') {
// apperCount++;
// }
// 功能实现后，重新审视，觉得写的不太好，因为硬编码
// 另外还要思考一个问题：1、"javajavajava"；2、从"lolol"查找"lol"
// 变形1
// if (str.charAt(i + 0) == 'j') {
// if (str.charAt(i + 1) == 'a') {
// if (str.charAt(i + 2) == 'v') {
// if (str.charAt(i + 3) == 'a') {
// apperCount++;
// }
// }
// }
// }
// 变形2
// if (str.charAt(i + 0) == strTemp.charAt(0)) {
// if (str.charAt(i + 1) == strTemp.charAt(1)) {
// if (str.charAt(i + 2) == strTemp.charAt(2)) {
// if (str.charAt(i + 3) == strTemp.charAt(3)) {
// apperCount++;
// }
// }
// }
// }
// 变形3
// 声明判断标识
// boolean flag = true;
// if (str.charAt(i + 0) != strTemp.charAt(0)) {
// flag = false;
// }
// if (str.charAt(i + 1) != strTemp.charAt(1)) {
// flag = false;
// }
// if (str.charAt(i + 2) != strTemp.charAt(2)) {
// flag = false;
// }
// if (str.charAt(i + 3) != strTemp.charAt(3)) {
// flag = false;
// }
// if (flag) {
// apperCount++;
// }
// 变形4
boolean flag = true;
for (int j = 0; j < strTemp.length(); j++) {
if (str.charAt(i + j) != strTemp.charAt(j)) {
flag = false;
}
}
if (flag) {
apperCount++;
}
}
System.out.println("原字符串中查找字符串：" + strTemp + "出现的次数为：" + apperCount);
}
}
【原】Java学习笔记022 - 字符串的更多相关文章
- 【原】Java学习笔记023 - 字符串缓冲区_正则表达式
package cn.temptation; import java.util.Arrays; public class Sample01 { public static void main(Stri ...
- Java学习笔记之字符串常用方法
一.String关键字一些常用方法 1.构造方法: public String(); 空构造 public String(byte[] bytes);将字节数组转成字符串 public String ...
- 【java学习笔记】字符串和Date的转换
String dateVal = "1992-12-06 18:34:23"; SimpleDateFormat sdf = new SimpleDateFormat(" ...
- Java学习笔记4
Java学习笔记4 1. JDK.JRE和JVM分别是什么,区别是什么? 答: ①.JDK 是整个Java的核心,包括了Java运行环境.Java工具和Java基础类库. ②.JRE(Java Run ...
- java学习笔记16--I/O流和文件
本文地址:http://www.cnblogs.com/archimedes/p/java-study-note16.html,转载请注明源地址. IO(Input Output)流 IO流用来处理 ...
- java学习笔记13--反射机制与动态代理
本文地址:http://www.cnblogs.com/archimedes/p/java-study-note13.html,转载请注明源地址. Java的反射机制 在Java运行时环境中,对于任意 ...
- 0030 Java学习笔记-面向对象-垃圾回收、(强、软、弱、虚)引用
垃圾回收特点 垃圾:程序运行过程中,会为对象.数组等分配内存,运行过程中或结束后,这些对象可能就没用了,没有变量再指向它们,这时候,它们就成了垃圾,等着垃圾回收程序的回收再利用 Java的垃圾回收机制 ...
- 0025 Java学习笔记-面向对象-final修饰符、不可变类
final关键字可以用于何处 修饰类:该类不可被继承 修饰变量:该变量一经初始化就不能被重新赋值,即使该值跟初始化的值相同或者指向同一个对象,也不可以 类变量: 实例变量: 形参: 注意可以修饰形参 ...
- 《Java学习笔记(第8版)》学习指导
<Java学习笔记(第8版)>学习指导 目录 图书简况 学习指导 第一章 Java平台概论 第二章 从JDK到IDE 第三章 基础语法 第四章 认识对象 第五章 对象封装 第六章 继承与多 ...
随机推荐
- git入门笔记汇总——（廖雪峰博客git入门）
本文内容是对廖雪峰老师Git教程做的笔记,外加一些自己的学习心得,还抱着学以致用的心态来实践一番 如有显示错误 请移步本人github:git教程小结 Git学习笔记 Git简介 安装Git 创建版本 ...
- Kubernetes系列之理解K8s Service的几种模式
今天给大家介绍下k8s的service的几种访问模式. 概述 我们知道pod的ip不是固定的,是根据所在宿主机的docker0网卡生成的,每次重启,更新,调度等情况IP都会变,那pod与pod之间需要 ...
- Python内置函数(14)——delattr
英文文档: delattr(object, name) This is a relative of setattr(). The arguments are an object and a strin ...
- ReentrantLock 实现原理
使用 synchronize 来做同步处理时,锁的获取和释放都是隐式的,实现的原理是通过编译后加上不同的机器指令来实现. 而 ReentrantLock 就是一个普通的类,它是基于 AQS(Abstr ...
- 经典案例复盘——运维专家讲述如何实现K8S落地
经典案例复盘——运维专家讲述如何实现K8S落地 背景介绍 运满满自开始微服务改造以来,线上线下已有数千个微服务的 Java 实例在运行中.这些 Java 实例部署在数百台云服务器或虚机上,除少数访问量 ...
- 如何在 Intellij IDEA 更高效地将应用部署到容器服务 Kubernetes
前言 在之前的一篇文章中,我们介绍了 如何将一个本地的 Java 应用程序直接部署到阿里云 ECS ,有不少读者反馈,如果目前已经在使用阿里云容器服务 Kubernetes 了,那该如何配合这个插件部 ...
- Spring Boot (十)：邮件服务
Spring Boot 仍然在狂速发展,才几个多月没有关注,现在看官网已经到 2.1.0.RELEASE 版本了.准备慢慢在写写 Spring Boot 相关的文章,本篇文章使用 Spring Boo ...
- 适配器模式 adapter 结构型 设计模式(九)
现实世界中的适配器模型 先来看下来几个图片,截图自淘宝 上图为港版的插头与港版的插座 上图为插座适配器卖家的描述图 上图为适配后的结果 现实世界中适配器模式 角色分类 这就是适配器模式在电 ...
- .NET WebAPI 利用特性捕捉异常
声明:本方式及代码只使用与.NET Web API. 先创建类继承ExceptionFilterAttribute类型并复写OnException方法. 代码如下: using System; usi ...
- Linux CentOS开机启动项设置命令：chkconfig
1.开机启动+++crontab 定时执行(定时执行可参考:https://www.cnblogs.com/prefectjava/p/9399552.html)可实现自动化运行的目的,简化了维护人员 ...