与字符串相关的类:
String类:
String的基本操作
package wwl.Class;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
/**
* 基本操作
*
*/
public class Stringclassoperating {
public static void main(String[] args) throws UnsupportedEncodingException {
String s1 = "hello,wwl"; //String底层是一个value[]字符数组来存储字符串的每个字符
//1.把字符串每个字符打印出来,charAt()返回指定索引值的字符
for (int i = 0; i < s1.length(); i++) {
System.out.print(s1.charAt(i));
}
//2.String类实现了Comparable接口,重写了compareTo()方法,根据字符码值比较大小
System.out.println("hehe".compareTo("hello")); //-4
System.out.println("张三".compareTo("李四")); //-2094
//3.format("格式串",格式化数据)
//%s字符串,%d整数,%b布尔,%f小数
System.out.println(String.format("姓名:%s,年龄:%d,婚否:%b,工资:%f", "feifei",28,false,30000.0));
//姓名:feifei,年龄:28,婚否:false,工资:30000.000000
//4.把字符串转化为字节数组
byte[] bytesss = "hello,王".getBytes();//把字符串以当前默认的编码转换为字节数组,在默认utf-8编码下汉字占三个字节
//在GBK编码下汉字占两个字节
System.out.println(Arrays.toString(bytesss));
bytesss = "hello,王".getBytes("GBK");//把字符串以指定的编码转换为字节数组,在其方法里声明了异常当编码错误时需要声明异常
System.out.println(Arrays.toString(bytesss));
//5.把字符串中的文件夹,文件名,扩展名分别分离出来
String text = "d:/wwl/src/wwl/Class/Stringclassoperating.java";
int lastSlashIndex = text.lastIndexOf("/");//返回字符串最后一次出现的位置
int dotIndex = text.indexOf(".");
String foleder = text.substring(0 , lastSlashIndex);
String filename = text.substring(lastSlashIndex+1 , dotIndex);
String suffix = text.substring(dotIndex+1);
System.out.println(foleder);
System.out.println(filename);
System.out.println(suffix);
//6.trim()去掉前后的空白字符
text = " Hello world ";
text = text.trim();
System.out.println(text);
//7.valueof()把其他类型数据转化为字符串
int num = 456;
text = "" + num;//字符串与基本类型数据连接,先把基本数据类型数据转换为字符串在连接
text = String.valueOf(num);
//8.toCharArray() 把字符串转换为字符数组
char[] content = "hello".toCharArray();
}
}
字符串的比较
package wwl.Class;
/**
* 字符串的比较
*/
public class Stringcompare {
public static void main(String[] args) {
String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2); //true
/*
* 关系运算符==判断的两个变量的值是否相等
* 表明s1变量和s2变量的值是相等的,说明s1和s2两个变量引用了同一个对象
* 在Java中,所有双引号引起来的字符串字面量都存储在字符串常量池中
* 当执行第一行 s1 = "hello"时,系统就把"hello"字面量保存到常量池中,把他的引用赋值给s1
* 当执行到第二行时s2 = "hello"时,系统直接把常量池中的"hello"字面量的引用赋值个s2
*/
System.out.println(s1.equals(s2));//true
String s3 = "he"+"llo";
System.out.println(s1 == s3);//true
/*
* 字符串字面量进行连接时,javac编译器会进行优化,
* 在编译阶段,把"he"+"llo"优化为"hello"
*/
String s4 = "hehe123";
String s5 = "hehe"+123;//字符串与整数连接系统会把整数转换为字符串在连接
System.out.println(s4 == s5);//true
/*
* 字符串字面量与整数字面量连接时,javac编译器也会进行优化
*/
int num = 123;
String s6 = "hehe" + num;
System.out.println(s5 == s6);//false,变量不会优化
}
}
创建String对象(包含几个方法的演示):
bytes->>Ascll码:getBytes()
字符分割
split():
parseInt:
integer包装类的方法,可以把字符串转化为十进制数字
String对象的不可变性:
Stringbulider/StringBuffer类
常用方法:append()添加
setCharAt(索引值,替换的数据) 替换数据
reverse() 字符串反序
delete(star,end)从索引star开始删除到索引end结束
日期类:
package wwl.Class;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.zip.DataFormatException;
import javax.xml.crypto.Data;
/**
* 日期类
*
*/
public class dataclasstest01 {
public static void main(String[] args) throws ParseException {
// 创建Date对象,返回当前日期
Date date = new Date();
System.out.println(date);
// 获得当前日期距离1970-1-1 00:00:00经过的毫秒数
long millis = System.currentTimeMillis();
System.out.println(millis);
// 根据毫秒数创建Data对象
Date date2 = new Date(millis);
System.out.println(date2);
date2 = new Date(millis + 1000*60*60*24);//一天
System.out.println(date2);
//把日期转换为指定的格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
System.out.println(sdf.format(date2));//2019年11月20日 16时05分52秒
//把日期字符串转换为Data对象
String text = "2088年9月20日 16时05分58秒";
sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
date = sdf.parse(text);
System.out.println(date);
}
}
结果:
数学类
package wwl.Class;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Random;
/**
* java.lang.math类(Math.random)
* 如果运算精度要求比较高,使用BigDecimal类
* java.util.random类产生随机数
*
*/
public class mathclass {
public static void main(String[] args) {
//math.random(),可以生成[0.0,1.0]范围内随即小数
for (int i = 0; i < 10; i++) {
System.out.println(Math.random());
}
System.out.println("---------------------------------------------");
//如果运算精度要求比较高,使用bigdecimal类
BigDecimal bd1 = new BigDecimal("6545645666666666666666666666666666666666666666666666666.123");
BigDecimal bd2 = new BigDecimal("654564566666666666666666666666666666666.123");
BigDecimal result = bd1.add(bd2);
System.out.println(result);
System.out.println("---------------------------------------------");
result = bd1.subtract(bd2);// 相减
result = bd1.multiply(bd2);
//相除时可能会出现除不断情况,出现异常
//result = bd1.divide(bd2);//出现异常
result = bd1.divide(bd2 , RoundingMode.DOWN);//舍入模式,尾数处理
System.out.println(result);
System.out.println("---------------------------------------------");
Random random = new Random();
//产生10个随机小数
for(int i = 1 ; i <= 10 ; i++) {
System.out.println(random.nextDouble());
}
System.out.println("---------------------------------------------");
//产生10个随机整数
for(int i = 1 ; i <= 10 ; i++) {
System.out.println(random.nextInt());
}
System.out.println("---------------------------------------------");
//产生[0-100)个随机整数
for(int i = 1 ; i <= 10 ; i++) {
System.out.println(random.nextInt(100));
}
}
}
包装类:
关系图
包装类对象的创建:
package wwl.Class;
/**
* 包装类对象创建
*
*/
public class packageapplication {
public static void main(String[] args) {
//1.根据基本类型创建包装类对象
Boolean boolean1 = new Boolean(true);
short s = 123;
Short short1 = new Short(s);
Integer integer1 = new Integer(123545);
Double double1 = new Double(3.14);
Character character1 = new Character('a');
//2.根据字符串创建包装类对象
boolean1 = new Boolean("true");
integer1 = new Integer("456");
double1 = new Double("45.789");
//注意1:字符串格式要符合数字的格式
// integer1 = new Integer("aa"); //数字格式异常
double1 = new Double("23e3"); //科学记数法
System.out.println(double1); //23000.0
//注意2:布尔类型的包装类对象把“true”字符串转换为true,其他字符串都转换为false
boolean1 = new Boolean("adsadasdas");
System.out.println(boolean1); //false
//注意3:character包装类只有一个构造方法(根据基本类型)没有根据字符串来创建的
// character1 = new Character("a");
//3.输出常用字段
System.out.println(Integer.BYTES); //字节数 ,4
System.out.println(Integer.SIZE); //位数: 32
System.out.println(Integer.TYPE); //基本类型:int
System.out.println(Integer.MIN_VALUE);
System.out.println(Integer.MAX_VALUE);
}
}
包装类的基本操作:
package wwl.Class;
/**
* 包装类的常用方法
*
*/
public class packageclassoperating{
public static void main(String[] args) {
Integer i1 = new Integer(123);
Integer i2 = new Integer("456");
//1.从Number继承的对象可以把包装类对象转换为基本类型数据
byte bb = i1.byteValue();
double dd = i2.doubleValue();
//2.包装类实现了comparable接口,重写了compareTo()方法,根据包装类的value字段比较大小
//每个包装类都有一个value字段,保存对应的基本类型的数据
System.out.println(i1.compareTo(i2)); //-1
Character c1 = new Character('A');
Character c2 = new Character('a');
System.out.println(c1.compareTo(c2)); //-32
Boolean b1 = new Boolean(true);
Boolean b2 = new Boolean(false);
System.out.println(b1.compareTo(b2)); //1
//3.equals(),根据value字段进行判断是否相等
System.out.println(i1.equals(i2)); //false
//4.parseInt(String s) 可以把字符串类型转换为基本类型数据,经常用!!!!!!!!!!!
int num = Integer.parseInt("789");
dd = Double.parseDouble("45.78");
//注意,字符串要符合数字格式
num = Integer.parseInt("adf"); //数字格式异常
//5.valueof() 把基本类型/字符串转化为包装类对象
i1 = Integer.valueOf(369);
i2 = Integer.valueOf("258");
}
}
装箱与拆箱:
package wwl.Class;
/**
* 装箱:
* 把基本类型转换为包装类对象
* 拆箱:
* 把包装类对象转换为基本类型
* 在Java中,可以自动的进行装箱与拆箱
*
*/
public class boxingandunboxing {
public static void main(String[] args) {
Integer i1 = 147;//自动装箱
int num = i1; //自动拆箱
Integer i2 = 666;//根据基本数据类型666创建了一个包装类对象,把这个包装类对象的引用赋值给i2
Integer i3 = 666;//重新创建了包装类对象
System.out.println(i2.equals(i3)); //true
Integer i4 = 77;
Integer i5 = 77;
System.out.println(i4 == i5);// true
/*
* Java认为-128~127之间的整数使用最频繁,所以这个范围内整数创建的包装类对象采用享元模式,即把包装类对象存储到
* 共享池中。在执行i4 = 77时,系统根据77创建一个Integer对象,把该对象存储到共享池中
* 当执行i5 = 77时,系统直接把共享池中的Integer对象的引用赋值给i5
*/
long gg1 = 15L;
long gg2 = 15L;
System.out.println(gg1 == gg2); //true
}
}
String Integer int相互转换:
package wwl.Class;
import wwl.interfaces.flyable.test;
/**
* String Integer int相互转换
*
*/
public class test10 {
public static void main(String[] args) {
// 1.int-->String
int num = 123;
String text = "" + num;//字符串与基本类型连接,会先把基本类型转换为字符串在连接
text = String.valueOf(num);
text = Integer.toString(num);
// 2.Integer-->String
Integer i1 = new Integer(789); // Integer是一个包装类必须进行实例化。类似于成员变量的实例化
text = i1.toString();//不重写显示完整类名和hash码的16进制
// 3.int-->Integer
i1 = num;//自动装箱
i1 = Integer.valueOf(num);
// 4.String-->Integer
i1 = Integer.valueOf(text);
// 5.String-->int
num = Integer.parseInt(text);
// 6.Interger-->int
num = i1;//自动拆箱
}
}