JAVA基础九 数字与字符串

JAVA基础九 数字与字符串

01 装箱与拆箱

1.1 封装类

所有的基本类型，都有对应的类类型。比如int对应的类是Integer，这种类就叫做封装类。
其他基本类型对应的封装类：

基本类型	封装类
char	Character
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

public static void main(String[] args) {
    int i = 5;   
    //把一个基本类型的变量,转换为Integer对象
    Integer it = new Integer(i);
    //把一个Integer对象，转换为一个基本类型的int
    int i2 = it.intValue();    
}

1.2 Number类

数字封装类有Byte，Short，Integer，Long，Float，Double，这些类都是抽象类Number的子类。

	int i=5;
	Integer it =new Integer(i);
	System.out.println(it instanceof Number);//ture

1.3 基本类型转封装类

基本语法：类类型 变量=new 基本类型(值)；

	int i=5;
	Integer it =new Integer(i);//基本类型转封装类

1.4 封装类转基本类型

基本语法：基本类型 变量=封装类变量.基本类型Value();

	int i=5;
	Integer it =new Integer(i);//基本类型转封装类
	int it2=it.intValue();//封装类转基本类型
	System.out.println(it2);//output:5

1.5 自动装箱

不需要调用构造方法，通过=符号自动把 基本类型 转换为 类类型 就叫装箱。

	int i=5;
	Integer it =i;//自动装箱
	System.out.println(it);//output:5

1.6 自动拆箱

不需要调用Integer的intValue方法，通过=就自动转换成int类型，就叫拆箱。

	int i=5;
	Integer it =i;//自动装箱
	int i2=it;//自动拆箱
	System.out.println(i2);//output:5

1.7 int的最大值，最小值

int的最大最小值值可以通过其对应的封装类Integer.MAX_VALUE和Integer.MIN_VALUE获取。

	System.out.println(Integer.MAX_VALUE);//int的最大值
	System.out.println(Integer.MIN_VALUE);//int的最小值

1.8 练习-装箱拆箱

1. 对byte,short,float,double进行自动拆箱和自动装箱
2. byte和Integer之间能否进行自动拆箱和自动装箱
3. 通过Byte获取byte的最大值

	//类似地进行自动拆箱和自动装箱
		byte b=1;
		Byte b1=b;//自动装箱
		byte b2=b1;//自动拆箱
		System.out.println(b1);
		System.out.println(b2);
		
		short s=2;
		Short s1=s;//自动装箱
		short s2=s1;;//自动拆箱
		System.out.println(s1);
		System.out.println(s2);
	//byte和Integer之间能否进行自动拆箱和自动装箱
		byte b=1;
		//Integer i=b;//byte转Integer装箱失败
		Byte b1=b;//自动装箱
		int i2=b1;//Byte转int,拆箱可以
		System.out.println(i2);
		int i3=3;
		//Byte b2=i3;//int转Byte，装箱失败
		Integer i4=i3;
		//byte b3=i4;//Integer转byte失败，拆箱失败
	通过Byte获取byte的最大值
		System.out.println(Byte.MAX_VALUE);//output:127

02 字符串转换

2.1 数字转字符串

1. 使用String类的静态方法valueOf；
2. 先把基本类型装箱为对象，然后调用对象的toString。

	//方法1	
	int i=5;
	String s=String.valueOf(i);
	//方法2
	Integer i1=i;
	String s2=i1.toString();
	
	System.out.println(s);
	System.out.println(s2);

2.2 字符串转数字

调用Integer的静态方法parseInt。

	String st="6";
	int i=Integer.parseInt(st);
	System.out.println(i);

2.3 练习-字符串转换

1. 把浮点数 3.14 转换为 字符串 “3.14”；
2. 再把字符串 “3.14” 转换为 浮点数 3.14；
3. 如果字符串是 3.1a4，转换为浮点数会得到什么？

//把浮点数 3.14 转换为 字符串 "3.14"；
	float f=3.14f;
	//方法1
	String s=String.valueOf(f);
	//方法2
	Float f2=f;
	String s2=f2.toString();
	System.out.println(s);
	System.out.println(s2);
//再把字符串 “3.14” 转换为 浮点数 3.14；
	float f3=Float.parseFloat(s);
	System.out.println(f3);
//如果字符串是 3.1a4，转换为浮点数会得到什么
	String s3="3.1a4";
	float f3=Float.parseFloat(s3);
	System.out.println(f3);
	//Excption

03 数学方法

java.lang.Math提供了一些常用的数学运算方法，并且都是以静态方法的形式存在。

运算方法	含义
round()	返回一个四舍五入后的整数
random()	返回一个0-1之间的随机浮点数（取不到1）
sqrt()	返回一个平方根结果
pow(a,b)	返回a的b次方结果
PI	返回常数Π的值
E	返回自然常数的值

	public static void main(String[] args) {
        float f1 = 5.4f;
        float f2 = 5.5f;
        //5.4四舍五入即5
        System.out.println(Math.round(f1));
        //5.5四舍五入即6
        System.out.println(Math.round(f2));
         
        //得到一个0-1之间的随机浮点数（取不到1）
        System.out.println(Math.random());
         
        //得到一个0-10之间的随机整数 （取不到10）
        System.out.println((int)( Math.random()*10));
        //开方
        System.out.println(Math.sqrt(9));
        //次方（2的4次方）
        System.out.println(Math.pow(2,4));
         
        //π
        System.out.println(Math.PI);
         
        //自然常数
        System.out.println(Math.E);
    }

练习1-数学方法

借助Math的方法，把自然对数计算出来，看看经过自己计算的自然对数和Math.E的区别有多大？

	int n=Integer.MAX_VALUE;
	double d=Math.pow(1+1.0/n, n);//1要改写成1.0（或1d，标识double类型）
	System.out.println(d);
	System.out.println(Math.E);

练习2-质数

统计找出一千万以内，一共有多少质数？

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int max=1000*10000;
		int count=0;
		for(int i=1;i<=max;i++) {
			if(isPrime(i)) {
				count++;
			}
		}
		System.out.println(max+"之内有质数"+count+"个");
		
	}
	private static boolean isPrime(int i) {
			
			for(int j=2;j<=Math.sqrt(i);j++) {
				if(i%j==0) {
					return false;
				}
			}
			return true;
	}

补充：埃拉托斯特尼筛法link。

04 格式化输出

4.1 格式化输出

使用格式化输出，可以使得代码变得简洁明了。

符号	含义
%s	字符串
%d	数字
%n	换行

	String name ="盖伦";
    int kill = 8;
    String title="超神";
        
    //直接使用+进行字符串连接，编码感觉会比较繁琐，并且维护性差,易读性差
    String sentence=name+"进行了连续"+kill+"次击杀后，获得了"+title+"的称号！";
    System.out.println(sentence);
        
    //使用格式化输出
    String sentence2="%s进行了连续%d次击杀后，获得了%s的称号!%n";
    System.out.printf(sentence2,name,kill,title);
	}

4.2 printf和format

printf和format能够达到一模一样的效果，如何通过eclipse查看java源代码 可以看到，在printf中直接调用了format。

	String name ="盖伦";
    int kill = 8;
    String title="超神";
    
	String sentenceFormat ="%s 在进行了连续 %d 次击杀后，获得了 %s 的称号%n";
    //使用printf格式化输出
    System.out.printf(sentenceFormat,name,kill,title);
    //使用format格式化输出
    System.out.format(sentenceFormat,name,kill,title);
    //System.out.printf = System.out.format.

4.3 换行符

换行符就是另起一行 — ‘\n’ 换行（newline）
回车符就是回到一行的开头 — ‘\r’ 回车（return）
在eclipse里敲一个回车，实际上是回车换行符，Java是跨平台的编程语言，同样的代码，可以在不同的平台使用，比如Windows，Linux，Mac
然而在不同的操作系统，换行符是不一样的：
（1）在DOS和Windows中，每行结尾是 “\r\n”；
（2）Linux系统里，每行结尾只有 “\n”；
（3）Mac系统里，每行结尾是只有 “\r”。
为了使得同一个java程序的换行符在所有的操作系统中都有一样的表现，使用%n，就可以做到平台无关的换行。

4.4 其他常用的格式化方式

符号	含义
%d	直接打印数字
%8d	总长度是8，默认右对齐
%-8d	总长度是8，左对齐
%08d	总长度是8，不够补0
%,d	千位分隔符
%.2f	小数点位数

	int year = 2020;
    //总长度，左对齐，补0，千位分隔符，小数点位数，本地化表达
          
    //直接打印数字
    System.out.format("%d%n",year);
    //总长度是8,默认右对齐
    System.out.format("%8d%n",year);
    //总长度是8,左对齐
    System.out.format("%-8d%n",year);
    //总长度是8,不够补0
    System.out.format("%08d%n",year);
    //千位分隔符
    System.out.format("%,8d%n",year*10000);
  
    //小数点位数
    System.out.format("%.2f%n",Math.PI);
          
    //不同国家的千位分隔符
    System.out.format(Locale.FRANCE,"%,.2f%n",Math.PI*10000);
    System.out.format(Locale.US,"%,.2f%n",Math.PI*10000);
    System.out.format(Locale.UK,"%,.2f%n",Math.PI*10000);

4.5 练习

效果示例：

	public static void main(String[] args) {
	// TODO Auto-generated method stub
	String[] a= {"请输入地名：","请输入公司类型：","请输入公司名称：","请输入老板名称：","请输入金额：","请输入产品：","请输入价格计量单位："};
		
		for(int i=0;i<=6;i++) {
			System.out.println(a[i]);
			a[i]=scan();
		}
		String sentence="%s最大%s%s倒闭了，王八蛋老板%s吃喝嫖赌，欠下了%s个亿，%n带着他的小姨子跑了!我们没有办法，拿着%s抵工资!原价都是一%s多、两%s多、三%s多的钱包，%n现在全部只卖二十块，统统只要二十块!%s王八蛋，你不是人!我们辛辛苦苦给你干了大半年，%n你不发工资，你还我血汗钱，还我血汗钱!";
		System.out.printf(sentence,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[6],a[6],a[5],a[3]);
	}
	private static String scan() {
		Scanner s=new Scanner(System.in);
		String t=s.nextLine();
		return t;
	}

05 字符

5.1 char的使用

在保存一个字符的时候使用char。

	char c1='a';
	char c2='1';
	char c3='中';
	char c4='ab';//错误

5.2 封装类Character

char对应的封装类是Character。有其它数字类型一样的装箱拆箱。

	char c1='我';
	Character c2=c1;
	char c3=c2; 

5.3 Character类的常用方法

方法	含义
isLetter()	判断是否是字母
isDigit()	判断是否是数字
isWhitespace()	判断是否是空白
isUpperCase()	判断是否是大写
isLowerCase()	判断是否是小写
toUpperCase()	转换为大写
toLowerCase()	转换为小写
toString()	转换为字符串

	System.out.println(Character.isLetter('a'));//判断是否为字母
    System.out.println(Character.isDigit('a')); //判断是否为数字
    System.out.println(Character.isWhitespace(' ')); //是否是空白
    System.out.println(Character.isUpperCase('a')); //是否是大写
    System.out.println(Character.isLowerCase('a')); //是否是小写
         
    System.out.println(Character.toUpperCase('a')); //转换为大写
    System.out.println(Character.toLowerCase('A')); //转换为小写
 
    String a = 'a'; //不能够直接把一个字符转换成字符串
    String a2 = Character.toString('a'); //转换为字符串

5.4 常见转义

符号	含义
\t制表符	对齐的效果，一个制表符的长度是8
\n	换行符
’	单引号
"	双引号
\	反斜杠\本身

    System.out.println("abc\tdef");
    System.out.println("ab\tdef");
    System.out.println("a\tdef");
         //使用\t制表符可以达到对齐的效果
    System.out.println("12345678def");
    //一个\t制表符长度是8      
    System.out.println("abc\ndef");
	//换行符 \n
    System.out.println("abc\'def");
    //单引号 \'
    System.out.println("abc\"def");
    //双引号 \"
    System.out.println("abc\\def");
	//反斜杠本身 \\        

5.5 练习

1. 通过Scanner从控制台读取字符串，然后把字符串转换为字符数组；
2. 转换为字符数组后，筛选出控制台读取到的字符串中的大写字母和数字，并打印出来。

	Scanner s=new Scanner(System.in);
	String str=s.nextLine();
	char[] cs=str.toCharArray();
	for(char a:cs) {
		if(Character.isUpperCase(a)||Character.isDigit(a))
			System.out.print(a);
	}
	s.close();

06 字符串

字符串即字符的组合，在Java中，字符串是一个类，所以我们见到的字符串都是对象。

6.1 创建字符串

1. 每当有一个字面值出现的时候，虚拟机就会创建一个字符串；
2. 调用String的构造方法创建一个字符串对象；
3. 通过+加号进行字符串拼接也会创建新的字符串对象。

	String s1="我爱你！";
	//字面值	,虚拟机碰到字面值就会创建一个字符串对象
	String s2=new String("我也爱你！");
	//创建了两个字符串对象	
	char[] ch=new char[] {'我','想','你','了','！'};
	String s3=new String(ch);
	//通过字符数组创建一个字符串对象
	String s4=s1+s2;
	//通过+加号进行字符串拼接
	
	System.out.println(s1);
	System.out.println(s2);
	System.out.println(s3);
	System.out.println(s4);

6.2 final修饰

String 被修饰为final,所以是不能被继承的。

	static class MyString extends String{
         //
    }
    //报错 The type MyString cannot subclass the final class String

6.3 immutable(不可改变的)

immutable 是指不可改变的，比如创建了一个字符串对象String garen ="盖伦";不可改变的具体含义是指：
不能增加长度、不能减少长度、不能插入字符、不能删除字符、不能修改字符。
一旦创建好这个字符串，里面的内容永远 不能改变，String 的表现就像是一个常量。

6.4 字符串格式化

略，参考本章04 格式化输出。

6.5 字符串长度

length方法返回当前字符串的长度，可以有长度为0的字符串,即空字符串。

	Scanner s=new Scanner(System.in);
	String st=s.nextLine();
	System.out.println(st.length());

6.6 练习-随机字符串

07 操纵字符串

关键字	介绍
charAt(int index)	获取指定位置的字符
toCharArray()	获取对应的字符数组
subString()	截取字符串
split()	根据分隔符分割
trim()	去掉首尾空格
toLowercase()/toUpperCase()	全部变成小写/大写形式
indexOf()	找到字符串所在的位置
contains()	是否包含
replaceAll()/replaceFirst()	替代所有/第一个

以下是示例：

7.1 charAt()

	String sentence="每天很辛苦，感觉很累，但是这有啥办法呢？";
	char s=sentence.charAt(11);
	System.out.println(s);

7.2 toCharArray()

	String sentence="每天很辛苦，感觉很累，但是这有啥办法呢？";
	char [] s=sentence.toCharArray();
	for(char st:s)
		System.out.println(st);

7.3 subString()

	String sentence="每天很辛苦，感觉很累，但是这有啥办法呢？";
	String s1=sentence.substring(1);
	System.out.println(s1);
		
	String s2=sentence.substring(6, 10);
	System.out.println(s2);

输出：

7.4 split()

	String sentence="每天很辛苦，感觉很累，但是这有啥办法呢？";
	String[] s=sentence.split("，");
	for(String s1:s)
		System.out.println(s1);

输出：

7.5 trim()

	String sentence="      每天很辛苦，     感觉很累，但是这有啥办法呢？      ";
	System.out.println(sentence);
	System.out.println(sentence.trim());

输出：

7.6 toLowerCase()/toUpperCase()

	String sentence="alSFjdADfbAgjGdfjAkAGB";
	System.out.println(sentence.toLowerCase());
	System.out.println(sentence.toUpperCase());

输出：

7.7 indexOf()

	String sentence="每天很辛苦感觉很累，但是这有啥办法呢";
	System.out.println(sentence.indexOf("每"));
	System.out.println(sentence.indexOf("辛苦"));

输出：

7.8 contains()

	String sentence="每天很辛苦感觉很累，但是这有啥办法呢";
	if(sentence.contains("辛苦"))
		System.out.println(sentence.indexOf("辛苦"));
	if(sentence.contains("幸福"))
		System.out.println(sentence.indexOf("幸福"));
	else
		System.out.println("找不到"+"幸福");

输出：

7.9 replaceAll()/replaceFirst()

	String sentence="每天很辛苦,感觉很累，但是这有啥办法呢";
	System.out.println(sentence.replaceAll("很","不"));
	System.out.println(sentence.replaceFirst("很", "不"));

输出：

补充作业：

1. 创建一个长度是100的字符串数组
2. 使用长度是2的随机字符填充该字符串数组
3. 统计这个字符串数组里重复的字符串有多少种

public class TestString {
	public static void main(String[] args) {
		String [] str=new String[100];
		//初始化字符串数组
		for(int i=0;i<str.length;i++) {
			str[i]=random(2);
		}
		//打印
		for(int i=0;i<str.length;i++) {
			if(0==i%20&&i!=0) {
				System.out.println("");
			}	
			System.out.print(str[i]+" ");
		}
		
		//找出相同的字符串并计数,
		for(int i=0;i<str.length;i++) {
			for(int j=i+1;j<str.length;j++) {
				//前面的数和后面的数对比
				if(str[i].equalsIgnoreCase(str[j])) {
					//把这个数str[i]传出去，并结束
					inPut(str[i]);
					break;
				}
			}
		}
		System.out.println("");
		//打印重复种类个数
		System.out.printf("重复的数组元素有%d种%n",pos);
		//打印重复的数组元素
		for(String st:eqString) {
			if(st==null) {
				break;
			}
			System.out.print(st+" ");
		}	
	}

	public static String random(int length) {
		String unit="";
		for(int i=0;i<length;i++) {
			while(true) {
				short s=(short)(Math.random()*75+48);
				char c=(char)s;
				if(Character.isLetter(c)||Character.isDigit(c)) {
					unit+=c;
					break;
				}
			}
		}
		return unit;
	}
	static String[] eqString=new String[100];
	public static int pos;
	public static void inPut(String in) {
		for(String s:eqString) {
			if(s==in)
				return;
		}
		eqString[pos]=in;
		pos++;
	}
}

输出：

08 比较字符串

8.1 是否是同一个对象

str1和str2的内容一定是一样的！但是，并不是同一个字符串对象！

	String str1 = "the light";         
	String str2 = new String(str1);         
	//==用于判断是否是同一个字符串对象
	System.out.println( str1  ==  str2);//false

8.2 是否是同一个对象-特例

当编译器发现已经存在现成的"the light"，那么就直接拿来使用，而没有进行重复创建。

	String str1 = "the light";
	String str3 = "the light";
	System.out.println( str1  ==  str3);//true

8.3 内容是否相同

使用equals进行字符串内容的比较，必须大小写一致。
equalsIgnoreCase，忽略大小写判断内容是否一致(二维码验证)。

	String str1 = "the light";
	String str2 = new String(str1);
	String str3 = str1.toUpperCase();
	//==用于判断是否是同一个字符串对象
	System.out.println( str1  ==  str2);
	System.out.println(str1.equals(str2));//完全一样返回true
	System.out.println(str1.equals(str3));//大小写不一样，返回false
	System.out.println(str1.equalsIgnoreCase(str3));//忽略大小写的比较，返回true

8.4 是否以字符串开始或者结束

startsWith //以…开始
endsWith //以…结束

	String str1 = "the light";
	String start = "the";
	String end = "Ight";
	System.out.println(str1.startsWith(start));//以...开始  true
	System.out.println(str1.endsWith(end));//以...结束  false

总结：使用equals进行字符串内容的比较；使用==进行对象是否相同的比较。

09 StringBuffer

StringBuffer是可变长的字符串。

9.1 追加 删除 插入 反转

关键字	含义
append	追加
delete	删除
insert	插入
reverse	反转

	String str1 = "let there ";  
	StringBuffer sb=new StringBuffer(str1);//创建一个sb对象
	sb.append("be light");//在后面追加
	System.out.println(sb);
        
	sb.delete(4, 10);//删除4-10的字符
	System.out.println(sb);
        
	sb.insert(4, "there ");//在4位置插入
	System.out.println(sb);
        
	sb.reverse();//反转
	System.out.println(sb);

输出：

9.2 长度 容量

length：”the“的长度是3；
capacity：分配的总空间是19。
和String内部是一个字符数组一样，StringBuffer也维护了一个字符数组。 但是，这个字符数组，留有冗余长度。比如说new StringBuffer(“the”)，其内部的字符数组的长度，是19，而不是3，若追加的长度大于19，会分配新的数组，看起来变长了。
练习，自定义MyStringBuffer。

本文学习内容均来自linkhow2j.cn，用于个人笔记和总结，想学习的可以到该网站学习哦，侵删。