黑马程序员—常见API

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

一Scanner类

(1)Scanner是JDK5以后出现的方便我们从键盘接受数据的类。

(2)Scanner的构造格式：

Scanner sc = new Scanner(System.in);

System.in 是System类下面有一个静态的成员变量in。它的类型是InputStream。

代表的是标准键盘输入流。也就是键盘录入数据。

Scanner是对其进行了封装，提供了各种转换功能。方便我们获取到想要的数据类型的数据。

(3)要掌握的两个功能：

A:返回int类型

public int nextInt()

B:返回String类型

public String nextLine()

public String next()

注意事项：

先next,再nextLine会有问题。

解决方案：

重新建立Scanner对象。//一般不会这样做。因为消耗资源

根据需求，选择合适的方法。

统一一种方法。

代码实例

public class Demo01_Scanner {

public static void main(String[] args) {

/*
Scanner sc = new Scanner(System.in);
int nextInt = sc.nextInt();
System.out.println(nextInt);

Scanner sc2 = new Scanner(System.in);
String data = sc2.next();
System.out.println(data);

Scanner sc3 = new Scanner(System.in);
String nextLine = sc3.nextLine();
System.out.println(nextLine);
*/

Scanner sc4 = new Scanner(System.in);
String next = sc4.next();
String nextLine = sc4.nextLine();

System.out.println("next方法返回内容:"+next);
System.out.println("这行内容:"+nextLine);

}

}

二String类的概述和使用

(1)由多个字符组成的一串数据。

(2)构造方法：

1：字面值常量赋值

2：public String() 创建一个空的字符串

3：public String(String original) 给定字符串，创建字符串对象

4：public String(byte[] bytes) 使用指定的字节数组创建字符串

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

6：public String(char[] value) 使用字符数组创建字符串

public String(char[] value, int offset, int count)

(3) String的普通方法：

判断：

重写equals方法：不再比较地址值，比较字符串内容本身

1：public boolean equalsIgnoreCase(String anotherString) 比较两个字符串内容，忽略大小写

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

CharSequence:char 值的一个可读序列 按照某种顺序排列的一列字符 String该接口的子类

在方法中如果看到CharSequence 类型，直接可以将其理解为String

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

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

4: public boolean isEmpty() 判断字符串是否为空 判断依据字符串长度为0

代码实例

public class Demo04_String {

public static void main(String[] args) {

//1：public boolean equalsIgnoreCase(String anotherString)  比较两个字符串内容，忽略大小写
String s = "i love java";
String s2 = "I love java";

System.out.println(s.equals(s2));
System.out.println(s.equalsIgnoreCase(s2));
System.out.println("=========================");
//2：public boolean contains(CharSequence s)  当且仅当此字符串包含指定的 char 值序列时，返回 true。
String s3 = "we love java";
String s4 = "you love java";
String s5 = "love java";
String s6 = "";

System.out.println(s3.contains(s4));
System.out.println(s3.contains(s5));
System.out.println(s3.contains(s6));
System.out.println("=========================");
//3:  public boolean startsWith(String prefix)  以某个字符串开头
//public boolean endsWith(String suffix)  以某个字符串结尾

String s7 = "i love java";
String s8 = "i lov";
String s9 = " java";
String s10 = "love";

System.out.println(s7.startsWith(s8));
System.out.println(s7.endsWith(s9));

System.out.println(s7.startsWith(s10, 2));
System.out.println("=========================");

//4: public boolean isEmpty() 判断字符串是否为空  判断依据字符串长度为0
String s11 = "i love java";
String s12 = " ";
String s13 = "";
//String s14 = null;

System.out.println(s11.isEmpty());
System.out.println(s12.isEmpty());
System.out.println(s13.isEmpty());
//System.out.println(s14.isEmpty());
}

}

获取：

1：public int length() 获取字符串长度 int[] arr = new int[]{1,2,3,4}; >>arr.length

2：public char charAt(int index) 根据索引获取字符

3：public int indexOf(int ch) 根据字符获取索引

public int indexOf(int ch, int fromIndex)

public int lastIndexOf(int ch)与indexOf方法相对象，是最后一次出现的索引

4：public String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。

public String substring(int beginIndex, int endIndex) 截取字符串的一部分 包含头，不包含尾

代码实例

public class Demo05_String {

public static void main(String[] args) {
//1：public int length()  获取字符串长度
String s = "i love java";
System.out.println(s.length());
System.out.println("==============");

//2:public char charAt(int index) 根据索引获取字符
String s2 = "i like java";
System.out.println(s2.charAt(2));
System.out.println("==============");

//3：public int indexOf(int ch)    根据字符获取索引,获取第一次遇到索引
//public int indexOf(int ch, int fromIndex)
String s3 = "i miss java";
System.out.println(s3.indexOf('i'));
System.out.println(s3.indexOf('i',2));
System.out.println("==============");

//4:public String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。
//public String substring(int beginIndex, int endIndex)  截取字符串的一部分   包含头，不包含尾
String s4 = "i enjoy java";
System.out.println(s4.substring(2));
System.out.println(s4);

System.out.println(s4.substring(0, 12));
System.out.println(s4.substring(0,s4.length()));
}

}

转换：

1：public char[] toCharArray() 字符串转为字符数组 字符数组的特殊性：可以直接打印数组，不是地址，是内容

2：public byte[] getBytes() 字符串转为字节数组

3: public static String valueOf(XX xx) 返回XX类型的字符串表示

4: public String toUpperCase() 转成大写

public String toLowerCase() 转成小写

5: public String concat(String str) 将指定字符串连接到此字符串的结尾。

代码实例

public class Demo06_String {

public static void main(String[] args) {

//1：public char[] toCharArray()  字符串转为字符数组
String s = "i love java";
char[] charArray = s.toCharArray();
System.out.println(charArray);
for (int i = 0; i < charArray.length; i++) {
char c = charArray[i];
System.out.println(c);
}
System.out.println("===================================");
//2：public byte[] getBytes()  字符串转为字节数组
String s2 = "i like java";
byte[] bytes = s2.getBytes();

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

//3: public static String valueOf(XX xx)  返回XX类型的字符串表示
Person p = new Person("AngelaBaby",28);
System.out.println(String.valueOf(p));

//4: public String toUpperCase() 转成大写
//public String toLowerCase() 转成小写
String s3 = "I love Java";
System.out.println(s3.toUpperCase());
System.out.println(s3.toLowerCase());

//5: public String concat(String str) 将指定字符串连接到此字符串的结尾。
String s4 = "i love ";
String s5 = "java";
System.out.println(s4.concat(s5));
System.out.println(s4+s5);
}

}

二String类的特殊性：

字符串是常量；它们的值在创建之后不能更改，因为 String 对象是不可变的，所以可以共享

指向字符串对象的引用，可以再指向其他字符串对象

字符串对象本身，无法改变。

常量池：

用于存放常量的内存区域

字符串属于常量，所以在使用字面值常量赋值时，就创建常量对象。

如果发现后边再次使用该常量时，不再创建新的对象，使用已经存在的对象。

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

代码实例

public class Demo03_String {

public static void main(String[] args) {

String s = "我是字符串";
String s2 = "我是字符串";

System.out.println(s == s2);
System.out.println(s.equals(s2));
System.out.println("================");
String s3 = new String("我是字符串");
String s4 = new String("我是字符串");

System.out.println(s3 == s4);
System.out.println(s3.equals(s4));

}

}

三StringBuffer类

(1)StringBuffer： 字符串缓冲区 用来临时存储字符串内容的。

一个StringBuffer对象可以反复存放不同的字符串内容，最终只需要将这个拼写好的完整字符串返回即可。

字符串缓冲区用来拼写字符串，真正使用的仍然为字符串

代码实例

public class Demo01_StringBuffer {

public static void main(String[] args) {
//定义一个int类型数组
int[] arr = new int[]{12,4,6,7,734,34,67,8,0,0};
//定义变量，接收结果字符串，并加入{
String s = "{";
//遍历数组
for ( int i=0; i<arr.length; i++) {
//依次获取到每一个元素
int j = arr[i];
//将每一个元素加到结果字符串中
s += j;
//如果不是最后一个元素，则元素后边需要添加，
if(i!=arr.length-1) {
s += ",";
}
}
//将所有元素添加到字符串内后，加入“}”
s += "}";
//打印最终结果
System.out.println(s);
}

}

构造：

public StringBuffer() 创建一个空的字符串缓冲区

public StringBuffer(int capacity) 指定容量创建一个字符串缓冲区

public StringBuffer(String str) 给定内容创建一个字符串缓冲区

普通方法：

public StringBuffer append(XXX xxx) 将任意类型转为字符串，添加到字符串缓冲区

public int capacity() 返回当前容量

public int length() 返回字符数

代码实例

public class Demo02_StringBuffer {

public static void main(String[] args) {

StringBuffer sb = new StringBuffer();
sb.append(2);
sb.append(true);
sb.append('a');
sb.append("i love java");

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

StringBuffer sb2 = new StringBuffer(24);
sb2.append("aaaaabbbbbcccccdddddeeeee");
System.out.println(sb2.length());
System.out.println(sb2.capacity());

System.out.println(sb2);
System.out.println("========================");
/*
StringBuffer sb3 = new StringBuffer("i love java");
System.out.println(sb3.capacity());
System.out.println(sb3.length());
System.out.println(sb3);
*/
}

}