黑马程序员之 ---- API中的常用类

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

API的概述

API(Application Programming Interface)

应用程序编程接口

编写一个机器人程序去控制机器人踢足球，程序就需要向机器人发出向前跑、向后跑、射门、抢球等各种命令，没有编过程序的人很难想象这样的程序如何编写。但是对于有经验的开发人员来说，知道机器人厂商一定会提供一些用于控制机器人的Java类，这些类中定义好了操作机器人各种动作的方法。其实，这些Java类就是机器人厂商提供给应用程序编程的接口，大家把这些类称为Xxx Robot API。本章涉及的Java API指的就是JDK中提供的各种功能的Java类。

Object: 所有类的父类， 超类，祖宗类

方法：

protected Object clone() 创建并返回此对象的一个副本

protected void finalize() 释放内容中的垃圾对象

public int hashCode() 返回该对象的哈希码值

public final Class getClass()返回此 Object 的运行时类

public boolean equals(Object obj)默认比较两个对象的哈希码值

public String toString()返回该对象的字符串表示

包名类名 + @ + 哈希码值的十六进制

三道面试题：

面试题1：

String s = new String(“hello”)和String s = “hello”;的区别?

有区别。

String s = new String(“hello”) 创建了两个对象，一个是new String()对象， 另一个是"hello"对象

String s = "hello"; 创建了一个对象， "hello"对象

面试题2：

String s1 = new String("hello");

String s2 = new String("hello");

System.out.println(s1==s2); //false

System.out.println(s1.equals(s2)); //true

String s3 = new String("hello");

String s4 = "hello";

System.out.println(s3==s4); //false

System.out.println(s3.equals(s4)); //true

String s5 = "hello";

String s6 = "hello";

System.out.println(s5==s6); //true

System.out.println(s5.equals(s6)); // true

面试题3

String s1 = "hello";

String s2 = "world";

String s3 = "helloworld";

System.out.println(s3 == s1+s2 ); // false

System.out.println(s3 == "hello" + "world");//true

System.out.println(s3.equals(s1+s2)); //true

String: 字符串类，封装了与字符串相关的所有操作

判断功能：

boolean equals(Object obj)：判断两个字符串内容是否相等，重写了Object类中的equals方法

boolean equalsIgnoreCase(String str):判断两个字符串内容是否相等,忽略大小写

boolean contains(String str): 判断当前字符串 是否包含 给定的字符串

boolean startsWith(String str): 判断当前字符串 是否以给定的字符串开头

boolean endsWith(String str) : 判断当前字符串 是否以给定的字符串结束

boolean isEmpty(): 判断当前字符串是否为 空字符串 , " " 空字符串

例题： 模拟登录,给三次机会,并提示还有几次

public class StringMethodTest {

public static void main(String[] args) {

// 1：已有一个QQ

String username = "123456";

String password = "itcast";

for (int i = 2; i >= 0; i--) {

// 2：登录(键盘输入用户名、密码)

Scanner sc = new Scanner(System.in);

System.out.println("请输入用户名:");

String enterName = sc.nextLine();

System.out.println("请输入密码:");

String enterPassword = sc.nextLine();

//3：调用登录功能

//判断键盘输入用户名、密码 是否 已有QQ匹配

if (username.equals(enterName) && password.equals(enterPassword)) {

//登录成功

System.out.println("欢迎你，来到Java的天堂");

break;//跳出循环

} else {

if (i == 0) {

System.out.println("账号已锁定，请找管理员联系");

} else {

//对不起，用户名或密码错误，请重新输入

System.out.println("对不起，用户名或密码错误，请重新输入,还有"+ i +"次机会");

}

}

}

}

}

String类中的获取功能：

int length() ： 获取当前字符串的长度

char charAt(int index): 获取当前字符串中，给定索引位置对应的字符

int indexOf(int ch) : 获取当前字符串中， 给定的字符第一次出现的位置，没有找到返回-1

int indexOf(String str): 获取当前字符串中， 给定的字符串第一次出现的位置，没有找到返回-1

int indexOf(int ch,int fromIndex)从指定的位置开始， 获取当前字符串中， 给定的字符第一次出现的位置，没有找到返回-1

int indexOf(String str,int fromIndex)从指定的位置开始,获取当前字符串中， 给定的字符串第一次出现的位置，没有找到返回-1

String substring(int start) 从指定的位置开始，截取当前字符串到末尾，返回一个新的字符串

String substring(int start,int end)从指定位置开始，到指定位置结束，截取当前字符串，返回一个新的字符串

注意：substring(int start,int end) 包含起始位置字符，不包含结束位置字符

例题：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)

public class StringMethodTest2 {

public static void main(String[] args) {

//1： 键盘输入字符串

Scanner sc = new Scanner(System.in);

System.out.println("请输入字符串：");

String str = sc.nextLine();

//2: 定义变量，大写个数，小写个数，数字个数

int BigCount = 0;

int SmallCount = 0;

int NumberCount = 0;

//3: 遍历字符串

for (int i = 0; i < str.length(); i++) {

//a:获取每一个字符 ch

char ch = str.charAt(i);

//b:判断当前字符的类型

if ( ch>='A' && ch <= 'Z') {

//大写个数++

BigCount++;

} else if (ch>='a' && ch <='z') {

//小写个数++

SmallCount++;

} else if ( ch>='0' && ch <='9') {

//数字个数++

NumberCount++;

}

}

//4: 打印

System.out.println("大写字符： " + BigCount );

System.out.println("小写字符： " + SmallCount );

System.out.println("数字字符： " + NumberCount );

}

}

String类的转换功能：

byte[] getBytes() 把当前字符串 转换成 字节数组

char[] toCharArray() 把当前字符串转换成 字符数组

static String valueOf(char[] chs) 静态方法，把给定的字符数组 转换成字符串

static String valueOf(int i) 静态方法，把基本数据类型 转换成 字符串

String toLowerCase() 把当前字符串全部转换为 小写字母

String toUpperCase() 把当前字符串全部转换为 大写字母

String concat(String str) 把当前字符串 与 给定的字符串进行 拼接

例题：　　把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)

public class StringMethodTest {

public static void main(String[] args) {

//1: 定义一个字符串

String str = "aaaaAbCdEfG";

//2: 获取首字母，然后大写

String start = str.substring(0, 1);

String big = start.toUpperCase();

//3: 获取其他字母，然后小写

String end = str.substring(1);

String small = end.toLowerCase();

//4: 拼接

String result = big + small;

System.out.println(result);

}

}

替换功能

String replace(char old,char new) 把当前字符串中，给定的旧字符，用新字符替换

String replace(String old,String new) 把当前字符串中，给定的旧字符串，用新字符串替换

去除字符串两端空格

String trim()

按自然顺序比较两个字符串

int compareTo(String str) 比较字符串的大小

int compareToIgnoreCase(String str) 比较字符串的大小,忽略大小写

String类综合练习：统计大串中小串出现的次数(优化版)

举例：在字符串”woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun”中java出现了5次

public class StringTest2 {

public static void main(String[] args) {

//1: 定义字符串

String str = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";//大串

String key = "java";//小串

//2：定义变量count，用来记录Java出现的次数

int count = 0;

//定义一个用来记录位置的变量index

int index = -1;

//找java出现的位置

//把位置赋值给index

//判断这个index的值 是否为-1, 如果为-1,结束循环

while ( (index = str.indexOf(key)) != -1 ) {

// 找到了java

count++;

//位置 = index + "java".length(),将返回的新字符串，覆盖原有字符串

str = str.substring(index + key.length());

}

//4：打印次数

System.out.println("java出现的次数： " + count);

}

}

StringBuffer: 字符串缓冲区

特点：StringBuffer 线程安全的类 -- 代码安全 --不会出错 -- 效率低

String 与 StringBuffer的区别？

String： 长度固定，内容固定

StringBuffer: 长度可变，内容可变

构造方法：

public StringBuffer() 构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。

public StringBuffer(int capacity) 构造一个不带字符，但具有指定初始容量的字符串缓冲区。

public StringBuffer(String str)构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度。

方法：

public int capacity()返回当前容量 （框的容量）

public int length() 返回长度（字符数）。 (框中实际使用的容量)

public String toString()返回此序列中数据的字符串表示形式。

添加功能

public StringBuffer append(String str) : 追加，在原有数据的基础上，添加新数据

将指定的参数类型数据[任意类型数据]，添加到当前的字符串缓冲区对象中，返回当前字符串缓冲区对象

public StringBuffer insert(int offset,String str)

在指定的位置上，将指定的参数类型数据[任意类型数据]，插入到当前的字符串缓冲区对象中，返回当前字符串缓冲区对象

删除功能

public StringBuffer deleteCharAt(int index)

把指定位置上的字符，在当前的字符串缓冲区对象中删除，返回当前字符串缓冲对象

public StringBuffer delete(int start,int end)

从指定位置开始，到指定位置结束，在当前的字符串缓冲区对象中删除，返回当前字符串缓冲对象

包左不包右

替换功能

public StringBuffer replace(int start,int end,String str) 包左不包右

从指定位置开始，到指定位置结束，用给定的字符串，将字符串缓冲区中的数据替换,返回当前的字符串缓冲区对象

反转功能

public StringBuffer reverse()//反转，返回当前的字符串缓冲区对象

截取功能

public String substring(int start)

从指定位置开始到最后，截取该字符串缓冲区的数据，返回字符串对象

public String substring(int start,int end)

从指定位置开始到指定位置结束，截取该字符串缓冲区的数据，返回字符串对象

截取功能和前面几个功能的不同

返回值类型是String类型，本身没有发生改变

1、String和StringBuffer的相互转换

StringBuffer ---> String

通过String类的构造方法

public String(StringBuffer buffer)

通过String类的方法

public static String valueOf(Object obj)

通过StringBuffer类的方法

public String toString()

String -----> StringBuffer

通过StringBuffer类的构造方法

public StringBuffer(String str)

通过StringBuffer类的方法

public StringBuffer append(String str)

public StringBuffer insert(int offset, String str)

2、把数组拼接成一个字符串

int[] arr = {1,2,3,4,5}

String str 内容： [1, 2, 3, 4, 5]

public class StringBufferTest2 {

public static void main(String[] args) {

//1： 创建int[]数组

int[] arr = {1,2,3,4,5};

String str = concatString(arr);

System.out.println(str);

}

//2： 定义把数组拼接成一个字符串的方法

public static String concatString(int[] arr){

//定义一个StringBuffer对象，用来拼接字符串

StringBuffer buffer = new StringBuffer("[");

//3: 遍历数组，得到每一个元素

for (int i = 0; i < arr.length; i++) {

if (i == arr.length-1) {

//最后一个元素

buffer.append(arr[i]).append("]");

} else {

buffer.append(arr[i]).append(", ");

}

}

//5: 返回结果

return buffer.toString();

}

}

面试题：

String,StringBuffer,StringBuilder的区别

String:

长度固定，内容不可变

StringBuffer: v1.0版本

长度可变，内容可变, 线程同步 --代码运行安全 -- 效率低

StringBuilder:v1.5版本

长度可变，内容可变， 线程不同步 -- 代码运行有隐患 -- 效率高

Arrays类 : 针对数组进行操作的工具类。提供了排序，查找等功能。

成员方法

public static String toString(int[] a) 把各种数组 转换为字符串

public static void sort(int[] a) 把各种数组 进行元素排序

public static int binarySearch(int[] a,int key) 在各种类型数组中，进行执行数值的查找，折半查找方式(二分查找法)

注意：该方法的使用，前提要求 给定的数组是一个有序的数组

Integer类:

Integer 类在对象中包装了一个基本类型 int 的值

该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法

构造方法：

public Integer(int value)

构造一个新分配的 Integer 对象，它表示指定的 int 值。

理解为： 把int基本类型数据 封装成 对象

public Integer(String s)

构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。

理解为： 把多个数字字符 转换为 Integer对象

方法：

public static String toString(int i) 把int数据转换成 String

public static String valueOf(int i) 把int数据转换成 String (记住，该方法为字符串类中的方法)

public int intValue() 获取到Integer对象中的 int基本类型数据

public static int parseInt(String s) 把String数据 转换成 int (记住)

public static Integer valueOf(String s) 把String数据 转换成 Integer对象

int类型和String类型的相互转换

int – String

方式1

int值 与 字符串相加

例如: 20 + ""

方式2 构造方法

int --> Integer --> String

Integer in = new Integer(20);

in.toString();

方式3 其他方法

通过Integer类的toString方法

public static String toString(int i)

通过String类的valueOf方法

public static String valueOf(int i)(记住)

String – int

方式1： 构造方法

String --> Integer --> int

Integer类中的构造方法

public int intValue() 获取到Integer对象中的 int基本类型数据

方式2：方法

Integer类中的方法

public static int parseInt(String s) (记住)

public static Integer valueOf(String s)

面试题：

Byte常量池问题

在java的常量池中，byte范围内的所有数据，都存储在常量池中

所以，当访问的数据在byte范围的时候，直接在常量池中获取

public class IntegerTest {

public static void main(String[] args) {

Integer i1 = new Integer(127);

Integer i2 = new Integer(127);

System.out.println(i1 == i2); // false

System.out.println(i1.equals(i2));//true

System.out.println("-----------");

Integer i3 = new Integer(128);

Integer i4 = new Integer(128);

System.out.println(i3 == i4);//false

System.out.println(i3.equals(i4));//true

System.out.println("-----------");

Integer i5 = 128; // Integer.valueOf(128)

Integer i6 = 128;

System.out.println(i5 == i6);// false

System.out.println(i5.equals(i6));//true

System.out.println("-----------");

Integer i7 = 127; //Integer.valueOf(127)

Integer i8 = 127;

System.out.println(i7 == i8);// true

System.out.println(i7.equals(i8));//true

}

}

Character类概述

Character 类在对象中包装一个基本类型 char 的值

此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然

方法：

public static boolean isDigit(char ch)确定指定字符是否为数字。

public static boolean isLowerCase(char ch)确定指定字符是否为小写字母。

public static boolean isUpperCase(char ch)确定指定字符是否为大写字母

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

字段：

public static final double E比任何其他值都更接近 e（即自然对数的底数）的 double 值。

public static final double PI比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。

方法：

public static double abs(double a) 返回 double 值的绝对值

public static double cbrt(double a)返回 double 值的立方根

public static double ceil(double a)返回比double 值大的最小整数

public static double floor(double a)返回比double 值小的最大整数

public static double max(double a, double b)返回两个 double 值中较大的一个

public static long round(double a) 四舍五入， 取整

public static double sqrt(double a)返回正确舍入的 double 值的正平方根

public static double random() : 返回0.0到1.0之间的随机小数，包含0.0，不包含1.0

Random: 随机数类 此类用于产生随机数

构造方法：

public Random()创建一个新的随机数生成器对象， 默认的种子是当前系统时间的毫秒值

public Random(long seed) 使用单个 long 种子创建一个新的随机数生成器。如果种子相同，每次得到随机数相同

方法：

public int nextInt() int范围内的随机数

public int nextInt(int n) 在0-n之间的随机数

public class RandomDemo {

public static void main(String[] args) {

//创建对象

//Random r = new Random();

Random r = new Random(1234567890L);

for (int i = 0; i < 10; i++) {

//public int nextInt() int范围内的随机数

//System.out.println( r.nextInt() );

//public int nextInt(int n) 在0-n之间的随机数

System.out.println( r.nextInt(20) );

}

}

}

System类:

System 类包含一些有用的类字段和方法。它不能被实例化。

成员方法

public static void gc() : 运行垃圾回收器

public static void exit(int status) : 退出正在运行的Java虚拟机

public static long currentTimeMillis(): 获得当前时间的毫秒值 (1970年1月1日 00:00:00 到当前时间之间的毫秒差值)

public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)//数组复制

BigInteger类

可以让超过Integer范围内的数据进行运算

构造方法

public BigInteger(String val)

方法：

public BigInteger add(BigInteger val) 加法

public BigInteger subtract(BigInteger val) 减法

public BigInteger multiply(BigInteger val) 乘法

public BigInteger divide(BigInteger val) 除法

public BigInteger[] divideAndRemainder(BigInteger val) 取商 + 余数

BigDecimal类

不可变的、任意精度的有符号十进制数。

构造方法

public BigDecimal(String val)

方法：

public BigDecimal add(BigDecimal augend) 加法

public BigDecimal subtract(BigDecimal subtrahend) 减法

public BigDecimal multiply(BigDecimal multiplicand) 乘法

public BigDecimal divide(BigDecimal divisor) 除法

public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode) 除法，保留指定位数的小数，指定进位方式

Date: 日期类

构造方法：

public Date(): 获取当前系统时间

public Date(long time): 获取1970年1月1日0点 加上 给定的毫秒值后，所对应的时间

Date 与 long类型的相互转换

public void setTime(long time) : 给当前的日期对象，设置时间

public long getTime() : 获取当前日期对象 距离1970年1月1日0点 的毫秒值

DateFormat类概述

DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。

是抽象类，所以使用其子类SimpleDateFormat

SimpleDateFormat构造方法

public SimpleDateFormat()

public SimpleDateFormat(String pattern)

成员方法

public final String format(Date date) : 将给定的日期对象 转换成 字符串对象

public Date parse(String source) :将给定的字符串 转换为 日期对象

例题：算一下你来到这个世界多少天?

public class DateTest {

public static void main(String[] args) throws ParseException {

//1： 出生日期

String time = "2008-08-08";

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

Date brithday = sdf.parse(time);

//2：用当前日期 减去 出生日期 ,就是来到世界上多久

Date currentDate = new Date();

//减法

long result = currentDate.getTime() - brithday.getTime();

//把毫秒 转换成 天数

long day = result / 1000 /60 / 60 / 24;

System.out.println("day:"+day);

}

}

Calendar类概述

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，

并为操作日历字段（例如获得下星期的日期）提供了一些方法。

成员方法

public static Calendar getInstance() 通过日历类中的静态方法，返回日历对象

public int get(int field) : 获取日历对象中的成员

public void add(int field,int amount) 对日历对象中，指定的成员进行时间调整

public final void set(int year,int month,int date)// 设置日历 年月日

例题：键盘输入一个年份，获取当前年份的二月有多少天

public class CalendarTest {

public static void main(String[] args) {

// 1： 键盘录入 2015

Scanner sc = new Scanner(System.in);

System.out.println("请输入年份：");

int year = sc.nextInt();

// a: 获取当前年份中2月份最后一天的是哪天

Calendar c = Calendar.getInstance();

// 1): 设置日历时间为 当年的3月1日

c.set(year, 2, 1);// 在日历月份中，范围是 0-11

// 2): 日历时间 天数-1

c.add(Calendar.DATE, -1);

// 3): 获取当前是哪天

StringBuilder sb = new StringBuilder();

sb.append(c.get(Calendar.YEAR)).append("年")

.append(c.get(Calendar.MONTH)+1).append("月")

.append(c.get(Calendar.DATE)).append("日");

System.out.println(sb);

}

}

正则表达式

语法规则：

字符 （一个字符）

x 字符 x , x任意字符

如：a代表字符a， b代表字符b

\x 转义字符 ,x任意字符

\\反斜线字符 ,代表就是一个 \

\t 制表符 Tab键

\n 新行（换行）符

\r 回车符

字符类(多个字符)

[abc] 代表 a、b 或 c中的其中一个字符

[^abc] 任何字符，除了 a、b 或 c（否定）

[a-z] 代表 字符a 到 字符z 之间的任意字符

[a-zA-Z] 代表所有字母中的一个

[0-9] 代表 0-9之间的一个数字

预定义字符类:

. 代表任何的一个字符

就是表示一个.怎么办？ \.

\w 单词字符：[a-zA-Z_0-9]

\d 数字：[0-9]

边界匹配器

^ 行的开头

$ 行的结尾

\b 单词边界 代表不是单词字符的字符，就是单词边界

hello java,android!Javaee

Greedy 数量词

注意： 这里的X 可以代表一个字符，也可以代表一组字符(字符串)

X? 代表X所代表的字符，出现一次或一次也没有

X* 代表X所代表的字符，出现零次或多次

X+ 代表X所代表的字符，出现一次或多次

X{n} 代表X所代表的字符，出现恰好 n 次

X{n,} 代表X所代表的字符，出现至少 n 次

X{n,m} 代表X所代表的字符，出现至少 n 次，但是不超过 m 次

正则表达式的应用：

判断功能

public boolean matches(String regex) 告知次字符串是否匹配给定的正则表达式

分割功能

public String[] split(String regex) 根据给定的正则表达式的匹配拆分此字符串

替换功能

public String replaceAll(String regex,String replacement) 将满足规则的字符串，用给定的字符串替换

获取功能

Pattern和Matcher类的使用

Pattern正则表达式对象类： 把正则表达式字符串 封装成了 正则表达式对象模式

方法：

public static Pattern compile(String regex)将给定的正则表达式编译到模式中。

public Matcher matcher(CharSequence input)创建匹配给定输入与此模式的匹配器。

Matcher 匹配器类

通过调用模式的 matcher 方法从模式创建匹配器。创建匹配器后，可以使用它执行三种不同的匹配操作：

matches 方法尝试将整个输入序列与该模式匹配。

lookingAt 尝试将输入序列从头开始与该模式匹配。

find 方法扫描输入序列以查找与该模式匹配的下一个子序列。

方法：

public boolean find()尝试查找与该模式匹配的输入序列的下一个子序列。

find() -- hasNextXxx() -- 判断是否有满足条件的数据

public String group()返回由以前匹配操作所匹配的输入子序列。

group() -- nextXxx() -- 获取满足条件的数据

正则表达式练习：

1、 举例：校验qq号码.

1:要求必须是5-15位数字

2:0不能开头

public class RegexDemo {

public static void main(String[] args) {

//键盘录入

Scanner sc = new Scanner(System.in);

System.out.println("请输入5-15位QQ号码： ");

String qq = sc.nextLine();

//正则表达式方式

String regex = "[1-9][0-9]{4,14}";

boolean flag = qq.matches(regex);

System.out.println(flag);

}

2、判断功能案例：

校验邮箱

public class RegexTest {

public static void main(String[] args) {

//键盘录入

Scanner sc = new Scanner(System.in);

System.out.println("请输入邮箱地址");

String email = sc.nextLine();

//指定规则

String regex = "\\w+@\\w+(\\.\\w+)+";

//验证

boolean flag = email.matches(regex);

System.out.println(flag);

}

}

3、 分割功能：

我有如下一个字符串: ”991 227 -27 91 27 46 38 50”

请写代码实现最终输出结果是：”-27 27 38 46 50 91 227 991”

public class RegexTest {

public static void main(String[] args) {

//1： 定义字符串 ”991 -27 91 27 46 38 50”

String str = "991 227 -27 91 27 46 38 50";

//2： 字符串分割

String[] arr = str.split(" ");

//3:把字符串数组 转换为int数组

//a:定义一个int数组

int[] intArray = new int[arr.length];

//b:把字符串数组的元素，一个个转换成int数据，存储到int数组中

for (int i = 0; i < arr.length; i++) {

intArray[i] = Integer.parseInt(arr[i]);

}

//4:int[] 排序

Arrays.sort(intArray);

//5:转回 String

String result = intToString(intArray);

//6:输出

System.out.println(result);

}

//把int[] 转换为String

//"991 227 -27 91 27 46 38 50"

public static String intToString(int[] intArray) {

StringBuilder sb = new StringBuilder();

//遍历int数组，获取到每一个元素

for (int i = 0; i < intArray.length; i++) {

sb.append(intArray[i]).append(" ");

}

return sb.toString();

}

}

4、论坛中不能出现数字字符，用*替换

public class RegexTest {

public static void main(String[] args) {

//键盘输入

Scanner sc = new Scanner(System.in);

System.out.println("请输入内容：");

String str = sc.nextLine();

//定义规则

//String regex = "[0-9]";

String regex = "[0-9]+";

//使用规则 替换 数字字符

String result = str.replaceAll(regex, "*");

//看结果

System.out.println(result);

}

}

5、组的练习：

把 “我我我我我我我我.....爱爱爱爱爱爱....学学学学学学学学学学学学...编编编编编编....程"

替换成"我爱学编程"

public class RegexTest {

public static void main(String[] args) {

//定义字符串

String s = "我我我我我我我我.....爱爱爱爱爱爱....学学学学学学学学学学学学...编编编编编编....程";

//去掉所有的点. ，通过替换功能完成

String result = s.replaceAll("(\\.)+", "");

System.out.println(result);

//去掉重复的字

//组 (.)

//(.) 我

//(.)\\1 --我我

//$加组号 可以使用正则表达式组中的内容

String result2 = result.replaceAll("(.)\\1+", "$1");

System.out.println(result2);

}

}