学习java第十二天
类 StringBuffer（从JDK1.0开始）
1、线程安全的可变字符序列（可变的字符串）
2、一个类似于 String 的字符串缓冲区
主要是两个方法（append()追加、insert()添加）
String与 StringBuffer：
1、都是对字符序列进行操作
2、String 的数据是不可变的、StringBuffer 的内容是可变的
3、StringBuffer 自带缓存区，读取数据块，效率更高
如果一个字符串反复修改其值，相比Stringl来说使用StringBuffer 效率更高，使用StringBuffer反复来创建变量。
StringBuffer的构造方法：
无参的构造 public StringBuffer(): 默认会给16个字符大小的缓冲区
注：capacity()方法 是获取缓冲区容量的大小
有参构造：
public StringBuffer(int capacity)：构造一个不带字符，但具有指定初始容量的字符串缓冲区。
public StringBuffer(String str)：构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度。
StringBuffer方法：
增改：
public StringBuffer append(参数列表)；
追加该方法的对象的值。 该方法采用：boolean，char，int，long，String等类型。
public StringBuffer insert(参数列表)
在指定位置添加给定的数据类型，boolean，char，int，long，String等类型。
需要第一参数传递追加的索引 。
删取：
public StringBuffer deleteCharAt(int index)：
移除此序列指定位置（索引）的 char。此序列将缩短一个 char字符。
public StringBuffer delete(int start, int end)：
删除指定区间的字符。
public char charAt(int index)：
返回此序列中指定索引处的 char 值。
public int indexOf(String str)
查找是否存在这个字符， 存在返回当前的索引，不存在返-1
length() 获取字符串的长度 *
replace(int start, int end, String str) 替换 根据区间来进行替换
reverse() 控制翻转 *
toString() 转换成String *
StringBuffer String相互转换：
String转换成一个StringBuffer ：
- 通过构造方法 new StringBuffer(“String字符串”);
- 通过调用其append new StringBuffer().append(“String字符串”)’;
StringBuffer转换String：
- 通过toString() 方法
- 通过String构造方法 new String(StringBuffer类的字符)
StringBuilder ： 1. 一个可变的字符序列 2.多个线程是不安全的
StringBuilder和StringBuilde的区别：
StringBuffer 1.0 多线程安全 效率低 (开发里使用这个多一点)
StringBuilder 1.5 多线程不安全 效率高
包装类：使用包装类型后，可以使用包装类的方法，可以实现类型的相互转换
基本数据类型都是非常简单的数据类型，不是包装类型
基本数据类型的包装类：
int -> Integer char -> Character
其它基本数据类型的包装类型都是把首字母换成大写
Integer 类型：
对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。
构造方法：
public Integer(int value)：Integer 对象，且为 int 值。
public Integer(String s)：表示 String 参数所指示的 int 值。
否则出现异常 ： java.lang.NumberFormatException
常量值:
public static final int MAX_VALUE 获取int类型最大的值
public static final int MIN_VALUE 获取int类型最小的值 所有的包装类型都会有 这三个常量
public static final int SIZE 获取 int 类型的位数
Integer类的常用方法：
public byte byteValue() 返回值是一个 byte 1.相互转换的时候不要超过最大的范围
public static int parseInt(String s) 静态方法: 把String转换成int类型的方法(最常用)
public static String toBinaryString(int i) 把int 类型转换成 二进制
public static String toOctalString(int i) 把 int 类型转换成 八进制
public static String toHexString(int i) int 类转换为 16进制
public static Integer valueOf(int i) 把int 类型转换成包装类
String int Integer （数据类型的相互装换）：
String转换成int 类型：
- 通过构造 new Integer()
- 通过parseInt(String s)(常用)
- valueOf(String str)
int 类型转换 成String 类型：
- new String(int i)
- 拼接 +""(常用)
- toString()方法
int 类型转换成 Integer 类型： - 通过构造方法 new Integer()
- valueOf(int i)
Integer转换成 int 类型：
- intValue()
- 直接赋值(Integer i = 10)
jdk 1.5 之后会自动包装
自动包装: 把基本数据类型转换成包装类
自动拆箱 把包装类转换成 基本数据类型
手动装箱 :Integer integer = new Integer(10);
手动拆箱 : intValue();
正则表达式：
- 就是一个字符串 (校验规则的字符串) 主要是做验证，把复杂的问题的简单化
- 坏处：记忆量，但不一定写的对
字符类
[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 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]
Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次
正则的三个方法 ：
第一个是比较 matches(str)
第二个是 split("")
第三个是: replaceAll(reg,"")
总结：这几天讲的这些类的方法挺多的，不好记，但也不用记，但是对于正则表达式的使用，我感觉真的是无从下手，比如说怎么截取指定字符到字符范围的内容都被难倒了。
作业*
import java.util.Arrays;
public class Until {
//1. 全部变为大写,并输出到屏幕,截取子串”DK” 并输出到屏幕
public static String getJdk(String str) {
return str.toUpperCase().substring(1, str.length());
}
//2. 写一个方法判断一个字符串是否对称
public static boolean check(String str) {
StringBuffer sb = new StringBuffer(str);
return sb.reverse().toString().equals(str);
}
//3. 编写一个程序，将下面的一段文本中的各个单词的字母顺序翻转
public static String turn(String str) {
String[] s = str.split("\\b");
String s1 = "";
for (int i = 0; i < s.length; i++) {
s1 += new StringBuffer(s[i]).reverse().toString();
}
return s1;
}
//4. String s="name=zhangsan age=18 classNo=090728"
// 将上面的字符串拆分，结果如下:zhangsan 18 090728;
public static String cut(String str) {
return str.replaceAll("([\\s][\\w]{1,999}[=])|([\\w]{1,999}[=])", " ");
}
//5. 使用两种方法把这个字符串中的单词首字母转为大写：
public static String changeFirst(String str) {
return str.substring(0, 1).toUpperCase() + str.substring(1);
}
//6.
//统计该字符串中字母s出现的次数
public static int operate(String str, String c) {
String[] s = str.split(c);
return s.length - 1;
}
//取出子字符串"test"
public static String get(String str, String c) {
if (str.contains(c)) {
return str.substring(str.indexOf(c), str.indexOf(c) + c.length());
}
return null;
}
// 用多种方式将本字符串复制到一个字符数组Char[] str中.
public static char[] way(String s) {
char[] str = null;
char[] ch1 = s.toCharArray();//第一种
char[] ch2 = new char[s.length()];//第二种
for (int i = 0; i < s.length(); i++) {
ch2[i] = s.charAt(i);
}
str = ch1;
return str;
}
//(4) 将字符串中每个单词的第一个字母变成大写， 输出到控制台。
public static String everyFirst(String str) {
String[] s1 = str.split(" ");
String s2 = "";
for (String s3 : s1) {
s2 += s3.substring(0, 1).toUpperCase() + s3.substring(1) + " ";
}
return s2;
}
//(5) 用两种方式实现该字符串的倒叙输出。(用StringBuffer和for循环方式分别实现)
public static String back(String str) {
//第一种
StringBuffer s1 = new StringBuffer(str);
s1.reverse();
//第二种
String s2 = "";
char[] ch = str.toCharArray();
for (int i = ch.length - 1; i > 0; i--) {
s2 += ch[i];
}
return s2;
}
//(6) 将本字符串转换成一个字符串数组，要求每个数组元素都是一个有意义的额英文单词,并输出到控制台
public static void print(String str) {
String[] s = str.split(" ");
for (String s1 : s) {
System.out.println(s1);
}
}
//首尾去除*字符
public static String delHeadEnd(String str) {
if (!str.isEmpty()) {
StringBuffer sb = new StringBuffer(str);
if (str.startsWith("*") && sb.length() != 0) {
sb.delete(0, 1);
}
if (str.endsWith("*") && sb.length() != 0) {
sb.delete(sb.length() - 1, sb.length());
}
str = sb.toString();
}
return str;
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
