JavaSE基础常用类2

最新推荐文章于 2022-12-31 14:19:34 发布

原创最新推荐文章于 2022-12-31 14:19:34 发布 · 314 阅读

0 ·

CC 4.0 BY-SA版权

1.String类其他方法

toLowerCase()：将大写字符转化成小写字符

toUpperCase()：将小写字符转化成大写字符

concat()：拼接字符串

package org.zst.String;
import java.util.Scanner;
public class Demo6 {
	public static void main(String [] args){
		//键盘录入一个字符串
		System.out.print("请输入字符串：");
		Scanner sc = new Scanner(System.in);
		String line = sc.nextLine();
		//截取字符串
		String s1 = line.substring(0, 1);
		//转换成小写
		String s2 = s1.toLowerCase();
		//截取其余 字符串转换成大写
		String s3 = line.substring(1);
		String s4 = s3.toUpperCase();
		//s2和s4拼接
		String result =s2.concat(s4);
		System.out.println("最终转换后的结果："+result);
		//String result2 = (line.substring(0, 1).toLowerCase().concat(line.substring(1).toUpperCase());
		//System.out.println("链式编程的到的结果："+result2);
	}
}

2.String中的一些功能

替换功能：

public String replace(char oldChar， char newChar):将字符串中某一个oldChar这个字符用newChar这个字符替换
public String replace(String oldStr， String newStr):将字符串中某一个子字符串用新的字符串替换
去除字符串两端空格：public String tirm()
两个字符串进行比较：public String compareTo(String anotherString) 是comparable接口里的一个方法，该接口可以实现一个自然排序

package org.zst.String;

public class Demo7 {
	public static void main(String [] args){
		String s = "halloween";
		//实现替换功能
		String s1=s.replace('l','y');
		System.out.println("替换其中一个字符后的字符串为："+s1);
		String s2 =s.replace("llo", "ssy");
		System.out.println("替换某子字符串后为："+s2);
		String s3="    Hello World    ";
		System.out.println("去除两端空格后的字符串为："+s3.trim());
		String s4 = "ssy";
		String s5 = "ssy";
		String s6 = "abc";
		String s7 = "ss";
		System.out.println("compareTo():"+s4.compareTo(s5));
		System.out.println("compareTo():"+s4.compareTo(s6));//s4第一个字符所在的位置减去s6第一个字符所在的位置得到的结果
	    System.out.println("compareTo():"+s4.compareTo(s7));//通过查看源码可知如果第一个字符相则直接返回length属性相减
	}
}

反转字符串：

package org.zst.String;
import java.util.Scanner;

public class Demo8 {
	public static void main(String[] args){

		Scanner sc = new Scanner(System.in);
		System.out.print("请输入字符串：");
		String line = sc.nextLine();
		String a = "";
		char[] chs = line.toCharArray();
		for(int x = chs.length-1;x>=0;x--){
			a += chs[x];	
		}
		System.out.println("翻转后的字符串为："+a);
	}
}

3.StringBuffer：线程安全的可变字符序列

面试题：StringBuffer和String的区别？

StringBuffer会构造一个字符串缓冲区，从内存角度考虑使用StringBuffer比较多（在单线程程序中使用StringBulider代替String，StringBuffer：线程不安全，单线程只是单纯为了提高执行效率）

String 代表一个普通字符串，从内存角度考虑比较耗费空间

StringBuffer的构造方法：

public StringBuffer()：构造一个其中不带字符的字符串缓冲区，其初始容量为16个字符

public StringBuffer(int capacity)：构造一个不带字符，但具有指定初始容量的字符串缓冲区

public StringBuffer(String str)：构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容，该字符串的初始容量为16加上字符串参数的长度

常用功能：

public int length()：获取长度数

public int capacit()：获取当前字符串缓冲区的容量

package org.zst.StringBuffer;

public class Demo {
	public static void main(String [] args){
		//StringBuffer sb = "halloween";  不能这样使用，直接用双引号括起来的是字符串类型
	    //创建一个字符串缓冲区对象
		StringBuffer sb = new StringBuffer();
		System.out.println("获取字符串缓冲区长度："+sb.length());
		System.out.println("获取字符串缓冲区容量:"+sb.capacity());
		
		StringBuffer sb2 = new StringBuffer(50);
		System.out.println("获取字符串缓冲区长度："+sb2.length());
		System.out.println("获取字符串缓冲区容量:"+sb2.capacity());
		
		StringBuffer sb3 = new StringBuffer("ssy");
		System.out.println("获取字符串缓冲区长度："+sb3.length());
		System.out.println("获取字符串缓冲区容量:"+sb3.capacity());
	}
}

4.StringBuffer中和添加有关的方法：

public StringBuffer append(int/String/char/long/double/short/float/obj……):当前这个方法追加，给缓冲区追加数据，返回的是字符串缓冲区本身

public StringBuffer insert(int offset,String str)：在某一个位置添加str这个字符串，返回的是字符串缓冲区本身

package org.zst.StringBuffer;

public class Demo2 {
	public static void main(String[] args){
		StringBuffer sb = new StringBuffer();
		sb.append("hello");
		sb.append(true);
		sb.append(12.45);
		sb.append('a');
		sb.append(14.32F);
		
		sb.insert(5, "zst");
		System.out.println("追加结果："+sb);
	}

}

5.StringBuffer的删除功能

public StringBuffer deleteCharAt(int index):删除指定位置处的字符，返回的是字符串缓冲区本。

public StringBuffer deleteCharAt(int start,int end):删除从指定位置开始到指定位置结束的字符，返回的是字符串缓冲区本身。

package org.zst.StringBuffer;

public class Demo3 {
	public static void main(String [] args){
	StringBuffer sb = new StringBuffer();
	sb.append("hello");
	sb.append("world");
	sb.append("你好，十一月");	
	sb.deleteCharAt(1);  //删除字符串中e这个字符
	sb.deleteCharAt(1);  //删除字符串中第一个l这个字符，注意当前第一个l的索引已经发生变化
	
	sb.delete(5, 9);  //包前不包后
	//sb.delete(0, sb.length());
	System.out.println("打印结果："+sb);
	}
}

6.StringbUffer和String之间的转换

类与类之间的转换
A类型--->B类型
这里面可能最终使用B类型里面的功能
B类型--->A类型
有时候需要的不是B类型,所以又要将B类型-->A类型
StringBuffer--->String之间的相互转换：public String toString()

面试题:
   StringBuffer和数组的区别?
   两个共同特点:都属于容器类型的变量
   数组:只能存储同一种数据类型的元素,数组的长度是固定的
int[] arr = {10,20,40,50,"hello"} 错误的
StringBuffer:字符串缓冲区,可以存储任意类型的元素,可以不断的去给缓冲区中追加(append),字符串缓冲区中:在内存始终返回的字符串

package org.zst.StringBuffer;
public class Demo5 {
	public static void main(String[] args) {
		//String--->StringBuffer
		//定义一个字符串
		String s = "hi" ;
		
		//方式1)使用StringBuffer的构造方式:StringBuffer(String str)
		//创建一个字符串缓冲区并指向这个字符串
		StringBuffer sb1 = new StringBuffer(s) ;
		System.out.println("方式一String到StringBuffer的转换:"+sb1);
		
		//方式2)创建字符串缓冲区对象,使用无参构造StringBuffer(),利用append()
		StringBuffer sb2 = new StringBuffer() ;
		sb2.append(s) ;
		System.out.println("方式二String到StringBuffer的转换:"+sb2);
		
		System.out.println("--------------------");
		
		//StringBuffer--->String
		//有一个字符串缓冲区对象
		StringBuffer buffer = new StringBuffer("ssy") ;
		//1)方式1String的另一种构造方法:String(StringBuffer buffer)
		String s2 = new String(buffer) ;
		System.out.println("方式一StringBuffer到String的转换："+s2);
		//2)方式2:/public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String
		String s3 = buffer.toString() ;
		System.out.println("方式二StringBuffer到String的转换:"+s3);
	}
}

7.StringBuffer的反转功能:

public StringBuffer reverse():将此字符串中的字符序列直接反转

package org.zst.StringBuffer;
import java.util.Scanner;

public class Demo4 {
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
	
		//录入并接收数据
		System.out.print("请您输入一个字符串:");
		String line = sc.nextLine() ;
		
		//可以创建字符串缓冲区对象
		StringBuffer sb = new StringBuffer(line) ;
		//public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String
		//反转功能
		 String result = sb.reverse().toString() ;
		 System.out.println("result:"+result);		
	}
}

8.StringBuffer的替换功能

public StringBuffer replace(int start,int end,String str):从指定位置开始到指定位置结束的字符用str子字符串替代

package org.zst.StringBuffer;
public class Demo6 {
	public static void main(String []args){
			StringBuffer sb = new StringBuffer();
			sb.append("hello");
			sb.append("world");
			sb.replace(1, 3, "ssy");
			System.out.println("sb:"+sb);	
		}
	}

9.StringBuffer的截取功能：

public StringBuffer subString(int start):从指定位置开始默认到截取末尾，返回值不是字符串缓冲区，返回值是一个新的字符串

public StringBuffer subString(int start，int end):从指定位置开始截取到指定位置结束，包前不包后，返回的是一个新的字符串

package org.zst.StringBuffer;
public class Demo7 {
	public static void main(String[] args){
		StringBuffer sb = new StringBuffer();
		sb.append("生活不止眼前的苟且");
		sb.append("还有远方的苟且");
		System.out.println("打印结果："+sb);
		
		String s1 = sb.substring(5);
		System.out.println("截取后的结果："+s1);
		
		String s2 = sb.substring(3, 6);
		System.out.println("第二次截取结果是："+s2);
	}
}

10.用String和StringBuffer实现将数组拼接成字符串

package org.zst.StringBuffer;
/* 将一个数组拼接成字符串，分别使用String和StringBuffer实现
 * */
public class Demo8 {
	public static void main(String[] args) {
		int [ ]arr = {5,9,8,3,7,6};
		String result =arrayToString(arr);
		String result2 = arrayToString2(arr);
		System.out.println("Result:"+result);
		System.out.println("Result2:"+result2);
	}
	//String方法
	public static String arrayToString(int [] arr){ 
		String result="";
		result +="[";
		for(int x = 0;x<arr.length;x++){
			if(x == arr.length-1){
				result+= arr[x];
				result+="]";
			}else{
				result+=arr[x];
				result+=" ";
			}
		}
		return result;  //注意返回值
	}
	//StringBuffer方法
	public static String arrayToString2(int[] arr){
		StringBuffer sb = new StringBuffer();
		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("]");
		return sb.toString();
	}
}

11.用String和StringBuffer实现反转字符串

package org.zst.StringBuffer;
import java.util.*;
public class Demo9 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.print("请您输入一个字符串：");
		String s= sc.nextLine();
		String result = getResult(s);
		System.out.println("用String倒着遍历的结果："+result);
		String result2 = getResult2(s);
		System.out.println("用StringBuffer倒着遍历的结果："+result2);
	}
	//String 方式进行反转
	public static String getResult(String s){
		String result = "";
		char[] chs = s.toCharArray();
		for(int x = chs.length-1;x>=0;x--){
			result += chs[x];
		}
		return result;
	}
	public static String getResult2(String s){
		/*StringBuffer sb = new StringBuffer(s);
		sb.reverse();
	
	return sb.toString();*/
		//链式编程
		return new StringBuffer(s).reverse().toString();
	}
}

12.String、StringBuffer、StringBulider的区别

String：一个不可变的字符序列

StringBuffer：一个可变的字符序列，从线程考虑，比String节省空间

StringBulider：一个可变的字符序列，在单个线程中优先使用，比String节省空间，线程不安全，不同步，执行效率高

13.StringheStringBuffer作为形式参数的区别

String作为形式参数和基本数据类型效果一样，StringBuffer和StringBulieder作为形式参数是引用数据类型效果

public class Demo10 {
	public static void main(String[] args) {
		String s = "hello";
		String s1 = "world";
		System.out.println(s+","+s1);
		change(s,s1);
		System.out.println(s+","+s1);
		StringBuffer sb = new StringBuffer("hello");
		StringBuffer sb1 = new StringBuffer("world");
		System.out.println(sb+","+sb1);
		change1(sb,sb1);
		System.out.println(sb+","+sb1);//缓冲区不变，变的是缓冲区的值
		}
	public static void change1(StringBuffer sb,StringBuffer sb1){
		sb = sb1;
		sb1.append(sb);
	}
	public static void change(String s ,String s1){
		s = s1;
		s1= s+s1;
	}
}

14.Integer类

jdk5.0之后的新特性：自动拆装箱，可变参数，增强for循环，静态导入，枚举……

每个基本数据类型都会被自动封装成一个引用类型，为了和String类型作转换

基本类型	引用类型
int	Integer
char	Character
byte	Byte
long	Long
double	Double
short	Short
float	Float
boolean	Boolean

public static String toBinaryString(int i ):以二进制无符号整数形式返回一个整数参数的字符串表示形式

public static String toOctalString(int i ):以八进制无符号整数形式返回一个整数参数的字符串表示形式

public static String toHexString(int i ):以十六进制无符号整数形式返回一个整数参数的字符串表示形式

public static fianl int MAX_VALUE：int类型能够表示的最大值

public static fianl int MIN_VALUE：int类型能够表示的最小值

package org.zst.Integer;
public class Demo {
	public static void main(String[] args) {
		System.out.println(Integer.toBinaryString(100));
		System.out.println(Integer.toOctalString(100));
		System.out.println(Integer.toHexString(100));
		System.out.println(Integer.MAX_VALUE);//一旦超过2^31的范围，Integer类不能使用
		System.out.println(Integer.MIN_VALUE);//一旦超过2^31的范围，Integer类不能使用
	}
}

15.Integer类的构造方式

public Integer(int value):将一个int类型数据封装成一个引用类型数据

public Integer(String str):将一个字符数类型封装成一个Integer类型数据

注意事项：此时的字符串必须时数字字符串，否则运行时会出现异常java.lang.NumberFormatException

package org.zst.Integer;
public class Demo2 {
	public static void main(String[] args) {
		Integer i = new Integer(100);
		//Integer i = 100;//Integer是一个引用类型，直接把基本类型赋值不报错是因为jdk5.0以后的自动封装箱
		System.out.println("i:"+i);
		String s = "2564";   //String s = "ssy";
		Integer j = new Integer(s);
		System.out.println("j:"+j); //编译时没有报错但是运行时出现异常java.lang.NumberFormatException，数字格式化异常
	}
}

16.int类型和String类型的相互转换

public int intValue():以int类型返回该Integer的值

public static int parseInt(String s ):将字符串参数作为有符号的十进制整数进行解析

public class Demo3 {
	public static void main(String[] args) {
		int num = 100;
		//方式一 空字符串拼接
		String s = ""+num;
		System.out.println("将int类型转换成String类型的第一种方式："+s);
		//方式二  int ————>Integer
		Integer i = new Integer(num);
		//Integer ——————>String
		String s1 = i.toString();
		System.out.println("将int类型转换成String类型的第二种方式："+s1);
		//方式三  public static String toString(int i)
		System.out.println("将int类型转换成String类型的第三种方式："+Integer.toString(100));
		Integer s2 = Integer.valueOf(num);  //方式四
		String s4 = s2.toString();
		System.out.println("将int类型转换成String类型的第四种方式："+s4);
		System.out.println("---------------------------------------");
		String a = "485634";
		//方式一 String ——————>Integer——————>int
		Integer j = new Integer(a);//此时a必须时数字字符串
		System.out.println("将String类型转换成int类型的第一种方式："+j.intValue());//public int intValue()：以int类型返回该Integer的值
		//方式二
		int b = Integer.parseInt(a);
		System.out.println("将String类型转换成int类型的第二种方式："+b);
	
	}
}

17.Character类

在对象中包装一个基本类型char的值，Character类型的对象包含类型为char的单个字段
构造方法： public Character(char value)：构造一个新分配的Character对象，用以表示指定的char值

package org.zst.Character;
public class Demo {
	public static void main(String[] args) {
		//Character c = new Character((char) 97);
		Character c = new Character('a');
		System.out.println("Character:"+c);
	}
}

Character类的判断功能:
public static boolean isLowerCase(char ch)确定指定字符是否为小写字母。
public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
public static boolean isDigit(char ch)确定指定字符是否为数字。

Character常用的转换功能:
public static char toUpperCase(char ch):将指定字符转换成大写
public static char toLowerCase(char ch):将指定字符转换成小写

package org.zst.Character;

public class Demo2 {
		public static void main(String[] args) {
	
			//public static boolean isLowerCase(char ch)确定指定字符是否为小写字母
			System.out.println("isLowerCase:"+Character.isLowerCase('a'));
			System.out.println("isLowerCase:"+Character.isLowerCase('A'));
			System.out.println("isLowerCase:"+Character.isLowerCase('0'));
			System.out.println("---------------------------------------");
			//public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
			System.out.println("isUpperCase:"+Character.isUpperCase('a'));
			System.out.println("isUpperCase:"+Character.isUpperCase('A'));
			System.out.println("isUpperCase:"+Character.isUpperCase('0'));
			System.out.println("---------------------------------------");
			//public static boolean isDigit(char ch)确定指定字符是否为数字。
			System.out.println("isDigit:"+Character.isDigit('a'));
			System.out.println("isDigit:"+Character.isDigit('A'));
			System.out.println("isDigit:"+Character.isDigit('0'));
			
		}
	}