文章目录
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 练习-装箱拆箱
- 对byte,short,float,double进行自动拆箱和自动装箱
- byte和Integer之间能否进行自动拆箱和自动装箱
- 通过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 数字转字符串
- 使用String类的静态方法valueOf;
- 先把基本类型装箱为对象,然后调用对象的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 练习-字符串转换
- 把浮点数 3.14 转换为 字符串 “3.14”;
- 再把字符串 “3.14” 转换为 浮点数 3.14;
- 如果字符串是 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 练习
- 通过Scanner从控制台读取字符串,然后把字符串转换为字符数组;
- 转换为字符数组后,筛选出控制台读取到的字符串中的大写字母和数字,并打印出来。
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 创建字符串
- 每当有一个字面值出现的时候,虚拟机就会创建一个字符串;
- 调用String的构造方法创建一个字符串对象;
- 通过+加号进行字符串拼接也会创建新的字符串对象。
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("很", "不"));
输出:
补充作业:
- 创建一个长度是100的字符串数组
- 使用长度是2的随机字符填充该字符串数组
- 统计这个字符串数组里重复的字符串有多少种
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,用于个人笔记和总结,想学习的可以到该网站学习哦,侵删。