/**
 * 1.1 ts 如何声明一个boolean, number, string类型的值
 */
// 在js中，定义 isFlag 为true, 但是后面还可以重新给它赋值为字符串，而ts中就不行，同理，声明number, string 也一样
let bool: boolean = true;
// 会报错：不能将类型“"str"”分配给类型“boolean”。
// isFlag = "str"
let str: string = "a";
// 会报错：不能将类型“1”分配给类型“string”。
// str = 1
let num: number = 1;
// 会报错：不能将类型“"a"”分配给类型“number”。
// num = "a"
/**
 *
 *
 *
 * 1.2 ts 如何声明一个 undefined, null 类型的值
 */
let u: undefined = undefined;
let n: null = null;
/**
 *
 *
 *
 * 1.3 ts 如何声明一个数组
 */
// 方式一：声明一个每一项只能是string类型的数组。在元素类型后面接上[]，表示由此类型元素组成一个数组
let arr1: string[] = ["a", "b"];
// 方式二：使用数组泛型，Array<元素类型>
let arr2: Array<string> = ["a", "b"];
// 方式三：利用接口: ts的核心原则是对值所具有的结构进行类型检查，接口的作用就是为这些类型命名和为你的代码或第三方代码定义契约
interface NumberArray {
  // 这个接口表示：只要索引的类型是number，那么值的类型必须是number
  [index: number]: number;
}
let arr3: NumberArray = [1, 2, 3];
// 数组里想放对象？
let arr4: Array<object> = [{ a: "1" }, { b: "2" }];
// 数组里想放多种数据类型？ 用 | 隔开就好
let arr5: Array<string | number> = ["a", 1];
// 数组里想放任意类型？
let arr6: Array<any> = ["a", 1, true, { a: 1 }, [1, 2]];
/**
 *
 *
 *
 * 1.4 ts 如何声明一个对象
 */
// 利用接口
interface OA {
  name: string; // 表示对象要有name属性, 值是string类型
  age?: number; // ? 表示age属性可以有也可以没有, 值是number类型
  readonly id: number; // readonly 表示 id 属性只可读，不可修改
}
let obj1: OA = { name: "obj1", id: 1 };
let obj2: OA = { name: "obj2", age: 18, id: 2 };
// 这种情况下name 和 id 属性必须要，age属性可要可不要，但是除了这三种属性外，其它的属性都不准出现
// let obj3:OA = {a: 1} // 会报错
// 有时候还是希望一个对象允许有任意的属性怎么办？
interface OB {
  name: string;
  age?: number;
  [propName: string]: any;
}
let obj4: OB = { name: "a" };
let obj5: OB = { name: "a", age: 1 };
let obj6: OB = { name: "a", age: 1, other1: 2, other2: "2", other3: { a: 1 } };
/**
 *
 *
 *
 * 1.5 ts 如何声明一个函数
 */
// 一： :void 表示函数没有返回值
function fn2(x: number): void {
  console.log(x);
}
// 二： 这里表示sum 函数接收两个参数(多了少了都不行), 参数类型是 number, 返回值也是number
function fn1(x: number, y: number): number {
  return x + y;
}
// 三： 同样也可以用?来表示可选参数，但是可选参数只能放到最后面
function fn3(x: number, y?: number): number {
  if (y) {
    return x + y;
  }
  return x;
}
// 四：ts 怎么表示默认参数
function fn41(x: number, y: number = 1): number {
  return x + y;
}
// 传值的时候，默认参数可以不传
fn41(1);
fn41(1, 2);
// 默认参数不像可选参数必须放后面，它也可以放前面, 但是还是推荐放后面去
function fn42(x: number = 1, y: number): number {
  return x + y;
}
// 传值的时候，默认参数可以不传，但是如果默认参数不放后面，这样传值感觉很怪
fn42(undefined, 2);
// 五：ts表示剩余参数。利用扩展运算符
function fn52(array: any[], ...items: any[]) {
  items.forEach(item => {
    array.push(item)
  })
}
// 六：箭头函数
// es6 箭头函数：没有参数的时候
// let fn61 = () => {}

// es6 箭头函数：一个参数的时候，可以不用圆括号
// let fn62 = arg => {
//   console.log(arg)
// }

// es6 箭头函数：多个参数的时候，如果致谢一行的话，不用大括号和return
// let fn63 = (arg1, arg2) => arg1 + arg2;

// es6 箭头函数：多个参数并且换行的时候，需要写大括号和return
// let fn64 = (arg1, arg2) => {
//   return arg1 + arg2
// }

// es6 箭头函数：返回一个对象，必须在对象外面加上圆括号
// let fn65 = (arg1, arg2) => ({a: arg1, b:arg2})

// es6 上例中一般会不改名字，同名可以缩写成这样
// let fn66 = (arg1, arg2) => ({
//   arg1,
//   arg2
// })

 
 
CSDN比较少上传文章，欢迎关注我的掘金账号：杨灿就是杨火山，一起学习，一起交流~
 
 
简单快速上手ts的学习路径：
 
 
一、熟悉掌握熟悉的强类型定义，初步学习编写强类型代码。
 
 
 
学习ts的声明变量类型，能够初步编写强类型代码；
 
 
学习ts的接口,进一步强定义对象的丰富属性；
 
 
学习ts的函数声明和实现定义，强类型化你的js函数；
 
 
 
二、灵活面对类型转换，类型报错，类型文件的声明和引入，灵活编写强类型代码。
 
 
学习ts的类型断言（解释型类型转换）；
学习ts的泛型，更灵活的面对多可能性类型参数；
学习ts的类型声明文件，全局定义；
 
 
ts在线运行练习网站：https://www.tslang.cn/play/index.html
 
 
一、ts简介
 
1.什么是TypeScript(TS)？
 
TypeScript简称TS
 TS和JS之间的关系其实就是Less/Sass和CSS之间的关系
 就像Less/Sass是对CSS进行扩展一样, TS也是对JS进行扩展
 就像Less/Sass最终会转换成CSS一样, 我们编写好的TS代码最终也会换成JS
 
2.为什么需要TypeScript?
 
因为JavaScript是弱类型, 很多错误只有在运行时才会被发现
 而TypeScript是强类型, 它提供了一套静态检测机制,如何我们编码事中途变换变量的类型，ts就会在报错，帮助我们在编码时发现错误。
 
 
 
Ts为帮助js弥补在大型项目中的缺陷而生。
 
 
3.TypeScript特点
 
支持最新的JavaScript新特特性
支持代码静态检查
支持诸如C,C++,Java,Go等后端语言中的特性
 (枚举、泛型、类型转换、命名空间、声明文件、类、接口等)
 
二、ts中的类型声明
 
TypeScript支持与JavaScript几乎相同的数据类型，此外还提供了实用的枚举类型、元祖方便我们使用
 
1.boolean、number、string简单类型的变量声明
 
布尔类型 boolean
 
let val2:boolean;
val2 = true;
// val2 = 1; // 会报错
console.log(val2);
 
数值类型 number
 
let val1:number; // 定义了一个名称叫做val1的变量, 这个变量中将来只能存储数值类型的数据
val1 = 123;
// val1 = "123"; // 会报错
// 注意点: 其它的用法和JS一样
// val1 = 0x11;
// val1 = 0o11;
// val1 = 0b11;
console.log(val1);
 
字符串类型 string
 
let val3:string;
val3 = "123";
val3 = `val1=${val1}, val2==${val2}`;
console.log(val3);
 
2.数组和元祖类型的变量声明
 
数组类型
 
(1)整个数组数据类型一致的情况
 
方式一: Array < number >
 
// 需求: 要求定义一个数组, 这个数组中将来只能存储数值类型的数据
let arr1:Array<number>; // 表示定义了一个名称叫做arr1的数组, 这个数组中将来只能够存储数值类型的数据
arr1 = [1, 3, 5];
// arr1 = ['a', 3, 5]; // 报错
console.log(arr1);
 
方式二: string[ ] （建议）
 
// 需求: 要求定义一个数组, 这个数组中将来只能存储字符串类型的数据
let arr2:string[]; // 表示定义了一个名称叫做arr2的数组, 这个数组中将来只能够存储字符串类型的数据
arr2 = ['a', 'b', 'c'];
// arr2 = [1, 'b', 'c']; // 报错
console.log(arr2);
 
(2)整个数组数据类型不一致的情况
 
联合类型声明数组 (number | string)[ ]
 
let arr3:(number | string)[];
// 表示定义了一个名称叫做arr3的数组, 这个数组中将来既可以存储数值类型的数据, 也可以存储字符串类型的数据
arr3 = [1, 'b', 2, 'c'];
// arr3 = [1, 'b', 2, 'c', false]; // 报错
console.log(arr3);
 
(3) 自由任意类型元素的数组
 
any[ ]
 
let arr4:any[]; // 表示定义了一个名称叫做arr4的数组, 这个数组中将来可以存储任意类型的数据
arr4 = [1, 'b', false];
console.log(arr4);
 
(4) 严格限制类型和长度的元祖数组
 
元祖类型 [string, number, boolean]
 
 
 
TS中的元祖类型其实就是数组类型的扩展,元祖用于保存定长定数据类型的数据
 
 
let arr5:[string, number, boolean]; 

// 表示定义了一个名称叫做arr5的元祖, 这个元祖中将来可以存储3个元素, 第一个元素必须是字符串类型, 第二个元素必须是数字类型, 第三个元素必须是布尔类型

arr5 = ['a', 1, true];
// arr5 = ['a', 1, true, false]; // 超过指定的长度会报错
arr5 = ['a', 1, true];
console.log(arr5);
 
3.enum枚举类型
 
 
 
枚举用于表示固定的几个取值,例如: 一年只有四季、人的性别只能是男或者女。
 枚举类型是TS为JS扩展的一种类型, 在原生的JS中是没有枚举类型的。
 
 
定义：
 

enum Gender{
    Male=0,
    Femal=1
}

// 简写
enum Gender{
    Male,
    Femal
}

// 定义了一个名称叫做Gender的枚举类型, 这个枚举类型的取值有两个, 分别是Male和Femal
 
使用：
 
let val:Gender; 
// 定义了一个名称叫做val的变量, 这个变量中只能保存Male或者Femal
val = Gender.Male;
val = Gender.Femal;
// val = 'nan'; // 报错
// val  = false;// 报错


// 注意点: TS中的枚举底层实现的本质其实就是数值类型, 所以赋值一个数值不会报错
// val = 666; // 不会报错
// console.log(Gender.Male); // 0
// console.log(Gender.Femal);// 1


// 注意点: TS中的枚举类型的取值, 默认是从上至下从0开始递增的
//         虽然默认是从0开始递增的, 但是我们也可以手动的指定枚举的取值的值
// 注意点: 如果手动指定了前面枚举值的取值, 那么后面枚举值的取值会根据前面的值来递增
// console.log(Gender.Male); // 6
// console.log(Gender.Femal);// 7

// 注意点: 如果手动指定了后面枚举值的取值, 那么前面枚举值的取值不会受到影响
// console.log(Gender.Male); // 0
// console.log(Gender.Femal);// 6

// 注意点: 我们还可以同时修改多个枚举值的取值, 如果同时修改了多个, 那么修改的是什么最后就是什么
// console.log(Gender.Male); // 8
// console.log(Gender.Femal);// 6

 
// 我们可以通过枚举值拿到它对应的数据
console.log(Gender.Male); // 0
// 我们还可以通过它对应的数据拿到它的枚举值
console.log(Gender[0]); // Male
 
探究底层实现原理
 
var Gender;
(function (Gender) {
 // Gender[key] = value;
    Gender[Gender["Male"] = 0] = "Male";
    Gender[Gender["Femal"] = 1] = "Femal";
})(Gender || (Gender = {}));

// Gender[Gender["Male"] = 0] = "Male" 相当于 Gender["Male"] = 0;Gender[0] = "Male";

let Gender = {};
Gender["Male"] = 0;
Gender[0] = "Male";
Gender["Femal"] = 1;
Gender[1] = "Femal";
 
4.any 任意类型
 
any表示任意类型, 当我们不清楚某个值的具体类型的时候我们就可以使用any，任何数据类型的值都可以赋值给any类型
 
一般用于定义一些通用性比较强的变量, 或者用于保存从其它框架中获取的不确定类型的值
 
 
 
注意不要过多使用any，因为什么都是any那ts就变成js了
 
 
let value:any; // 定义了一个可以保存任意类型数据的变量
value = 123;
value = "abc";
value = true;
value = [1, 3, 5];
 
5.void类型
 
void与any正好相反, 表示没有任何类型, 一般用于函数返回值。在TS中只有null和undefined可以赋值给void类型
 
function test():void {
    console.log("hello world");
}
test();

let value:void; // 定义了一个不可以保存任意类型数据的变量, 只能保存null和undefined
// value = 123; // 报错
// value = "abc";// 报错
// value = true;// 报错
// 注意点: null和undefined是所有类型的子类型, 所以我们可以将null和undefined赋值给任意类型
// value = null; // 不会报错
value = undefined;// 不会报错
 
6.never类型
 
表示的是那些永不存在的值的类型,一般用于抛出异常或根本不可能有返回值的函数。
 
// function demo():never {
//     throw new Error('报错了');
// }
// demo();

// function demo2():never {
//     while (true){}
// }
// demo2();
 
7.Object对象类型
 
let obj:object; // 定义了一个只能保存对象的变量
// obj = 1;
// obj = "123";
// obj = true;
obj = {name:'lnj', age:33};
console.log(obj);
 
 
 
如何表示一个具体的对象数据结构呢？
 答案：可以使用ts的接口,在后续文章中会详细介绍。
 
 
8. 接口interface类型
 
（1）什么是接口类型?
 
 
 
和number,string,boolean,enum这些数据类型一样,接口也是一种类型, 也是用来约束使用者的。
 
 
（2）定义和使用
 
// 需求: 要求定义一个函数输出一个人完整的姓名, 这个人的姓必须是字符串, 这个人的名也必须是一个字符

interface FullName{
    firstName:string
    lastName:string
}

let obj = {
    firstName:'Jonathan',
    lastName:'Lee'
    // lastName:18 会报错
};

//{firstName, lastName}使用了解构赋值
function say({firstName, lastName}:FullName):void {
    console.log(`我的姓名是:${firstName}_${lastName}`);
}
say(obj);

 
ts入门笔记目录：
 
TS入门笔记1——TS的类型声明
 
TS入门笔记2——TS接口进阶详解
 
TS入门笔记3——TS中的函数声明
 
TS入门笔记4——TS的类型断言（解释型类型转换）
 
TS入门笔记5——TS的泛型
 
TS入门笔记6——ts中的声明文件、模块、命名空间
 
 
 
 
记录知识，传递快乐~
 
 
如果我的总结对你有帮助，请给我点个赞，你的鼓励是我持续记录的一大动力~
 
 
如果文章中有错误，请多包涵，欢迎在评论中指出~
 

 
字符串
 
参考资料：《Java从入门到精通》/明日科技编著. 4版. 北京：清华大学出版社，2016
 
在Java语言中，字符串作为String类的实例来处理。以对象的方式来处理字符串，使字符串更加灵活、方便。
 
一、String类
 
前面介绍了，char类型变量只能表示单个字符，不能表示由多个字符连接而成的字符串。在java语言中将字符串作为对象处理，可以通过java.lang包中的String类来创建字符串对象。
 
1、声明字符串
 
在Java语言中，字符串必须包含在一对双引号("")中。声明一个字符串的方式如下：
 
String str; //声明字符串
 
String str1 = "hello"; //声明字符串，并赋初值
 
注意：声明字符串变量必须经过初始化才能使用，否则编译器会报出“变量未经过初始化”。
 
2、创建字符串
 
Java语言中将字符串作为对象来处理，因此可以像创建对象一样来创建字符串对象。
 
(1)String(char a[])
 
用一个字符数组a创建String对象
 
char a[] = {‘a‘,‘b‘,‘c‘,‘d‘}; 等价于
 
String s = new String(a); -----------> String s = new String("abcd");
 
(2)String(char a[], int offset, int length)
 
提取字符数组a中的一部分创建一个字符串对象。
 
参数offset表示：开始截取字符串的位置。
 
参数length表示：截取字符串的长度。
 
char a[] = {‘s‘,‘t‘,‘u‘,‘d‘,‘e‘,‘n‘,‘t‘}; 等价于
 
String s = new String(a,2,4); ---------> String s = new String("uden");
 
除了上面的两种方式，还可以通过引用字符串常量来创建字符串变量。
 
String str1, str2;
 
str1 = "hello world";
 
str2 = "hello world";
 
此时，str1和str2引用相同的字符串变量，因此具有相同的实体。
 
public class StringTest {
 
public static void main(String[] args) {
 
String s = new String("hello");
 
String s1 = "hello";
 
String s2 = "hello";
 
String s3 = new String("hello");
 
System.out.println("s=s1? " + (s == s1));
 
System.out.println("s1=s2? " + (s1 == s2));
 
System.out.println("s=s3? " + (s == s3));
 
}
 
}
 
输出结果：
 
s=s1? false
 
s1=s2? true
 
s=s3? false
 
3、连接字符串
 
可以对多个字符串进行连接，也可以使字符串与其他数据类型进行连接。
 
使用“+”运算符可以实现多个字符串的连接。
 
public class StringJoin {
 
public static void main(String[] args) {
 
String s1 = new String("hello");
 
String s2 = new String("world");
 
String s3 = s1 + " " + s2;
 
System.out.println(s3); //输出hello world
 
}
 
}
 
字符串同其他基本数据类型进行连接时，会自动调用toString()方法，将这些数据直接转换成字符串。
 
public class ToString {
 
public static void main(String[] args) {
 
int num = 10;
 
float f1 = 2.34f;
 
String s1 = num + " " + f1;
 
System.out.println(s1);
 
}
 
}
 
三、获取字符串信息
 
(1)获取字符串长度
 
使用String类的length()方法可以获取声明的字符串对象的长度。
 
String str = "hello world";
 
System.out.println( str.length() ); //输出11
 
注意：字符串的长度包括字符串中的空格。
 
(2)字符串查找
 
String类提供了两种查找字符串的方法，即indexOf()和lastIndexOf()方法。
 
indexOf()方法返回的是搜索的字符或字符串首次出现的位置。
 
lastIndexOf()方法返回的是搜索的字符或字符串最后一次出现的位置。
 
String str = "hello world";
 
System.out.println( str.indexOf("o") ); //输出4
 
System.out.println( str.lastIndexOf("l") ); //输出9
 
注意：计算机中String对象是数组表示的，字符串的下标从0开始。
 
说明：如果lastIndexOf()方法中的参数为空字符串""(注意没有空格)，则返回字符串的长度。
 
(3)获取指定索引位置的字符
 
使用charAt()方法可以将指定索引位置的字符返回。
 
String str = "hello world";
 
char c = str.charAt(6);
 
System.out.println( c ); //输出w
 
四、字符串操作
 
(1)获取子字符串
 
通过String类的substring()方法可以对字符串进行截取。这些方法的共同点就是利用字符串的下标进行截取。
 
substring(int beginIndex)
 
返回从指定的索引位置开始截取至该字符串的结尾。
 
String str = "hello world";
 
String substr = str.substring(3);
 
System.out.println(substr); //输出lo world
 
substring(int beginIndex, int endIndex)
 
返回从指定的索引位置开始截取至指定的索引位置结束的字符串。
 
String str = "hello world";
 
String substr = str.substring(3,9);
 
System.out.println(substr); //输出lo wor
 
(2)去空格
 
trim()方法返回字符串的副本，忽略前导空格和尾部空格。
 
String str = " hello world ";
 
String substr = str.trim();
 
System.out.println(substr);
 
输出结果：
 
hello world
 
注意：中间的空格保留
 
(3)字符串替换
 
replace()方法可实现将指定的字符或字符串替换成新的字符或字符串。格式如下：
 
replace(char oldChar, char newChar)
 
replace()方法返回一个新的字符串。
 
如果要替换的字符oldChar在原字符串中反复出现，replace()方法会将所有oldChar全部替换成newChar。
 
oldChar必须和原字符串中的字符大小写一致。
 
String str = "hello world";
 
String substr = str.replace(‘l‘,‘L‘);
 
System.out.println(substr);
 
输出结果：
 
heLLo worLd
 
(4)判断字符串的开头与结尾
 
startsWith()
 
该方法用于判断字符串对象的前缀是否为参数指定的字符串，返回值为boolean类型。
 
String str = "hello world";
 
boolean bool1 = str.startsWith("he");
 
boolean bool2 = str.startsWith("hE");
 
System.out.println(bool1); //输出true
 
System.out.println(bool2); //输出false
 
endsWith()
 
该方法用于判断当前字符串是否为以指定的子字符串结束，返回值为boolean型。
 
String str = "hello world";
 
boolean bool1 = str.endsWith("ld");
 
boolean bool2 = str.endsWith("Ld");
 
System.out.println(bool1); //输出true
 
System.out.println(bool2); //输出false
 
(5)判断字符串是否相等
 
对字符串对象的比较不能简单地使用比较运算符“==”，因为比较运算符比较的是两个字符串的内存地址是否相同。即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回false。
 
String str1 = "i love java";
 
String str2 = "i love java";
 
System.out.println(str1 == str2) //输出true
 
String str3 = new String("i love java");
 
String str4 = new String("i love java");
 
System.out.println(str3 == str4); //输出false
 
因此，要比较两个字符串的内容是否相等，应该使用equals()和equalsIgnoreCase()方法。
 
equals()方法
 
该方法比较两个字符串是否具有相同的字符和长度，结果返回boolean类型。注意：进行字符比较是区分大小写。
 
equalsIgnoreCase()方法
 
该方法和equals()类似，但是不区分大小写。
 
String str1 = "i love java";
 
String str2 = "i love java";
 
String str3 = "I LOVE JAVA";
 
boolean res1 = str1.equals(str2);
 
boolean res2 = str1.equals(str3);
 
boolean res3 = str1.equalsIgnoreCase(str3);
 
System.out.println(res1); //返回true
 
System.out.println(res2); //返回false
 
System.out.println(res3); //返回true
 
(6)按字典顺序比较两个字符串
 
compareTo()方法是按照字典顺序比较两个字符串，该比较基于字符串中各个字符的Unicode值。
 
如果按照字典顺序，String对象位于参数字符串之前，则比较结果是一个负整数。
 
如果按照字典顺序，String对象位于参数字符串之后，则比较结果是一个正整数。
 
如果这两个字符串相等，则结果为0。
 
String str4 = new String("bb");
 
String str5 = new String("ac")
 
int res = str4.compareTo(str5)
 
System.out.println(res); //输出1
 
注意：
 
先比较第一位字符，若在之前，则返回-1；若在之后，则返回1；
 
若第一位字符相同，则比较第二位字符，以此类推。
 
如果所有字符相同，则返回0。
 
(7)字母大小写转换
 
toLowerCase()方法
 
将字符串中的所有字母转换为小写字母。
 
toUpperCase()方法
 
将字符串中的所有字母转换为大写字母。
 
String str6 = "I Love Java"
 
String str7 = str6.toLowerCase();
 
String str8 = str6.toUpperCase()
 
System.out.println(str7);
 
System.out.println(str8);
 
输出结果：
 
i love java
 
I LOVE JAVA
 
(8)字符串分割
 
split()方法可以使字符串按照指定的分割符或字符串对内容进行分割，并将分割后的结果存放在字符串数组中。split()方法提供了两种字符串分割形式。
 
split ( String sign )
 
其中，sign为字符串的分割符，也可以是正则表达式。如果想定义多个分割符，可以使用“|”符号。例如，“,|?”表示使用“,”和“?”进行分割。
 
String str6 = "Do you Love Java?Yes";
 
String[] a = str6.split(" |\?")
 
//定义空格和问号作为分割符，问号要作转义
 
for(int i=0; i
 
System.out.println(a[i]);
 
}
 
输出结果：
 
Do
 
you
 
Love
 
Java
 
Yes
 
五、格式化字符串
 
String类的静态format()方法用于创建格式化的字符串。format()有两种重载的方式：
 
format ( String format, Object...args )
 
format ( Local 1, String format, Object...args )
 
1、日期格式化
 
import java.util.Date;
 
public class Format {
 
public static void main(String[] args) {
 
Date date = new Date();
 
String day = String.format("%te",date);
 
String year = String.format("%tY",date);
 
String mouth = String.format("%tm",date);
 
System.out.println(year + "-" + mouth + "-" + day);
 
} //输出2020-05-4
 
}
 
其中，"%te、%tY、%tm是转换符。
 
2、时间格式化
 
import java.util.Date;
 
public class Format {
 
public static void main(String[] args) {
 
Date date = new Date();
 
String day = String.format("%te",date);
 
String year = String.format("%tY",date);
 
String mouth = String.format("%tm",date);
 
String hour = String.format("%tH",date);
 
String minute = String.format("%tM",date);
 
String second = String.format("%tS",date);
 
System.out.println("当前时间：" + year + "-" + mouth + "-" + day + " " + hour + ":" + minute + ":" + second);
 
} //输出：当前时间：2020-05-4 20:19:09
 
}
 
3、常见的日期时间格式化组合
 
import java.util.Date;
 
public class Format {
 
public static void main(String[] args) {
 
Date date = new Date();
 
String time = String.format("%tT",date);
 
String year = String.format("%tF",date);
 
System.out.println("当前时间：" + year + " " + time);
 
} //输出：当前时间：2020-05-04 20:23:09
 
}
 
六、正则表达式
 
正则表达式通常被用于判断语句中，用来检测某一字符串是否满足某一格式。
 
七、字符串生成器
 
创建成功的字符串对象，其长度是固定的，内容不能被改变和编译。虽然使用“+”可以达到附加新字符或字符串的目的，但“+”会产生一个新的String实例，会在内存中创建新的字符串对象。如果重复对字符串进行修改，将极大地增加系统开销。使用可变地字符序列类StringBuilder类，可以大大提高频繁增加字符串地效率。
 
public class Jerque {
 
public static void main(String[] args) {
 
String str = "";
 
//记录开始时间
 
long startTime = System.currentTimeMillis();
 
for(int i=0; i<10000; i++){
 
str = str + i;
 
}
 
//记录结束时间
 
long endTime = System.currentTimeMillis();
 
long time = endTime - startTime;
 
System.out.println("String消耗时间：" + time);
 
StringBuilder builder = new StringBuilder("");
 
//记录开始时间
 
startTime = System.currentTimeMillis();
 
for(int i=0; i<10000; i++){
 
builder.append(i);
 
}
 
//记录结束时间
 
endTime = System.currentTimeMillis();
 
time = endTime - startTime;
 
System.out.println("StringBuilder消耗时间：" + time);
 
}
 
}
 
输出结果：
 
String消耗时间：300
 
StringBuilder消耗时间：0
 
StringBuilder类的常用方法如下：
 
append ( )
 
该方法用于向字符串生成器中追加内容，可以实现接受任何类型的数据。
 
insert ( )
 
该方法用于向字符串生成器的指定位置插入数据内容，可以接受int、float、char和boolean等数据类型或其他对象。
 
public class ToString {
 
public static void main(String[] args) {
 
StringBuilder builder = new StringBuilder("hello");
 
builder.insert(5," world");
 
System.out.println( builder.toString() );
 
//输出：hello world
 
}
 
}
 
delete ( int start, int end )
 
该方法删除字符串中指定的字符，从指定的start位置开始，直到end-1的位置。如果start等于end，则不发生任何改变。
 
public class ToString {
 
public static void main(String[] args) {
 
StringBuilder builder = new StringBuilder("hello world");
 
builder.delete(2,5);
 
System.out.println( builder.toString() );
 
//输出：he world
 
}
 
}

//字符串替换
string replace_all_distinct(string&   str, const   string&   old_value, const   string&   new_value)
{
	for (string::size_type pos(0); pos != string::npos; pos += new_value.length()) {
		if ((pos = str.find(old_value, pos)) != string::npos)
			str.replace(pos, old_value.length(), new_value);    //用new_value替换str中从pos开始（包括0）的old_value.length()个字符的子串
		else   break;
	}
	return  str;
}

 
//字符串替换
//int StrReplace(char strRes[], char from[], char to[]) {
//	int i, flag = 0;
//	char *p, *q, *ts;
//	for (i = 0; strRes[i]; ++i) {
//		if (strRes[i] == from[0]) {
//			p = strRes + i;                         //p为从替换的第一个字符开始后面所有的字符串，例如you are cute,are换成is，p为are cute
//													//printf(p);
//			q = from;
//			while (*q && (*p++ == *q++));
//			if (*q == '\0') {
//				ts = (char *)malloc(strlen(strRes) + 1);  //malloc函数用于向操作系统申请内存，声明在stdlib.h中, 
//														  //并将指针转换为char *类型赋值给ts，申请的大小为(strlen(strRes) + 1)。
//				strcpy(ts, p);                           //字符串复制,p为cute
//				strRes[i] = '\0';
//				strcat(strRes, to);                  //字符串链接,strRes为"you ",设strRes[i] = '\0';即是把后面的截断
//				strcat(strRes, ts);
//				//	printf("strRes2%s\n", strRes);
//				free(ts);
//				flag = 1;
//			}
//		}
//	}
//	return flag;
//}