一.String类中的其它功能
1.替换功能:
public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换
public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新 的字符串去替代
2.去除字符串两端空格:
public String trim()
3.两个字符串进行比较:
public int compareTo(String anotherString) 是Comparable接口中的方法(该接口可以实现一个自然排序)
例子:
public class StringDemo {
public static void main(String[] args) {
//定义字符串
String s1 = "helloworld" ;
//替换功能
// public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换
// String s2 = s1.replace('l', 'k') ;
// System.out.println("s:"+s2);
//public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新 的字符串去替代
String s3 = s1.replaceAll("owo", "ak47") ;
System.out.println("s3:"+s3);
System.out.println("------------------");
String s4 = " hello world " ;
System.out.println("s4:"+"----"+s4+"----");
//public String trim()
String s5 = s4.trim() ;
System.out.println("s5:"+"----"+s5+"----");
//public int compareTo(String anotherString)
String s6 = "hello" ;
String s7 = "hello" ;
String s8 = "abc" ;
System.out.println("compareTo():"+s6.compareTo(s7));
System.out.println("compareTo():"+s6.compareTo(s8));
}
}
二.StringBuffer
1.StringBuffer的构造方法:
public StringBuffer ()构造一个其中不带字符的字符串缓冲区,其初始容量为 16 个字符
public StringBuffer(int capacity)构造一个不带字符,但具有指定初始容量的字符串缓冲区
public StringBuffer(String str)构造一个字符串缓冲区,并将其内容初始化为指定的字符串内容。该字符串的初始 容量为 16 加上字符串参数的长度。
2.常用的功能:
public int length():获取字符串长度数
public int capacity():获取当前字符串缓冲区的容量
例子:
public class StringBufferDemo {
public static void main(String[] args) {
// StringBuffer sb = "hello" ;
// String s = "hello" ;
// StringBuffer sb = s ;
// public StringBuffer ()构造一个其中不带字符的字符串缓冲区,其初始容量为 16 个字符
//创建一个字符串缓冲区对象
StringBuffer sb = new StringBuffer() ;
System.out.println("sb.length:"+sb.length());
System.out.println("sb.capacity:"+sb.capacity());//16
System.out.println("----------------------------");
// public StringBuffer(int capacity)构造一个不带字符,但具有指定初始容量的字符串缓冲区
StringBuffer sb2 = new StringBuffer(50) ;
System.out.println("sb2.length:"+sb2.length());
System.out.println("sb2.capacity:"+sb2.capacity());//50
System.out.println("----------------------------");
StringBuffer sb3 = new StringBuffer("hello") ;
System.out.println("sb3.length:"+sb3.length());
System.out.println("sb3.capacity:"+sb3.capacity());//默认:初始容量16 + 当前字符串长度
}
}
面试题:
StringBuffer和String 的区别?
StringBuffer会构造一个字符串缓冲区,从内存角度考虑,一般情况使用StringBuffer比较多(在单线程程序中使 用StringBulider替代
StringBuffer:线程不安全,单线程单纯为了提供执行效率!)
String:普通的一个字符串,从内存角度考虑,耗费空间!
3.StringBuffer中的和添加有关的方法
public StringBuffer append(int/String/char/boolean/double/float....):当前这个方法追加,给缓冲中追加数据,返回字 符串缓冲区本身(经常使用的)
public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身
例子:
public class StringBufferDemo2 {
public static void main(String[] args) {
//创建一个字符串缓冲区对象
StringBuffer sb = new StringBuffer() ;
//追加数据
/* sb.append("hello") ;
sb.append(true) ;
sb.append(13.45) ;
sb.append('A') ;
sb.append(12.56F);*/
//链式编程
sb.append("hello").append(true).append(13.45).append('A').append(12.56F);
//public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身
sb.insert(5, "world") ;
//输出
System.out.println("sb:"+sb);
}
}
4.StringBuffer的删除功能:
public StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回的是字符串缓冲区本身!
public StringBuffer delete(int start,int end):删除从指定位置开始到指定位置结束的字符,返回的是字符串缓冲区本身!
例子:
public class StringBufferDemo3 {
public static void main(String[] args) {
//创建字符串缓冲区对象
StringBuffer sb = new StringBuffer() ;
//给缓冲区追加数据
sb.append("hello") ;
sb.append("world") ;
sb.append("java") ;
public StringBuffer deleteCharAt(int index)
//需求:要删除当前缓冲区中'e'这个字符
// sb.deleteCharAt(1) ;
//需求:要删除当前缓冲区中第一个'l'这个字符
// sb.deleteCharAt(1) ;
// public StringBuffer delete(int start,int end)
// sb.delete(5, 9) ;
//从0索引开始,当前缓冲的字符串全部删除掉
sb.delete(0, sb.length()) ;
//输出
System.out.println("sb:"+sb);
}
}
public StringBuffer reverse():将此字符串中的字符序列直接反转
例子:
public class StringBufferDemo4 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//录入并接收数据
System.out.println("请您输入一个字符串:");
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);
}
}
6.StringBuffer的替换功能:
public StringBuffer replace(int start, int end,String str)
从指定位置开始到指定位置结束的字符用str子字符串去替代
例子:
public class StringBufferDemo5 {
public static void main(String[] args) {
//创建字符串缓冲区对象
StringBuffer sb = new StringBuffer() ;
//给缓冲添加数据
sb.append("hello") ;
sb.append("world") ;
sb.append("java") ;
//public StringBuffer replace(int start, int end,String str)
sb.replace(5, 10, "节日快乐") ;
System.out.println("sb:"+sb);
}
}
7.StringBuffer的截取功能:
public String substring(int start):从指定位置默认截取到末尾,返回值是一个新的字符串
public String substring(int start,int end):从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串
例子:
public class StringBufferDemo6 {
public static void main(String[] args) {
//创建字符串缓冲区对象
StringBuffer sb = new StringBuffer() ;
//添加
sb.append("hello") ;
sb.append("world") ;
sb.append("java") ;
//public String substring(int start)
// String s1 = sb.substring(5) ;
// System.out.println("s1:"+s1);
//public String substring(int start,int end)
String s2 = sb.substring(5,10) ;
System.out.println("s2:"+s2);
System.out.println("sb:"+sb);
}
}
面试题:
String,StringBuffer,StringBuilder的区别?
String:一个不可变的字符序列,StringBuffer:和StringBuilder是可变的字符序列,在单个线程时候的时候(优先 采用StringBuilder)
从线程角度考虑:
StringBuilder线程不安全,不同步,执行效率高!它比StringBuffer要快!
面试题:
StringBuffer和数组的区别?
两个共同特点:都属于容器类型的变量
数组:只能存储同一种数据类型的元素,数组的长度是固定的
int[] arr = {10,20,40,50,"hello"} 错误的
StringBuffer:字符串缓冲区,可以存储任意类型的元素,可以不断的去给缓冲区中追加(append),字符串缓冲区 中:在内存始终返回的字符串
8.
类与类之间的转换
A类型--->B类型
这里面可能最终使用B类型里面的功能
B类型--->A类型
有时候需要的不是B类型,所以又要将B类型-->A类型
StringBuffer--->String之间的相互转换
例子:
public class StringBufferTest {
public static void main(String[] args) {
//String--->StringBuffer
//定义一个字符串
String s = "hello" ;
/*StringBuffer sb = "hello" ;
StringBuffer sb = s ;*/
//方式1)使用StringBuffer的构造方式:StringBuffer(String str)
//创建一个字符串缓冲区并指向这个字符串
StringBuffer sb = new StringBuffer(s) ;
System.out.println("sb:"+sb);
//方式2)创建字符串缓冲区对象,使用无参构造StringBuffer(),利用append()
StringBuffer sb2 = new StringBuffer() ;
sb2.append(s) ;
System.out.println("sb2:"+sb2);
System.out.println("--------------------");
//StringBuffer--->String
//有一个字符串缓冲区对象
StringBuffer buffer = new StringBuffer("world") ;
//1)方式1String的另一种构造方法:String(StringBuffer buffer)
String s2 = new String(buffer) ;
System.out.println("s2:"+s2);
//2)方式2:/public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String
String s3 = buffer.toString() ;
System.out.println("s3:"+s3);
}
}
二.Integer
1.说明:java的jkd5.0以后:还有一些新特性:自动拆装箱,可变参数,增强for循环,静态导入,枚举...
对于每个基本数据类型都会被自动封装成一个引用类型
基本类型 引用类型
int Integer
char Character
byte Byte
boolean Boolean
double Double
float Float
long Long
short Short
将基本类型--->引用类型的作用:就是为了和String类型作为转换
举例:
public class IntegerDemo {
public static void main(String[] args) {
//public static String toBinaryString(int i)
System.out.println(Integer.toBinaryString(100)) ;
//public static String toOctalString(int i)
System.out.println(Integer.toOctalString(100));
//public static String toHexString(int i)
System.out.println(Integer.toHexString(100));
//public static final int MAX_VALUE
//public static final int MIN_VALUE
System.out.println(Integer.MAX_VALUE);//2147483647
System.out.println(Integer.MIN_VALUE);//-2147483647
}
}
2.Integer类的构造方式:
public Integer(int value):将一个int类型的数据封装成一个引用类型
public Integer(String s):将一个字符串类型封装成一个Integer类型
注意事项:
该字符串必须是数字字符串!,否则:java.lang.NumberFormatException
例子:
public class IntegerDemo2 {
public static void main(String[] args) {
// public Integer(int value)
//创建一个Integer对象
Integer i = new Integer(100);
// Integer i = 100 ;//jdk5以后的自动装箱!
System.out.println("i:"+i);
//public Integer(String s)
// String s = "abc" ;
String s = "20" ;
Integer ii = new Integer(s) ;
System.out.println("s:"+s);
}
}
3.int类型和String类型的相互转换
例子:
public class IntegerTest {
public static void main(String[] args) {
//定义一个int类型的数据
int number = 100 ;
//方式1)字符串拼接符
String s1 = "" + number ;
System.out.println("s1:"+s1);
//方式2:int--->Integer类型
Integer i = new Integer(number) ;
//Integer--->String
//public String toString()
String s2 = i.toString() ;
System.out.println("s2:"+s2);
//方式3)public static String toString(int i)
String s3 = Integer.toString(number) ;
System.out.println("s3:"+s3);
//方式4)
//public static Integer valueOf(int i)
Integer integer= Integer.valueOf(number) ;
String s4 = integer.toString() ;
System.out.println("s4:"+s4);
System.out.println("---------------------------");
//定义一个字符串:
String s = "10" ;
//方式1:String--->Integer---->int
Integer ii = new Integer(s) ;
//public int intValue()以 int 类型返回该 Integer 的值
int num = ii.intValue() ;
System.out.println("num:"+num);
//public static int parseInt(String s)
int num2 = Integer.parseInt(s) ;
System.out.println("num2:"+num2);
//Integer的内存缓存区:IntegerCashe
//low = -128
//high=127
Integer i1 = 127 ; //----->底层在封装的时候:Integer integer = Inteter.valueOf(int i) ;
Integer i2 = 127 ;
System.out.println(i1==i2);//true
Integer i3 = 128 ;
Integer i4 = 128 ;
System.out.println(i3==i4);//false
}
}
4. Jdk5.0以后的新特性:自动拆装箱
例子:
public class IntegerTest2 {
public static void main(String[] args) {
//创建一个Integer对象
Integer i = new Integer(100) ;
i += 200 ;
System.out.println("i:"+i);
/**
* 通过反编译工具查看源码:
* Integer i = new Integer(100); //将int类型值通过构造的形式自动装箱为Integer类型
i = Integer.valueOf(i.intValue() + 200);//i.intValue()--->int类型的数据:把Integer--->int:自动拆箱
自动装箱了
System.out.println((new StringBuilder("i:")).append(i).toString());
*/
}
}
三.character类
1. Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段
2. 构造方法:
public Character(char value)构造一个新分配的 Character 对象,用以表示指定的 char 值。
例子:
public class CharacterDemo {
public static void main(String[] args) {
//创建一个Character类的对象
// Character character = new Character((char)97) ;
Character character = new Character('a') ;
System.out.println("character:"+character);
}
}
3.Character类的判断功能:
public static boolean isLowerCase(char ch)确定指定字符是否为小写字母。
public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
public static boolean isDigit(char ch)确定指定字符是否为数字。
4. Character常用的转换功能:
public static char toUpperCase(char ch):将指定字符转换成大写
public static char toLowerCase(char ch):将指定字符转换成小写
例子:
public class CharacterDemo2 {
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'));
}
}
冒泡排序的思想:
两两比较,大的往后放,第一次比完,最大值出现在最大索引处,依次进行这样的比较....
算法如下:
public static void bubbleSort(int[] arr){
for(int x = 0 ; x < arr.length-1; x ++){
for(int y = 0 ; y < arr.length-1-x ; y++){
//判断
if(arr[y]>arr[y+1]){
int temp = arr[y] ;
arr[y] = arr[y+1] ;
arr[y+1] = temp ;
}
}
}
}