Java——面向对象编程高级级部分——第三部分——常用类
常用类
Java中各常用类：String，Math，Array等
String类
基本介绍
1.String对象用于保存字符串的，也就是一组字符序列
2.字符串常量是用双引号括起来的字符序列
3.字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节
4.String类有很多构造器（构造器重载）常用的构造方法
5.String实现了Serializable说明String可以串行化（可以再网络传输）
String实现了Comparable说明String可以比较
6.String类是final类，不能被其他类继承
7.String 有数学private final char value[] 用于存放字符串内容，该value是一个final类型，一旦赋值则不可再修改（此处的不可修改指的是value的地址，不再指向其他地址空/新对象，而不是value里的内容，单个字符的内容是可以变化的）
创建方式
1.直接赋值
String s="hsp";
先从常量池查看是否有“hsp”的数据空间，如果有，直接指向，如果没有，则重新创建，然后指向，s最终指向的是常量池的空间地址
2.调用构造器
String st=new String("hsp");
先在堆中创建空间，里面维护了一个value属性，指向常量池的hsp空间，如果常量池没有没有“hsp”,重新创建，如果有，直接通过value指向，最终指向的是堆中的空间地址
例题：
字符串特性
常量相加看的是池，变量相加，看到是堆
常见方法
String类是保存字符串常量的，每次关心都要重新开辟空间，效率较低，因此java设计者还提供了StringBuilder和StringBuffer来增强String的功能
toUpperCase：字符串全部转换为大写
toLowerCase：字符串全部转换为小写
concat ：字符串拼接
s1.replace（）方法执行后，返回的结果才是替换过的。对s1本身没有影响
split 注意特殊字符有时需要转义字符·
compareTo：比较两个字符串的大小
（1）如果长度相同，并且每个字符也相同，就返回0
（2）如果长度相同或者不相同，但在比较时可以区分大小，就返回前面-后面字符的计算结果
（3）如果前面的部分都相同，就返回两个字符串长度之差，前面字符串长度-后面字符串长度
format：格式化输出，把变量填充到占位符
StringBuffer类
基本介绍
1.StringBuffer类代表可变的字符序列，可以对字符串内容进行增删
2.StringBuffer是一个容器
StringBuffer 的直接父类是AbstractStringBuilder
StringBuffer 实现了Serializable，即StringBuffer的对象可以串行化
在父类中AbstractStringBuilder又熟悉char[] value，不是final类，该value数组存放字符串内容，因此存放在堆中，不再是常量池
StringBuffer类是一个final类，不可被继承
对比String类
1.String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低
2.StringBuffer类保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用每次更改地址（即不是每次都创建对象，空间不足时才会更改），效率较高
构造器
String和StringBuffer之间的相互转换
String -》StringBuffer
String str = "hhhhhh";
//1.
StringBuffer stringBuffer1=new StringBuffer(str);
//2.
StringBuffer stringBuffer = new StringBuffer();
stringBuffer = stringBuffer.append(str);
StringBuffer -》String
//1.
StringBuffer stringBuffer2=new StringBuffer("hhhh");
String s=stringBuffer2.toString();
//2.
String s1=new String(stringBuffer2)
常用方法
实例
StringBuilder类
基本介绍
1.一个可变的字符序列，此类提供一个与StringBuffer兼容的API，但是不保证同步（不是线程安全的，没有做互斥处理），该类被设计用做StringBuffer的一个建议替换，用在字符串缓冲区被单个线程使用的时候，如果可能，建议有限采用该类，因为在大多数时候，它比StringBuffer块
2.StringBuilder上的主要操作是append和insert非人非，可以重载这些方法，以接收任意类型的数据
其余各类特征与StringBuffer基本相同
String，StringBuffer，StringBuilder类的比较
1.StringBuilder后让StringBuffer非常类似，均代表可变的字符序列，而且方法也一样
2.String：不可变字符序列，效率低，但是复用率高
3.StringBuffer：可变字符序列，效率较高（增删），线程安全
4.StringBuilder：可变字符徐留俄，效率最高， 线程不安全
5.String使用注意说明：如果对String大量修改，不要使用String，多次操作会产生大量副本字符串对象存留在内存中，降低效率，如果这样的操作放到循环中，会极大的影响程序的性能
使用原则
1.如果字符串操作大量的修改操作，一般使用StringBuffer或StringBuilder
2.如果字符串操作大量的修改操作，并在单线程的情况，一般使用StringBuilder
3.如果字符串操作大量的修改操作，并在多线程的情况，一般使用StringBuffer
4.如果我们的字符串很少修改，被多个对象引用，使用String，比如配置信息
Math类
基本介绍
Math类包含用于执行基本数学运算的方法，均为静态方法
常用方法
random
返回的是 0<=x<1 之间的一个随机小数
//产生一个[0，1)之间的随机数。
Math.random()：
//返回指定范围的随机数(n-m之间)的公式:
Math.random()*(m-n)+n；//不包含m
Math.random()*(m+1-n)+m//包含m
应用：用Math类的random()方法产生一个字符，若该字符是一个大写英文字母，则输入 “Yes!”，否则输出“NO”。
random()方法产生的随机数在0.0和1.0之间，乘以128后，其值在0.0和128.0之间，将它转换为char类型后，用if来判断是否在’A’ 和’Z’之间。
public class IsUpper{
public static void main(String [] args){
char ch;
ch = ( char ) ( Math.random() * 128);
if ( ch >= 'A' && ch <= 'Z'){
System.out.println("Yes!");}
else{
System.out.println("No!");}
}
}
Math.random()方法语句基础上处理可获得多种类型、或任意范围的随机数。
int num=(int)(Math.random()*n); //返回大于等于0小于n之间的随机数
int num0=m+(int)(Matn.randon()*n); //返回大于等于m小于m+n（不包括m+n）之间的随机数
1.随机生成a~z之间的字符
2.随机生成cha1~cha2的字符
(char)('a'+Math.random()*('z'-'a'+1));
(char)(cha1+Math.random()*(cha2-cha1+1));
Arrays类
基本介绍
Arrays里面包含了一系列静态方法，用于管理或操作数组
常用方法
冒泡排序
public static void bubble(int[] arr)
{
int temp=0;
for (int i = 0; i <arr.length-1 ;i++) {
for (int j = 0; j < arr.length-i-1; j++) {
if(arr[j]>arr[j+1])
{
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
实现定制排序
package hsp;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
public class Exception01 {
public static void main(String[] args) {
int[] arr={1,-1,8,0,20};
//bubble01(arr);
System.out.println(Arrays.toString(arr));
bubble02(arr, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
int i1=(Integer) o1;
int i2=(Integer) o2;
return i1-i2;//i2-i1也可以，决定返回值大于0还是小于0
}
});
}
public static void bubble01(int[] arr)
{
int temp=0;
for (int i = 0; i <arr.length-1 ;i++) {
for (int j = 0; j < arr.length-i-1; j++) {
if(arr[j]>arr[j+1])
{
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
public static void bubble02(int[] arr, Comparator c){
int temp=0;
for (int i = 0; i <arr.length-1 ;i++) {
for (int j = 0; j < arr.length-i-1; j++) {
if(c.compare(arr[j],arr[j+1])>0)
{
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
}
二分搜索查找
1.要求数组必须有序，如果数组无需不能使用二分搜索查找
2.如果数组中不存在改元素就返回 return -（low+1）
int[] arr = {1, 2, 98, 123, 456};
int index=Arrays.binarySearch(arr,-123);
System.out.println(index);
拷贝
如果拷贝长度>arr.length 就在数组后面增加null
如果拷贝长度小于0，就抛出异常
int[] arr = {1, 2, 98, 123, 456};
int[] newarr=Arrays.copyOf(arr,arr.length);
数组填充fill
使用替换原理
int[] arr = {1, 2, 98, 123, 456};
Arrays.fill(arr,99);
实例
字符串反转
public class Exception01 {
public static void main(String[] args) {
String str="abcdef";
String re=reverse(str,1,4);
System.out.println(re);
}
//把String转成char[] ,因为char[] 的数组是可以交换的
public static String reverse(String str,int start,int end){
char[] chars=str.toCharArray();
char temp=' ';
for (int i = start,j=end; i < j; i++,j--) {
temp=chars[i];
chars[i]=chars[j];
chars[j]=temp;
}
return new String(chars);
}
}
代码改进：
public class Exception01 {
public static void main(String[] args) {
String str="abcdef";
String re;
try {
re = reverse(str,1,4);
} catch (Exception e){
System.out.println(e.getMessage());
return ;
}
System.out.println(re);
}
//把String转成char[] ,因为char[] 的数组是可以交换的
public static String reverse(String str,int start,int end){
if(!(str!=null&&start>=0&&end>start&&end<str.length()))
{
throw new RuntimeException("参数错误");
}
char[] chars=str.toCharArray();
char temp=' ';
for (int i = start,j=end; i < j; i++,j--) {
temp=chars[i];
chars[i]=chars[j];
chars[j]=temp;
}
return new String(chars);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
