JavaSE基础常用类2

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类型转换StringString 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类型作转换

基本类型引用类型intIntegercharCharacterbyteBytelongLongdoubleDoubleshortShortfloatFloatbooleanBooleanpublic 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 ————>IntegerInteger i = new Integer(num);//Integer ——————>StringString 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——————>intInteger 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'));}}