Java基础常用API

1.API概念

    *API(Application Programming Interface) : 应用程序编程接口

2.Scanner和String类

    *Scanner类

        *用于键盘录入

package com.text;
import java.util.Scanner;
/*
 * Scanner:用于获取键盘录入的数据。(基本数据类型，字符串数据)
 * public String nextLine():获取键盘录入的字符串数据
 */
public class ScannerDemo {
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		//接收数据
		System.out.println("请输入一个字符串数据：");
		String s = sc.nextLine();
		
		//输出结果
		System.out.println("s:"+s);
	}
}

    *String类

        *构造方法

            *String(String original):把字符串数据封装成字符串对象

            *String(char[] value):把字符数组的数据封装成字符串对象

            *String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象

package com.text;
/*
 * String:字符串类
 * 		由多个字符组成的一串数据
 * 		字符串其本质是一个字符数组
 * 
 * 构造方法：
 * 		String(String original):把字符串数据封装成字符串对象
 * 		String(char[] value):把字符数组的数据封装成字符串对象
 * 		String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象
 * 
 * 注意：字符串是一种比较特殊的引用数据类型，直接输出字符串对象输出的是该对象中的数据。
 */
public class StringDemo {
	public static void main(String[] args) {
		//方式1
		//String(String original):把字符串数据封装成字符串对象
		String s1 = new String("hello");
		System.out.println("s1:"+s1);
		System.out.println("---------");
		
		//方式2
		//String(char[] value):把字符数组的数据封装成字符串对象
		char[] chs = {'h','e','l','l','o'};
		String s2 = new String(chs);
		System.out.println("s2:"+s2);
		System.out.println("---------");
		
		//方式3
		//String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象
		//String s3 = new String(chs,0,chs.length);
		String s3 = new String(chs,1,3);
		System.out.println("s3:"+s3);
		System.out.println("---------");
		
		//方式4
		String s4 = "hello";
		System.out.println("s4:"+s4);
	}
}

    *常见字符串对象两种方式的区别

比如
	String s1 = "hello";
	String s2 = "he"+"llo";
	s1和s2的地址指向的是同一块内存
	记住下面这个是不行的
	String s1 = "hello";
	String s2 = "he";
	String s3 = "llo";
	String s4= s2 + s3;
	s4和s1的地址值是不一样的,因为这个不是常量拼接,这个叫做变量拼接;

    *==可以比较基本数据类型,也可以引用数据类型

        *基本数据类型比较的数据值

        *引用数据类型比较的是地址值

    *所有的字符串都是在方法区中常量池里面存储

        *如果是直接赋值,拿的是方法区中常量池里面的地址

        *如果是new出来的,我们拿的是堆里面的地址

    *String类的判断功能

         *boolean equals(Object obj):比较字符串的内容是否相同

         *boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写

         *boolean startsWith(String str):判断字符串对象是否以指定的str开头

         *boolean endsWith(String str):判断字符串对象是否以指定的str结尾

         *boolean contains(String str):判断是否包含str

package com.text;
/*
 * Object:是类层次结构中的根类，所有的类都直接或者间接的继承自该类。
 * 如果一个方法的形式参数是Object，那么这里我们就可以传递它的任意的子类对象。
 * 
 * String类的判断功能：
 * boolean equals(Object obj):比较字符串的内容是否相同
 * boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
 * boolean startsWith(String str):判断字符串对象是否以指定的str开头
 * boolean endsWith(String str):判断字符串对象是否以指定的str结尾
 */
public class StringDemo {
	public static void main(String[] args) {
		//创建字符串对象
		String s1 = "hello";
		String s2 = "hello";
		String s3 = "Hello";
		
		//boolean equals(Object obj):比较字符串的内容是否相同
		System.out.println(s1.equals(s2));
		System.out.println(s1.equals(s3));
		System.out.println("-----------");
		
		//boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
		System.out.println(s1.equalsIgnoreCase(s2));
		System.out.println(s1.equalsIgnoreCase(s3));
		System.out.println("-----------");
		
		//boolean startsWith(String str):判断字符串对象是否以指定的str开头
		System.out.println(s1.startsWith("he"));
		System.out.println(s1.startsWith("ll"));
	}
}

    *String的获取功能      

        *int  length(); //返回字符串中的字符个数

        // 字符串也有索引;

        *char  charAt(int index);//获取指定位置上的字符;

        *int   indexOf(String str); // 获取str第一次出现的索引位置;

        *int   indexOf(String str,int index);//从指定索引开始查

        *String  substring(int start)// 这个是从start位置开始截取,直到最后

        *String  substring(int start,int end);// 从start位置开始截取,到end结束(包含start,但是不包含end)

    *String类转换功能

        *char[] toCharArray():把字符串转换为字符数组

        *String toLowerCase():把字符串转换为小写字符串

        *String toUpperCase():把字符串转换为大写字符串

package com.text;
/*
 * String类的转换功能：
 * char[] toCharArray():把字符串转换为字符数组
 * String toLowerCase():把字符串转换为小写字符串
 * String toUpperCase():把字符串转换为大写字符串
 * 
 * 字符串的遍历：
 * 		A:length()加上charAt()
 * 		B:把字符串转换为字符数组，然后遍历数组
 */
public class StringDemo {
	public static void main(String[] args) {
		//创建字符串对象
		String s = "abcde";
		
		//char[] toCharArray():把字符串转换为字符数组
		char[] chs = s.toCharArray();
		for(int x=0; x<chs.length; x++) {
			System.out.println(chs[x]);
		}
		System.out.println("-----------");
		
		//String toLowerCase():把字符串转换为小写字符串
		System.out.println("HelloWorld".toLowerCase());
		//String toUpperCase():把字符串转换为大写字符串
		System.out.println("HelloWorld".toUpperCase());
	}
}

    *String类的其他功能

        *String trim();//去除前后空格;不能去除中间空格;

        *String[]  split(String str);//按str切割,将切割后的内容装到一个数组中;//.是不能切割,不建议空格切割

        *String    replace(String oldStr, String newStr)// 可以将所有的oldStr替换成newStr

package com.text;
/*
 * 去除字符串两端空格	
 *		String trim()
 * 按照指定符号分割字符串	
 *		String[] split(String str)
 */
public class StringDemo {
	public static void main(String[] args) {
		//创建字符串对象
		String s1 = "helloworld";
		String s2 = "  helloworld  ";
		String s3 = "  hello  world  ";
		System.out.println("---"+s1+"---");
		System.out.println("---"+s1.trim()+"---");
		System.out.println("---"+s2+"---");
		System.out.println("---"+s2.trim()+"---");
		System.out.println("---"+s3+"---");
		System.out.println("---"+s3.trim()+"---");
		System.out.println("-------------------");
                                                               
		//String[] split(String str)
		//创建字符串对象
		String s4 = "aa,bb,cc";
		String[] strArray = s4.split(",");
		for(int x=0; x<strArray.length; x++) {
			System.out.println(strArray[x]);
		}
	}
}

3.StringBuilder类

    *是一个可变的字符串

    *String和StringBuilder类的区别

        *String的内容是固定的

        *StringBuilder的内容是可变的

    *+=拼接字符串会消耗内存

        *因为每次拼接都会创建一个新的字符串对象,而利用StringBuilder来拼接字符串始终用的都是同一个StringBuilder容器

    *StringBilder常用的方法

        *构造方法

            *StringBuilder()

            *StringBuilder(String str)

        *成员方法

            *public int capacity():返回当前容量 (理论值)

            *public int length():返回长度(已经存储的字符个数)

            *public StringBuilder append(任意类型):添加数据，并返回自身对象

            *public StringBuilder reverse():反转功能

package com.text;
/*
 * StringBuilder:是一个可变的字符串。字符串缓冲区类。
 * 
 * String和StringBuilder的区别：
 * 		String的内容是固定的。
 * 		StringBuilder的内容是可变的。
 * 
 * 构造方法：
 * 		StringBuilder()
 * 
 * 成员方法：
 * 		public int capacity():返回当前容量
 * 		public int length():返回长度（字符数）
 * 
 * 		容量：理论值
 * 		长度：实际值
 */
public class StringBuilderDemo {
	public static void main(String[] args) {
		//创建对象
		StringBuilder sb = new StringBuilder();
		System.out.println("sb:"+sb);
		System.out.println("sb.capacity():"+sb.capacity());
		System.out.println("sb.length():"+sb.length());
	}
}

package com.text;
/*
 * 添加功能
 *		public StringBuilder append(任意类型):添加数据，并返回自身对象
 * 反转功能
 *		public StringBuilder reverse()
 */
public class StringBuilderDemo {
	public static void main(String[] args) {
		//创建对象
		StringBuilder sb = new StringBuilder();
		
		//public StringBuilder append(任意类型)
		//StringBuilder sb2 = sb.append("hello");
		
		/*
		System.out.println("sb:"+sb);
		System.out.println("sb2:"+sb2);
		System.out.println(sb == sb2); //true
		*/
		
		/*
		sb.append("hello");
		sb.append("world");
		sb.append(true);
		sb.append(100);
		*/
		
		//链式编程
		sb.append("hello").append("world").append(true).append(100);
		
		System.out.println("sb:"+sb);
		
		//public StringBuilder reverse()
		sb.reverse();
		System.out.println("sb:"+sb);
		
	}
}

    *String和StringBuilder的相互转换

package com.text;
/*
 * StringBuilder和String的相互转换
 * 
 * StringBuilder -- String
 * 		public String toString():通过toString()就可以实现把StringBuilder转成String
 * 
 * String -- StringBuilder
 * 		StringBuilder(String str):通过构造方法就可以实现把String转成StringBuilder
 */
public class StringBuilderTest {
	public static void main(String[] args) {
		//StringBuilder -- String
		/*
		StringBuilder sb = new StringBuilder();
		sb.append("hello").append("world");
		
		String s = sb.toString();
		System.out.println(s);
		*/
		
		//String -- StringBuilder
		String s = "helloworld";
		StringBuilder sb = new StringBuilder(s);
		System.out.println(sb);
	}
}

    *把数组转换为字符串

package com.text;
/*
 * 把数组拼接成一个字符串
 * 举例：
 * 		int[] arr = {1,2,3};
 * 结果：
 * 		[1, 2, 3]
 */
public class StringBuilderTest2 {
	public static void main(String[] args) {
		//定义一个数组
		int[] arr = {1,2,3};
		
		//写方法实现拼接
		
		//调用方法
		String s = arrayToString(arr);
		
		//输出结果
		System.out.println("s:"+s);
	}
	
	/*
	 * 两个明确：
	 * 		返回值类型：String
	 * 		参数列表：int[] arr
	 */
	public static String arrayToString(int[] arr) {
		StringBuilder sb = new StringBuilder();
		//[1, 2, 3]
		sb.append("[");
		for(int x=0; x<arr.length; x++) {
			if(x==arr.length-1) {
				sb.append(arr[x]);
			}else {
				sb.append(arr[x]).append(", ");
			}
		}
		sb.append("]");
		
		String result = sb.toString();
		
		return result;
	}
}

    *判断一个字符串是否是对称字符串

        *例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串

package com.text;
import java.util.Scanner;

/*
 * 判断一个字符串是否是对称字符串
 * 例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
 * 
 * 分析：
 * 		A:键盘录入一个字符串
 * 		B:写方法实现判断一个字符串是否是对称字符串
 * 			把字符串反转，和反转前的字符串进行比较，如果内容相同，就说明是对称字符串
 * 		C:调用方法
 * 		D:输出结果
 */
public class StringBuilderTest4 {
	public static void main(String[] args) {
		//键盘录入一个字符串
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串：");
		String s = sc.nextLine();
		
		//写方法实现判断一个字符串是否是对称字符串
		
		//调用方法
		boolean b = isSymmetry(s);
		
		//输出结果
		System.out.println("b:"+b);
	}
	
	/*
	 * 两个明确：
	 * 		返回值类型：boolean
	 * 		参数列表：String s
	 */
	public static boolean isSymmetry(String s) {
		//把字符串反转，和反转前的字符串进行比较，如果内容相同，就说明是对称字符串
		StringBuilder sb = new StringBuilder(s);
		sb.reverse();
		String result = sb.toString();
		
		return result.equals(s);
	}
}