day10_basic_class

Ayui.

已于 2023-07-31 14:34:19 修改

阅读量27

点赞数

分类专栏： 01_javase 文章标签： java

于 2023-07-26 09:49:57 首次发布

本文链接：https://blog.csdn.net/m0_61569709/article/details/131932344

版权

01_javase 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

本文展示了Java中字符串的转换方法，包括大小写转换、人民币数字表达、算术运算以及查找最大公共子串。同时，文章讨论了StringBuffer与StringBuilder在字符串缓冲区的应用，以及SimpleDateFormat用于日期格式化。此外，还提及了Integer等包装类在数据转换中的作用和特性，包括缓冲池的概念。

摘要由CSDN通过智能技术生成

1 作业

package day10_basic_class;

public class ZuoYe01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(test01("MyNameIsMiaoTianBao"));
		test02(12345678);
		test02(1234567891);
		test02(1234567091);
		test02(1234500091);
		test02(1234500000);
		str2Double("12343");
		str2Double("12343.34");
		System.out.println("最大共同子串：："+test04("abcdefg","12345"));
		System.out.println("最大共同子串：："+test04("123456789","12345"));
		System.out.println("最大共同子串：："+test04("abcdefg123kliuy","12345"));
		
		test03("1.0+1.3");
		test03("1.4/1.6");
		test03("13.1*12.6");

	}
//   1 写一个方法对字符串进行转换：MyNameIsMiaoTianBao   转化为 My name is miao tian bao
	public static String test01(String s) {
		String ss="";
		ss+=s.charAt(0);
		for (int i =1; i < s.length(); i++) {
			 char c=s.charAt(i);
			 //判断当前字符的类型
			 if(c<='Z'&&c>='A') {
				 c=(char)(c+('a'-'A'));
				 ss+=' ';
			 }
			 ss+=c;
		}
		return ss;
	}
//	2 写一个方法获取参数 整数对应的人民币叫法：：
//	          123456---一十二万三千四百五十六元整
	public static String test02(int n) {
		char[] arrDanWei= {'元','十','百','千'};
		String strHanZi="零一二三四五六七八九";
		String ssn=n+"";
		String ss="";
		//思路：倒着遍历ssn
		for (int i = 0; i <ssn.length(); i++) {
			 char c=ssn.charAt(ssn.length()-i-1);//获取当前字符  1
			//获取i的余数 
			 if(c!='0'||arrDanWei[i%4]=='元') {//0后面不能加单位
				 ss=arrDanWei[i%4]+ss;
			 }
			
			 ss=strHanZi.charAt(c-'0')+ss;
		}
		System.out.println(n+":::"+ss);
		//使用元切割
		String[] arr=ss.split("元");
		if(arr.length==1) {
			ss=arr[0]+"元";
		}else if(arr.length==2) {
			ss=arr[0]+"万"+arr[1]+"元";
		}else   if(arr.length==3) {
			ss=arr[0]+"亿"+arr[1]+"万"+arr[2]+"元";
		}
		System.out.println(n+":::"+ss);
		return ss;
	}
//	3 写一个方法对参数字符串进行运算(可能是：+ - * / %)：如果参数是1+1  返回的字符串是1+1=2		  
	public static String test03(String s) {
		//从s中截取出来运算符和两个数字
		int indexYsf=-1;
		if(s.contains("+")) {
			indexYsf=s.indexOf("+");
		}else if(s.contains("-")) {
			indexYsf=s.indexOf("-");
		}else if(s.contains("*")) {
			indexYsf=s.indexOf("*");
		}else if(s.contains("/")) {
			indexYsf=s.indexOf("/");
		}else if(s.contains("%")) {
			indexYsf=s.indexOf("%");
		}
		//获取运算符
		char ysf=s.charAt(indexYsf);
		//获取两个数组
		//"111.234"---111.234
		String s1=s.substring(0,indexYsf);
		String s2=s.substring(indexYsf+1);
		//转化为数字
		double d1=str2Double(s1);
		double d2=str2Double(s2);
		//运算：：
		double result=0;
		switch(ysf) {
		    case '+':
		    	result=d1+d2;break;	
		    case '-':
		    	result=d1-d2;break;	
		    case '*':
		    	result=d1*d2;break;	
		    case '/':
		    	result=d1/d2;break;	
		    case '%':
		    	result=d1%d2;break;	
		}
		String ss=s+"="+result;
		System.out.println(s+":::"+ss);
		return ss;
	}
	private static double str2Double(String s) {//1234.567
		double n=0;
		"111.23"---111.23
		//获取.的位置
		int indexDian=s.indexOf('.');//
		String ss=s.replace(".", "");//1234567
		for (int i = ss.length()-1,k=1; i >=0; i--,k*=10) {
			 n+=(ss.charAt(i)-'0')*k;
		}
		System.out.println(s+"::"+n);//1234567
		//如果有小数点 只需要ss/10 的n
		if(indexDian!=-1) {
			double k=Math.pow(10, s.length()-indexDian-1);
			n=n/k;
		}
		System.out.println(s+"::::"+n);
		return n;
	}
//	扩展题： 写一个方法获取两个字符串最大的公有子串：如：123456abcdef  3456ab123kjh  最大的共有子串是3456ab	
	public static String test04(String s1,String s2) {
		//1 获取小串
		String minStr=s1.length()>s2.length()?s2:s1;
		String maxStr=s1.length()>s2.length()?s1:s2;
		//2 遍历小串：获取小串的子串 判断 另外一个是否包含
		for (int i = minStr.length(); i >=1; i--) {//i表示的是子串字符个数
			 for (int j = 0; j <minStr.length()-i+1; j++) {
				   //获取子串
				   String ss=minStr.substring(j,j+i);
				   if(maxStr.contains(ss)) {
					   return ss;
				   }
			 }
		}
		return "";
	}
}

2 字符串缓冲区

方法

     * StringBuffer  StringBuilder :字符串缓冲区
	 * StringBuffer和StringBuilder的区别：
	 *     1 版本不同：StringBuffer -1.0
	 *                StringBuilder -1.5
	 *     2 是否线程安全： StringBuffer 线程安全 支持多线程 效率低
	 *                    StringBuilder 线程不安全 不支持多线程 效率高
	 * 相同之处：都是字符串缓冲区---字符序列可以更改
	 *          api兼容    
	 * StringBuffer  StringBuilder和String的区别
	 *      String是字符串常量 字符串对象一旦创建 字符序列不能更改
	 *      StringBuffer  StringBuilder 是字符串缓冲区   字符序列可以更改
	 *      
	 * 什么时候使用字符串缓冲区：对字符串进行频繁修改时：拼接/删除等
	 * 什么时候使用字符串：对字符序列不进行更改
	 *                          
	 * 构造方法：1 StringBuilder()   创建一个空字符的字符串缓冲区
	 *          2 StringBuilder(String seq) 创建一个和参数字符串相同序列的字符串缓冲区
	 * 特有普通方法：所有的返回值都是当前StringBuilder对象
	 *     1  StringBuilder append(String s) ;把参数字符串 提交到当前字符串缓冲区的后面
	 *     2  StringBuilder delete(int start, int end) : 删除start倒end-1处的所有字符
	 *        StringBuilder deleteCharAt(int index) ：删除指定下标处的字符
	 *     3  StringBuilder insert(int offset, String s)  ;把s插入倒 offset下标处
	 *     4  StringBuilder replace(int start, int end, String str) :使用str替换satrt到end-1处的字符
	 *     5  StringBuilder reverse() 反转
	 *     6  void setCharAt(int index, char ch)；设置指定位置处的字符为ch \
	 *     7  String toString()     
	 * 和String相同的方法：
	 *     1 char charAt(int index)   :获取参数下标处的字符 
	 *     2  int indexOf(String str)   ：获取str第一次出现的位置
	 *        int indexOf(String str,int startIndex) ：从startIndex位置处开始找
	 *        int lastIndexOf(String str)  ：倒着找
	 *        int lastIndexOf(String str,int startIndex)
	 *     3 int length()    ：字符个数
	 *     4 String substring(int start)   ：截取子串
	 *       String substring(int start, int end)

代码

package day10_basic_class;

public class Demo02StringBufferStringBuilder {
	public static void main(String[] args) {
		StringBuilder stb1=new StringBuilder("123");
		StringBuilder stb2=stb1.append("abc");
		System.out.println(stb1+":::"+stb2);
		System.out.println(stb1==stb2);
		//把当前对象返回给调用者的优点：实现方法连的操作
		//stb1.append("1").append("2").append(true);
		//new Student().setSex('男').setSid(11).setSname("韩梅梅");
		stb1=new StringBuilder("abcdefghijk");
		stb1.delete(1, 3);//adefghijk
		System.out.println(stb1);
		stb1=new StringBuilder("abcdefghijk");
		stb1.deleteCharAt(1);//acdefghijk
		System.out.println(stb1);
		stb1=new StringBuilder("abcdefghijk");
		System.out.println(stb1.insert(1, true));
		stb1=new StringBuilder("abcdefghijkabcdefghijk");
		System.out.println(stb1.replace(1, 5, "--"));//a--fghijkabcdefghijk
		stb1=new StringBuilder("abcdefghijk");
		System.out.println(stb1.reverse());//kjihgfedcba
		stb1=new StringBuilder("abcdefghijk");
		stb1.setCharAt(1, '-');
		System.out.println(stb1);//a-cdefghijk
	}
}
class Student{
	private int sid;
	private String sname;
	private char sex;
	public int getSid() {
		return sid;
	}
	public Student setSid(int sid) {
		this.sid = sid;
		return this;
	}
	public String getSname() {
		return sname;
	}
	public Student setSname(String sname) {
		this.sname = sname;
		return this;
	}
	public char getSex() {
		return sex;
	}
	public Student setSex(char sex) {
		this.sex = sex;
		return this;
	}	
}

练习

//	 *  1: 使用字符串缓冲区：写一个方法：吧参数字符串大写转为小写 小写转为大写 删除数字
public static String change1(String str) {
    //吧字符串转换为字符串缓冲区
    StringBuilder stb=new StringBuilder(str);
    // 遍历字符串缓冲区
    for (int i = 0; i < stb.length(); i++) {
        //获取当前字符
        char c=stb.charAt(i);
        //判断当前字符的类型
        if(c>='0'&&c<='9') {
            //删除当前字符
            stb.deleteCharAt(i);
            //删除一个 需要i--
            i--;
        }else if(c>='A'&&c<='Z') {
            stb.setCharAt(i, (char)(c+('a'-'A')));
        }else if(c>='a'&&c<='z') {
            stb.setCharAt(i, (char)(c-('a'-'A')));
        }
    }
    return stb.toString();
}
//	 *  2：使用字符串缓冲区：写一个方法：吧字符串缓冲区中的字符按编码表排序：如：abc123deGKL98--12389GKLabcde
public static String test02(String str) {
    //吧字符串转换为字符串缓冲区
    StringBuilder stb=new StringBuilder(str);
    for (int i = 0; i < stb.length()-1; i++) {
        for (int j=i+1; j < stb.length(); j++) {
            char ci=stb.charAt(i);
            char cj=stb.charAt(j);
            if(ci<cj) {
                stb.setCharAt(i, cj);
                stb.setCharAt(j, ci);
            }
        }
    }
    return stb.toString();
}

3 Simpledateformat

package day10_basic_class;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo01SimpleDateFormat {
	//SimpleDateFormat:字符串和日期之间的相互转换 日期格式化类
	//格式化（日期 -> 文本）、解析（文本 -> 日期）
	// 注意SimpleDateFormat只能解析或者格式化指定格式的字符串：：：
	
	//为了表示字符串的格式 使用预定义的字符来表示时间参数：
	//y-年
	//M-月
	//d-号
	//E-星期
	//H-时
	//m-分
	//s-秒
	
	/*构造方法：
	 *   1 SimpleDateFormat()； 字符串格式是固定的：
	 *   2 SimpleDateFormat(String partten)； 指定字符串格式：
	 *普通方法：
	 *    1 String format(Date date)    ； 由日期获取指定格式的字符串
	 *    2  Date parse(String source)  ；由指定格式的字符串获取日期对象  
	 * */
	
	public static void main(String[] args) throws Exception{
		   //1 创建一个字符串来指定字符串的格式
		  String pattern="yyyy年MM月dd号 E HH:mm:ss";//xxxx年xx月xx号 星期x xx:xx:xx
		  //2 创建一个日期格式化对象 并关联格式
		  SimpleDateFormat sdf=new SimpleDateFormat(pattern);
		  Date date=new Date();
		  //格式化方法：
		  System.out.println(sdf.format(date));//2022年09月09号 星期五 11:19:23
	      //解析方法
		  date=sdf.parse("2022年09月09号 星期五 11:19:23");//Unhandled exception type ParseException
		  System.out.println(date.toLocaleString());//2022-9-9 11:19:23
		  
		  
		  //无参数的日期格式化对象
		  sdf=new SimpleDateFormat();
		  //格式化方法：
		  System.out.println(sdf.format(date));//22-9-9 上午11:19
		  sdf=new SimpleDateFormat("yy-M-d aK:m");
		  //格式化方法：
		  System.out.println(sdf.format(date));//22-9-9 上午11:19
	}
}

4 包装类

java为了完全面向对象：为8种基本数据类型 提供8种对应的类---包装类
byte--Byte
short--Short
int----Integer
long---Long
float--Float
double--Double
boolean--Boolean
char--Character
包装类提供的功能：实现基本类型数据--包装类对象--字符串之间的相互转换
八种包装类种的方法基本一致：主学Integer和Character

Integer

 * Integer:int的包装类
	 * final static int BYTES:  ：所占的字节数
	 * final static int SIZE    ： 所占的bit位
	 * final static int MAX_VALUE :最大值
	 * final static int MIN_VALUE :最小值
	 * 
	 * 1：基本数据类型数据--包装类对象
	 *    1.1 构造方法：Integer(int value) 
	 *    1.2 静态方法：static Integer valueOf(int i)  
	 *    1.3 自动装箱： 包装类类型的引用=常量值;   ---编译器会自动把常量值通过构造方法创建一个包装类对象
	 * 
	 * 2：包装类对象---基本数据类型数据
	 *     2.1 实例方法：int intValue()  
	 *     2.2 自动拆箱：基本数据类型变量=包装类对象;  ----编译器会自动获取包装类的常量值赋值给变量
	 * 
	 * 3：包装类对象---字符串
	 *     3.1 实例方法：String toString() 
	 *     3.2 字符串拼接：+ 
	 *     
	 * 4：字符串---包装类对象
	 *      4.1 构造方法：Integer(String s) 
	 *      4.2 静态方法：static Integer valueOf(String s)           : 使用10进制解析s 
	 *                   static Integer valueOf(String s, int radix)：使用 radix进制解析s
	 * 5：基本数据类型数据--字符串
	 *      5.1 静态方法：static String toString(int i)  ：由整数i获取一个字符串    
	 *                   static String toString(int i, int radix) ：由整数i获取一个radix进制的字符串 
	 *      5.2 字符串拼接：+  
	 *      5.3 静态方法：static String toBinaryString(int i)  ；获取二进制字符串
	 *                  static String toHexString(int i)     ；获取十六进制字符串
	 *                  static String toOctalString(int i)   ；获取八进制字符串               
	 * 6：字符串--基本数据类型数据
	 *      6.1 静态方法：int parseInt(String s)  
	 *                   int parseInt(String s, int radix)

Integer的缓冲池

		  //内存中为integer自动装箱的对象定义一个缓冲区：存储了-128到127之间的256个对象
		  //当自动装箱的对象的值 与其中的值一致时 不新创建对象 直接使用缓冲区中的对象地址
		  //注意：仅限于自动装箱 并且仅限于值在[-128,127]之间的数据
		  Integer ii11=-128,ii12=-128,ii13=new Integer(-128);
		  Integer ii21=-129,ii22=-129;
		  Integer ii31=127,ii32=127;
		  Integer ii41=128,ii42=128;
		  System.out.println("ii11==ii12=="+(ii11==ii12));
		  System.out.println("ii11==ii13=="+(ii11==ii13));
		  System.out.println("ii21==ii22=="+(ii21==ii22));
		  System.out.println("ii31==ii32=="+(ii31==ii32));
		  System.out.println("ii41==ii42=="+(ii41==ii42));

Character

     * Character中的特有方法：
	 *  static boolean isDigit(char ch)  ：判断字符是不是数字
	 *  static boolean isLetter(char ch)  ：判断字符是不是单词字符--字母+汉字
	 *  static boolean isLetterOrDigit(char ch)  ：判断字符是不是数字或者单词字符
	 *  static boolean isLowerCase(char ch) ：判断字符是不是小写 
	 *  static boolean isUpperCase(char ch) ：判断字符是不是大写
	 *  static boolean isWhitespace(char ch) ：判断字符是不是空白字符 
	 *  static char toLowerCase(char ch)     ：字符转化为小写
	 *  static char toUpperCase(char ch)     ： 字符转化为大写