黑马程序员_JAVA之API(String类与StringBuffer类)

------- android培训、java培训、期待与您交流！----------

String类

String：字符串数据类型。属于引用数据类型。

String类的特殊性：

字符串为常量，字符串值一旦初始化便不可以修改。

常量池：

在java用于保存在编译期已确定的，已编译的class文件中的一份数据。

主要方法：

public boolean equals(Object anObject)  字符串重写了equals方法，比较的不再是地址值，而是内容。

String的构造方法：

public String(String original)  给定一个字符串，用于创建一个字符串对象

字符串是常量：存储于内存当中的常量池中。

代码实现：

package cn.itcast;

public class Demo3 {

public static void main(String[] args) {

String s = "我以前爱小说";s = "我现在爱java";
String s2 = "我现在爱java";

System.out.println(s==s2);
//System.out.println(s.equals(s2));
System.out.println("===============");

String s3 = new String("我现在爱java");
String s4 = new String("我现在爱java");
System.out.println(s3==s4);
//System.out.println(s3.equals(s4));
}

}

普通方法：

判断方法：

重写了equals方法，不再比较地址值，比较的是字符串内容

public boolean equalsIgnoreCase(String anotherString)  Ignore:忽略  Case:大小写

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

等效于(实际不等效)  public boolean contains(String anotherString)

public boolean startsWith(String prefix)  以某个字符串开头

public boolean endsWith(String suffix)  以某个字符串结尾

public boolean isEmpty() 判断字符串对象的值是否为空

代码实现：

package cn.itcast;

public class Demo4 {

public static void main(String[] args) {

String s = "coder我是一个coder";
String s2 = "Coder我是一个Coder";

System.out.println(s.equals(s2));
System.out.println(s.equalsIgnoreCase(s2));

boolean contains = s.contains("code");
System.out.println(contains);
boolean contains2 = s2.contains("code");
System.out.println(contains2);

System.out.println("==========================");
System.out.println(s.startsWith("code"));
System.out.println(s.endsWith("code"));
//s = "";
System.out.println(s.isEmpty());
}

}

获取方法：

public int length()  获取字符串长度     数组时length属性        字符串是length()方法

public char charAt(int index) 返回指定索引处的 char 值。

public int indexOf(int ch, int 从哪开始找)  返回指定字符所在的索引   没有改字符返回-1

public int indexOf(String str,int fromIndex)  返回指定字符串所在的索引  没有该字符串返回-1

public int lastIndexOf(String str)  与indexOf相对，前者是返回最先找到的，后者返回最后找到的

public String substring(int beginIndex)  取子串

public String substring(int beginIndex, int endIndex)  包含头不包含尾

代码实现：

package cn.itcast;

public class Demo7 {

public static void main(String[] args) {

char[] arr = new char[]{'a','b','c','d'};
System.out.println(arr.length);
System.out.println(arr[1]);

String s = "abcda";
System.out.println(s.length());
System.out.println(s.charAt(1));

int indexOf = s.indexOf('a',1);
System.out.println(indexOf);
System.out.println("==========");
int indexOf3 = s.lastIndexOf('a');
System.out.println(indexOf3);

int indexOf2 = s.indexOf("abc");
System.out.println(indexOf2);

String substring = s.substring(2);
System.out.println(substring);
//abcda  该方法规则非常普遍，这里一定记住
String substring2 = s.substring(2,4);
System.out.println(substring2);
}

}

转换方法：

public char[] toCharArray()  将字符串转成char类型的数组

public byte[] getBytes()  将字符串转成byte类型的数组

public String toString()  字符串将原本返回对象地址的方法重写了，重写成返回这个字符串本身的动作

public static String valueOf(XX xx)  返回给定数据的的字符串表示形式。

public String toLowerCase()  大转小

public String toUpperCase() 小转大

代码实现：

package cn.itcast;

public class Demo8 {

public static void main(String[] args) {

String s =  "U love java,I love java";
String s2 = "我们爱java,越来越爱，恒爱，真爱";

char[] charArray = s.toCharArray();

for (int i = 0; i < charArray.length; i++) {
char c = charArray[i];
System.out.print(c+" ");
}

System.out.println();

byte[] bytes = s.getBytes();

for (int i = 0; i < bytes.length; i++) {
byte b = bytes[i];
System.out.print(b+" ");
}

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

String valueOf = String.valueOf(false);
System.out.println(valueOf);
String valueOf2 = String.valueOf(100);
System.out.println(valueOf2);
Person p = new Person("白日鼠");
String valueOf3 = String.valueOf(p);
System.out.println(valueOf3);

System.out.println(s.toLowerCase());
System.out.println(s.toUpperCase());

System.out.println(s.concat(s2));
System.out.println(s+s2);
}

}

构造方法：

字符串的本质就是一个字符数组

public String(char[] value)

public String(char[] value,int 从哪里开始, int 去多少个)  使用字符数组的一部分创建字符串

public String(byte[] bytes)

public String(byte[] bytes, int offset, int length)  使用字节数组的一部分创建字符串

代码实现：

package cn.itcast;

public class Demo6 {

public static void main(String[] args) {

char[] arr = new char[]{'a','b','c','d'};

String s = new String(arr);
System.out.println(s);

String s2 = new String(arr,2,2);
System.out.println(s2);

//		byte[] bytes = new byte[]{97,98,99,100};
byte[] bytes = new byte[]{'a','b','c','d'};
String s3 = new String(bytes);
System.out.println(s3);

String s4 = new String(bytes,0,2);
System.out.println(s4);
}

}

其他方法：

public String replace(char oldChar, char newChar)  使用新字符替换旧字符

public String replace(CharSequence target, CharSequence replacement)使用新字符串替换旧字符串

public String replace(String oldString, String newString)使用新字符串替换旧字符串

public String[] split(String regex)   根据给定的字符串，切割调用方法的字符串

public String trim()  去掉首尾空白

代码实现：

package cn.itcast;

public class Demo9 {

public static void main(String[] args) {

String s = "good good study,day day up";
char newChar = 'a';
String newString = "nice";
System.out.println(s);
//String replace = s.replace('o', newChar);
//System.out.println(replace);

//String replace = s.replace("good", newString);
//System.out.println(replace);

String[] split = s.split(" ");
for (int i = 0; i < split.length; i++) {
String string = split[i];
System.out.println(string+"-");
}

String s3 = "			u love java 吐, i love java,too	";
String trim = s3.trim();
System.out.println(trim);

System.out.println(s3);

}

}

比较方法：

public int compareTo(String anotherString)    将调用方法的字符串与给定的字符串进行比较

返回负数，则调用方法的字符串小

返回整数，则调用方法的字符串大

返回0，两个字符串相等

字符串有默认的字典顺序

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

代码实现：

package cn.itcast;

public class Demo10 {

public static void main(String[] args) {

int i = 10;
int j = 20;
System.out.println(i<j);

String s = "中文a love java";
String s2 = "中文A LOVE JAVA";

System.out.println(s.compareTo(s2));
System.out.println(s2.compareTo(s));

System.out.println(s.compareToIgnoreCase(s2));
System.out.println(s.compareToIgnoreCase(s2));
}
}

引用类型String的"四个空"

没有值：引用根本就没有赋值   无法直接使用的

有值，但是值为空null：不能调用方法！

有值,有对象 ,对象的内容是空的 :  调用isEmpty返回true

当返回值是void时，不可打印

当单独打印null时，不可打印

代码实现：

package cn.itcast;

public class Demo5 {

public static void main(String[] args) {

//没有值
//String s;
//System.out.println(s);

//有值，但是值是null
//String s = null;
//System.out.println(s);
//s.isEmpty();

String s = "";
System.out.println(s);
System.out.println(s.isEmpty());

//null值字面值不能直接打印
//返回值是void的方法也不能直接打印
//		System.out.println(null);
//		System.out.println(method());
}

public static void method() {

}

}

完成需求：

遍历字符串中每一个字符

例如：将一个int数组的值拼写成字符串形式。{12,3,432,53,6} >>"{12,3,432,53,6}"

代码实现：

package cn.itcast;

public class Demo11 {

public static void main(String[] args) {

String s = "我爱java";
method(s);

int[] arr = new int[]{12,3,432,53,6};
String s2 = method2(arr);
System.out.println(s2);
}

public static String method2(int[] arr) {
String s2 = "{";
for (int i = 0; i < arr.length; i++) {
int j = arr[i];
s2 += j;
if(i!=arr.length-1)
s2 += ",";
}
s2 += "}";
return s2;
}

public static void method(String s) {
char[] charArray = s.toCharArray();

for (int i = 0; i < charArray.length; i++) {
char c = charArray[i];
System.out.print(c+" ");
}
}

}

StringBuffer与StringBuilder

StringBuffer与StringBuilder的异同：

这两个所拥有的方法完全相同；

StringBuilder比StringBuffer效率更快；

StringBuffer比StringBuilder线程安全。

下面以StringBuffer为例介绍其应用：

概念：

字符串缓冲区，缓冲区用于存储数据，所以也称之为容器。字符串的组成原理就是通过该类实现的。

StringBuffer与String的区别：

效率更快，避免了过多字符串常量垃圾对象的产生；

前者用于生成字符串，后者用于表示字符串

前者为常量，后者是“可变化的量”

代码实现：

package cn.itcast;

public class Demo {

public static void main(String[] args) {

String s = "i love java";
//遍历这个字符串，拼成一个新的字符串，但是左右两边加上[]
String s2 = "[";
for (int i = 0; i < s.length(); i++) {

char charAt = s.charAt(i);
s2 += charAt;
}
s2 += "]";
//缓冲区的存储过程
//[
//[i
//[i
//[i l
//...
//[i love java]
System.out.println(s2);
}

}

StringBuffer的方法：

构造方法：

public StringBuffer()  创建一个容量为16的缓冲区

public StringBuffer(String str)
 构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

普通方法：

容量public int capacity() 返回当前容量        可以容纳的字符数

长度public int length()  返回内容的长度       已经容纳的字符数

代码实现：

package cn.itcast;

public class Demo2 {

public static void main(String[] args) {

StringBuffer sb = new StringBuffer();

sb.append("i");
sb.append("love");
sb.append("java");
sb.append("!");
sb.append("abcdefg");

System.out.println(sb.toString());
System.out.println(sb.capacity());
System.out.println(sb.length());

StringBuffer sb2 = new StringBuffer("i love code!");

System.out.println(sb2.capacity());
}

}

StringBuffer普通方法：

public StringBuffer append(XX xx)  追加  返回对象本身

public StringBuffer insert(int 插入的位置, XX xx)  插入  返回对象本身

public StringBuffer delete(int start, int end)  删除元素

public StringBuffer deleteCharAt(int index) 删除元素

public StringBuffer reverse() 将此字符序列用其反转形式取代。

public StringBuffer replace(int start, int end, String str)  从哪开始到哪结束，替换成str

代码实现：

package cn.itcast;

public class Demo3 {

public static void main(String[] args) {

StringBuffer sb = new StringBuffer();
sb.append("i love java");
sb.append(true);
sb.append(new Demo());
sb.append(100);
// System.out.println(sb);

StringBuffer sb2 = new StringBuffer();

//由于StringBuffer可以返回对象本身，所以可以使用链式调用
sb2.append(true)
.append(100)
.append("i love java")
.append(new Demo())
.append("aabcd")
.insert(2, "$$$")
.append("abc");

System.out.println(sb2);

sb2.delete(0, 3).deleteCharAt(0).reverse();
System.out.println(sb2);
sb2.replace(0, 10, "oy");
System.out.println(sb2);

String s = sb2.toString();
System.out.println(s);
}

}