java基础 day15 常用类(方法) 包装类

最新推荐文章于 2023-06-15 22:40:09 发布

龙是我吗？

最新推荐文章于 2023-06-15 22:40:09 发布

阅读量155

点赞数 1

分类专栏： Java

本文链接：https://blog.csdn.net/qq_21694049/article/details/103112093

版权

Java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

与字符串相关的类：

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;//自动拆箱
		
	}
}