常见API整理【Scanner类、匿名对象、Random类以及ArrayList集合】

（一）、Scanner类

1.1 引用类型使用步骤

导包
使用import关键字导包，在类的所有代码之前导包，引入要使用的类型，java.lang包下的所有类无需导入。

import 包名.类名;

1.2 创建对象

使用该类的构造方法，创建一个该类的对象。 格式：

数据类型 变量名 = new 数据类型(参数列表);

1.3 调用方法

调用该类的成员方法，完成指定功能。 格式：

变量名.方法名();

1.4 Scanner使用步骤

• 查看类
  java.util.Scanner：该类需要import导入后使用。
• 查看构造方法
  public Scanner(InputStream source): 构造一个新的Scanner，它生成的值是从指定的输入流扫描的。
• 查看成员方法
  public int nextInt()：将输入信息的下一个标记扫描为一个int值。
• 使用Scanner类，完成接收键盘录入数据的操作，代码如下：

//1. 导包
import java.util.Scanner;
public class Demo01_Scanner {
	public static void main(String[] args) {
		//2. 创建键盘录入数据的对象
		Scanner sc = new Scanner(System.in);
		//3. 接收数据
		System.out.println("请录入一个整数：");
		int i = sc.nextInt();
		//4. 输出数据
		System.out.println("i:"+i);
	}
}

（二）、匿名对象【了解】

2.1 概念

• 创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。虽然是创建对象的简化写法，但是应用场景非常有限。
• 匿名对象 ：没有变量名的对象。
  格式：

new 类名(参数列表);

举例：

new Scanner(System.in);

2.2 应用场景

1. 创建匿名对象直接调用方法，没有变量名。

new Scanner(System.in).nextInt();

2. 一旦调用两次方法，就是创建了两个对象，造成浪费，请看如下代码。注意：一个匿名对象，只能使用一次。

new Scanner(System.in).nextInt();
new Scanner(System.in).nextInt();

3. 匿名对象可以作为方法的参数和返回值

• 作为参数：

class Test {
	public static void main(String[] args) {
		// 普通方式
		Scanner sc = new Scanner(System.in);
		input(sc);
		//匿名对象作为方法接收的参数
		input(new Scanner(System.in));
	}
	public static void input(Scanner sc){
		System.out.println(sc);
	}
}

• 作为返回值

class Test2 {
	public static void main(String[] args) {
		// 普通方式
		Scanner sc = getScanner();
	}
	public static Scanner getScanner(){
		//普通方式
		//Scanner sc = new Scanner(System.in);
		//return sc;
		//匿名对象作为方法返回值
		return new Scanner(System.in);
	}
}

（三）、Random使用步骤

• 查看类
  java.util.Random：该类需要 import导入使后使用。
• 查看构造方法
  public Random()：创建一个新的随机数生成器。
• 查看成员方法
  public int nextInt(int n)：返回一个伪随机数，范围在0（包括）和 指定值 n（不包括）之间的
  int值。
  获取一个随机的int数字（范围是int所有范围，有正负两种）；int num = r.nextInt()
  获取一个随机的int数字（参数代表了范围，左闭右开区间）；int num = r.nextInt()
  使用Random类，完成生成3个10以内的随机整数的操作，代码如下：

//1. 导包
import java.util.Random;
public class Demo01_Random {
	public static void main(String[] args) {
		//2. 创建键盘录入数据的对象
		Random r = new Random();
		 
		for(int i = 0; i < 3; i++){
			//3. 随机生成一个数据
			int number = r.nextInt(10);
			//4. 输出数据
			System.out.println("number:"+ number);
		}
	}
}

备注：创建一个 Random 对象，每次调用 nextInt() 方法，都会生成一个随机数

（四）、ArrayList集合

• 数组的长度不可以发生改变。但是ArrayList集合的长度是可以随意发生变化的。
• 对于ArrayLIst来说，有一个尖括号< E >代表泛型。
• 泛型：也就是在集合当中的所有元素，全都是统一的什么类型。
• 注意：泛型只能是引用类型，不能是基本类型。

import java.util.ArrayList;

public class Demo02Anonymous {
	public static void main(String[] args) {
	//创建了一个ArrayList集合，集合的名称是list，里面装的都是String字符串类型的数据
	//备注：从JDK1.7+ 开始，右侧的尖括号可以不写内容，但是<> 本身还是要写的。
		ArrayList<String> List = new ArrayList<String>();
		System.out.println(List); // []
	}		
}

• 注意事项：对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。如果内容为空，得到的是空的中括号：[ ]

4.1 add:将指定的元素添加到此集合的尾部。

public boolean add(E e) ：向集合当中添加元素，参数的类型和泛型一致。【返回值代表添加是否成功。】

//添加元素
list.add("hello");
list.add("world");
list.add("java");

boolean success = list.add("流言");
System.out.println(list); // [流言]
System.out.println("添加的动作是否成功:" + success); // true

注意：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。
但是对于其他集合来说，add添加动作不一定成功。

4.2 get(int index)：返回此集合中指定位置上的元素。返回获取的元素。

public E get(int index)：从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。

//从集合中获取元素：get。 索引值从0开始。
String name = list.get(2);
System.out.println("第二号索引位置："+name);

4.3 remove(int index)：移除此集合中指定位置上的元素。返回被删除的元素。

public E remove(int index)：从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。

//从集合中删除元素：remove索引值从0开始。
String whoRemoved = list.remove(3);
System.out.println("被删除的是："+whoRemoved);
System.out.println(list);

4.4 size()：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。

public int size()：获取集合的尺寸长度，返回值是集合中包含的元素个数。

//获取集合的长度尺寸,也就是其中的元素个数
int size = list.size();
System.out.println("集合的长度是：" + size);

• 遍历集合

import java.util.ArrayList;
public class Demo02Anonymous {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.add("迪丽热巴");
		list.add("古力娜扎");
		list.add("马尔扎哈");
		
		//遍历集合
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}		
}

4.5 ArrayList集合存储基本数据类型

如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的" 包装类 "。

public class Demo02ArrayListMethod {
	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		System.out.println(list);
	}
}

• 从JDK 1.5+ 开始，支持自动装箱、自动插箱。
• 自动装箱：基本类型------> 包装类型。
• 自动插箱：包装类型------> 基本类型。

（五）、String类

• java.lang.String类代表字符串。API当中说：Java程序中的所有字符串字面值（如 “ abc ”）都作为此类的实体实现。
• 其实就是说：程序中所有的双引号字符串，都是String类的对象。（就算没有new，也照样是。）
• 字符串的特点：①、字符串的内容不可变。②、正是因为字符串不可改变，所以字符串是可以共享使用的。③、字符串效果上相当于是char[ ]字符数组，但是底层原理是byte [ ] 字节数组。

1、字符串常用方法

5.1.1 public String()：创建一个空白字符串，不含有任何内容。

//使用空参构造
String str1 = new String();
//小括号留空，说明字符串什么内容都没有。
System.out.println(str1);

5.1.2 public String(char[ ] array)：根据字符数组的内容，来创建对应的字符串。

//根据字符数组创建字符串
char[] charArray = {'A','B','C'};
String str2 = new String(charArray);
System.out.println(str2);//  ---->  ABC

5.1.3 public String(byte[ ] array)：根据字节数组的内容，来创建对应的字符串。

//根据字节数组创建字符串
byte[] byteArray = {97,98,99};
String str3 = new String(byteArray);
System.out.println(str3);//----> abc

2、字符串的常量池

• 字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。
  对于基本类型来说，==是进行数值的比较。对于引用类型来说，==是进行【地址值】的比较。
  
  双引号直接写的字符串在常量池当中，new的不在常量池当中。

3、字符串的比较方法

• 如果确实需要字符串的内容比较，可以使用两个方法：
• ①、public boolean equals(Object obj)：参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true；否则返回false。
• 【注意：Ⅰ、任何对象都能用Object进行接受。Ⅱ、equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。Ⅲ、如果比较双方一个常量一个变量，推荐把常量字符串写在前面。】

String str5 = null;
System.out.println("abc".equals(str5));//推荐，false
System.out.println(str5.equals("abc"));//不推荐，报错，空指针异常NullPorinterException

• ②、public boolean equalsIgnoreCase(String str)：忽略大小写，进行内容比较。

String strA = "Java";
String strB = "java";
System.out.println(strA.equals(strB));//false,忽略大小写
System.out.println(strA.equalsIgnoreCase(strB));//true,忽略大小写

4、字符串的获取相关方法

• 5.4.1 public int length()：获取字符串当中含有的字符个数，拿到字符串长度。

//获取字符串的长度
int length = "hello".length();
System.out.println(length);//5

• 5.4.2 public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串。

//拼接字符串
String str1 = "Hello";
String str2 = "World";
String str3 = str1.concat(str2);
System.out.println(str1);//Hello,原封不动
System.out.println(str2);//World,原封不动
System.out.println(str3);//HelloWorld,新的字符串

• 5.4.3 public char charAt(int index)：获取指定索引位置的单个字符串（从0开始）。

//获取指定索引位置的单个字符
char ch = "Hello".charAt(1);
System.out.println(ch);//e

• 5.4.4 public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，如果没有，返回-1值。

//查找参数字符串在本来字符串当中出现的第一次索引位置
//如果根本没有。返回-1值。
String original = "HelloWorldHelloWorld";
int index = original.indexOf("llo");
System.out.println(index);//2
System.out.println("HelloWorld".indexOf("abc"));//-1

5、字符串的截取方法

• public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串。
• public String substring(int begin,int end)：截取从begin开始，一直到end结束，中间的字符串。【注意：[ begin，end ) :包含左边，不包含右边】

String str1 = "HelloWorld";
String str2 = str1.substring(5);
System.out.println(str1);//HelloWorld,原封不动
System.out.println(str2);//World,新字符串
		
String str3 = str1.substring(4,7);
System.out.println(str3);
		
//下面这种写法，字符串的内容仍然是没有改变的
//下面有两个字符串，"Hello","Java"
//strA当中保存的是地址值。
//本来地址值是Hello的0x666
//后来地址值变成了Java的0x999
String strA = "Hello";
System.out.println(strA);
strA = "Java";
System.out.println(strA);

6、字符串的转换方法

• 5.6.1 public char[ ] toCharArray()：将当前字符串拆分成字符数组作为返回值。

//转换成为字符串数组
char[] chars = "Hello".toCharArray();
System.out.println(chars[0]);//H
System.out.println(chars.length);//5

• 5.6.2 public byte[ ] getBytes()：获得当前字符串底层的字节数组。

//转换为字节数组
byte[] bytes =  "abc".getBytes();
for (int i = 0; i < bytes.length; i++) {
	System.out.println(bytes[i]);
}

• 5.6.3 public String replace(CharSequence oldString，CharSequence newString)：将所有出现的老字符串替换成新的字符串，返回替换之后的结果新字符串。
• 【注意：CharSequence意思就是说可以接受字符串类型】

String str1 = "How do you do?";
String str2 = str1.replace("o","*");
System.out.println(str1);//How do you do?
System.out.println(str2);//H*w d* y*u d*?

7、字符串的分割方法

• public String[ ] split(String regex)：按照参数的规则，将字符串切分成若干部分。

String str1 = "aaa,bbb,ccc";
String[] array1 = str1.split(",");
for (int i = 0; i < array1.length; i++) {
	System.out.println(array1[i]);
}//按照","分割--->aaa bbb ccc

• 【注意事项：split方法的参数其实是一个“正则表达式”，如果按照英文句点" . " 进行分割，必须写" \. " （两个反斜杠）】

String str3 ="XXX.YYY.ZZZ";
String[] array3 = str3.split("\\.");
System.out.println(array3.length);
for (int i = 0; i < array3.length; i++) {
	System.out.println(array3[i]);
}//按照"."分割--->XXX YYY ZZZ