Java常用类
Object类:
类 Object 是类层次结构的根类。每个类都使用 Object 作为超类(父类)。所有对象（包括数组）都实现这个类的方法。
hashCode();
public int hashCode()返回该对象的哈希码值
hashCode()----->通过哈希算法(哈希表:hashtable)---->地址值(不是实际意义上的地址值!
package org.westos_10_常用类;
public class ObjectDemo01 {
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(s1.hashCode());//随机产生一个哈希值118352462
Student s2 = new Student();
System.out.println(s2.hashCode());//1550089733
System.out.println("love".hashCode());//3327858
System.out.println("---------------------");
//public final Class getClass()返回此 Object 的运行时类
Class c1 = s1.getClass() ;
System.out.println("c1:"+c1);//c1:class org.westos_10_常用类.Student
String name = c1.getName();
System.out.println("name: "+name);//name: org.westos_10_常用类.Student(全路径名称)
}
}//随机产生一个哈希值118352462
Student s2 = new Student();
System.out.println(s2.hashCode());//1550089733
System.out.println("love".hashCode());//3327858
System.out.println("---------------------");
//public final Class getClass()返回此 Object 的运行时类
Class c1 = s1.getClass() ;
System.out.println("c1:"+c1);//c1:class org.westos_10_常用类.Student
String name = c1.getName();
System.out.println("name: "+name);//name: org.westos_10_常用类.Student(全路径名称)
}
}*toString();
public String toString();返回该对象的字符串表示(建议所有子类都重写此方法)
Integer类中有一个方法:
public static String toHexString(int i):将一个int类型的数据转换成一个十六进制的字符串表现形式
如果直接输出对象名称,想要显示当前对象的成员变量的值,那么必须重写Object类中的toString()方法
//toString()重写 自动生成 Alt+Shlft +s--->s
@Override
public String toString() {
return "Persen [name=" + name + ", age=" + age + "]";
}
public class ObjectDemo {
public static void main(String[] args) {
Persen p1 = new Persen("彭于晏 ",22);
System.out.println("p1: " +p1); //p1: org.westos_10_object.Persen@70dea4e
//toString方法重写后打印 p1: Persen [name=彭于晏 , age=22]
System.out.println("toString: "+p1.toString());
System.out.println(p1.getClass().getName()+"@"+Integer.toHexString(p1.hashCode()));
//toString: org.westos_10_object.Persen@70dea4e toString: Persen [name=彭于晏 , age=22]
/*
查看源码后：
public String toString() {
return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
}
toString() 等价于 对象名.getClass().getName() +"@" +Integer.toHexString(对象名.hashCode())
*/
System.out.println("---------------------------------");
System.out.println(p1.getClass().getName()+"@"+Integer.toHexString(p1.hashCode()));
/* org.westos_10_object.Persen@70dea4e
直接对象名称,想要显示成员变量的值,怎么办?
重写toString()方法 */
}
}//p1: org.westos_10_object.Persen@70dea4e
//toString方法重写后打印 p1: Persen [name=彭于晏 , age=22]
System.out.println("toString: "+p1.toString());
System.out.println(p1.getClass().getName()+"@"+Integer.toHexString(p1.hashCode()));
//toString: org.westos_10_object.Persen@70dea4e toString: Persen [name=彭于晏 , age=22]
/*
查看源码后：
public String toString() {
return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
}
toString() 等价于 对象名.getClass().getName() +"@" +Integer.toHexString(对象名.hashCode())
*/
System.out.println("---------------------------------");
System.out.println(p1.getClass().getName()+"@"+Integer.toHexString(p1.hashCode()));
/* org.westos_10_object.Persen@70dea4e
直接对象名称,想要显示成员变量的值,怎么办?
重写toString()方法 */
}
}
*equal();
Object中的另一个方法：
public boolean equals(Object obj)指示其他某个对象是否与此对象“相等”。返回一个boolean类型
面试题:
== 和 equal()方法的区别
==:比较的是两个对象的地址值是否相同,
equals()方法默认比较的是两个对象的地址值是否相同,如果重写了Object类中的equals()方法,那么默认比较就是两个对象的内容是否相同
使用工具自动生成equals()方法
在javascript:Array对象,Number对象,String对象,valueOf():====>s1.valueOf(s2) ;比较是内容是否相同
由于Object类中的equals()方法底层是通过"=="来实现的,所以默认比较的是地址值,如果想比较内容是否相同,需要重写equals()方法
public class ObjectDemo_ {
public static void main(String[] args) {
//创建对象
Persen p1 = new Persen("李白",21);
Persen p2 = new Persen("李白",21);
System.out.println(p1 == p2);//地址不同 输出false
System.out.println("------------------");
Persen p3 = p1 ;
System.out.println(p1==p3);//地址相同 true
System.out.println("-------------------");
System.out.println(p1.equals(p2));//false equals()方法默认比较的是地址值底层源码依赖"=="
//想要比较内容必须重写equals()方法
System.out.println(p1.equals(p2));//由于重写equals()方法,所以比较的是对象的内容是否相同! true
}
}//创建对象
Persen p1 = new Persen("李白",21);
Persen p2 = new Persen("李白",21);
System.out.println(p1 == p2);//地址不同 输出false
System.out.println("------------------");
Persen p3 = p1 ;
System.out.println(p1==p3);//地址相同 true
System.out.println("-------------------");
System.out.println(p1.equals(p2));//false equals()方法默认比较的是地址值底层源码依赖"=="
//想要比较内容必须重写equals()方法
System.out.println(p1.equals(p2));//由于重写equals()方法,所以比较的是对象的内容是否相同! true
}
}
Object类中的其他两个方法:finalize()和clone()
protected void finalize()throws Throwable:当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法,
但是,什么时候调用垃圾回收器不确定;
System类中的一个方法:
public void gc():运行垃圾回收器,这个垃圾回收器最终调用的就是finalize()方法
protected Object clone()创建并返回此对象的一个副本
throws CloneNotSupportedException
注意事项:
Object 类的 clone 方法执行特定的复制操作。首先，如果此对象的类不能实现接口 Cloneable，则会抛出 CloneNotSupportedException。异常
//重写Object中的clone()方法
@Override
protected Object clone() throws CloneNotSupportedException {//抛出一个运行时异常
return super.clone();
}
@Override
protected Object clone() throws CloneNotSupportedException {//抛出一个运行时异常
return super.clone();
}package org.westos_10_object_02;
import java.security.GeneralSecurityException;
public class ObjectDemo { //抛出声明
public static void main(String[] args) throws CloneNotSupportedException {
Student s1 = new Student();
s1.setName("李荣浩");
s1.setAge(21);
System.out.println(s1.getName()+" -- "+s1.getAge());//李荣浩 -- 21
//复制s1对象
Object obj = s1.clone() ;
//向下转型
Student s2 = (Student) obj;
System.out.println(s1.getName()+"----"+s2.getAge());//李荣浩----21
}
}//抛出声明
public static void main(String[] args) throws CloneNotSupportedException {
Student s1 = new Student();
s1.setName("李荣浩");
s1.setAge(21);
System.out.println(s1.getName()+" -- "+s1.getAge());//李荣浩 -- 21
//复制s1对象
Object obj = s1.clone() ;
//向下转型
Student s2 = (Student) obj;
System.out.println(s1.getName()+"----"+s2.getAge());//李荣浩----21
}
}
Scanner类：
package org.westos_10_scanner;
import java.util.Scanner;
/* 键盘录入两个方法：
* 1)Scanner:用来创建一个文本扫描器(键盘录入)
2)java高级特性:IO流(后面讲)
BufferReder:字符缓冲流来键盘录入
开发步骤:
* 1)创建键盘录入对象
* 2)录入数据
* 3)输出
Scanner类中常用的方法:
*
* nextInt():录入int类型的数据
* nextLine():录入一个字符串类型
* 如果想要录入一个int类型的数，却输入了一个字符串，就会报出异常：
* java.util.InputMismatchException:输入和想到的数据不匹配
* 故加入一个判断的功能来避免
* * 判断的功能:
* 细节:可以添加逻辑判断
* hasNextXXX(); 在录入数据之前,加上判断功能,判断是否由下一个可以录入的XXX类型的数据
* nextXXX();//通过录入获取这个int类型的数据
*
* 举例:
* public boolean hasNextInt()
* nextInt();
*
* */
public class ScannerDemo1 {
public static void main(String[] args) {
//创建键盘录入对象(导包)
Scanner sc = new Scanner(System.in);
//判断
if(sc.hasNextInt()) {
int a = sc.nextInt();
System.out.println("a:"+a);
}else{
//错误提示
System.out.println("录入的数据类型和想要的不匹配!");
}
}
}/* 键盘录入两个方法：
* 1)Scanner:用来创建一个文本扫描器(键盘录入)
2)java高级特性:IO流(后面讲)
BufferReder:字符缓冲流来键盘录入
开发步骤:
* 1)创建键盘录入对象
* 2)录入数据
* 3)输出
Scanner类中常用的方法:
*
* nextInt():录入int类型的数据
* nextLine():录入一个字符串类型
* 如果想要录入一个int类型的数，却输入了一个字符串，就会报出异常：
* java.util.InputMismatchException:输入和想到的数据不匹配
* 故加入一个判断的功能来避免
* * 判断的功能:
* 细节:可以添加逻辑判断
* hasNextXXX(); 在录入数据之前,加上判断功能,判断是否由下一个可以录入的XXX类型的数据
* nextXXX();//通过录入获取这个int类型的数据
*
* 举例:
* public boolean hasNextInt()
* nextInt();
*
* */
public class ScannerDemo1 {
public static void main(String[] args) {
//创建键盘录入对象(导包)
Scanner sc = new Scanner(System.in);
//判断
if(sc.hasNextInt()) {
int a = sc.nextInt();
System.out.println("a:"+a);
}else{
//错误提示
System.out.println("录入的数据类型和想要的不匹配!");
}
}
}package org.westos.scanner_01;
import java.util.Scanner;
/**
* Scanner类中的注意事项:
* 先录入int类型的数据,在录入String类型数据,第二次录入的数据没有接收到,直接输出结果了,由于"回车"才能接收数据
* 回车换行符导致的!
* 解决方案:
* 在第二次录入String类型数据之前,需要重新创建键盘录入对象录入String类型
*
* */
public class ScannerDemo3 {
public static void main(String[] args) {
//键盘录入对象
Scanner sc = new Scanner(System.in) ;
//先录入两个int类型的数据
/*int a = sc.nextInt() ;
int b = sc.nextInt() ;
System.out.println("a:"+a+",b:"+b);*/
//录入两个String类型的数据
//hasNextLine
String a = sc.nextLine() ;
String b = sc.nextLine() ;
//先录入String类型的数据,在录入int类型的数据
String a = sc.nextLine() ;
int b = sc.nextInt() ;
//先录入int类型,再录入String类型
int a = sc.nextInt() ;
//String b = sc.nextLine() ;
String b = sc.next() ;
int a = sc.nextInt() ;
//创建键盘录入对象
Scanner sc2 = new Scanner(System.in) ;
String b = sc2.nextLine() ;
System.out.println("a:"+a+",b:"+b);
}
}
/**
* Scanner类中的注意事项:
* 先录入int类型的数据,在录入String类型数据,第二次录入的数据没有接收到,直接输出结果了,由于"回车"才能接收数据
* 回车换行符导致的!
* 解决方案:
* 在第二次录入String类型数据之前,需要重新创建键盘录入对象录入String类型
*
* */
public class ScannerDemo3 {
public static void main(String[] args) {
//键盘录入对象
Scanner sc = new Scanner(System.in) ;
//先录入两个int类型的数据
/*int a = sc.nextInt() ;
int b = sc.nextInt() ;
System.out.println("a:"+a+",b:"+b);*/
//录入两个String类型的数据
//hasNextLine
String a = sc.nextLine() ;
String b = sc.nextLine() ;
//先录入String类型的数据,在录入int类型的数据
String a = sc.nextLine() ;
int b = sc.nextInt() ;
//先录入int类型,再录入String类型
int a = sc.nextInt() ;
//String b = sc.nextLine() ;
String b = sc.next() ;
int a = sc.nextInt() ;
//创建键盘录入对象
Scanner sc2 = new Scanner(System.in) ;
String b = sc2.nextLine() ;
System.out.println("a:"+a+",b:"+b);
}
}
String类
String类:
代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现;字符串一旦被赋值,其值不能再改变
String类常用的构造方法:
String():表示一个空字符序列。
public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
public String(byte[] bytes,int index,int length):将部分字节数组构造成一个字符串
public String(char[] value):将字符数组构造成一个字符串
public String(char[] value,int index,int length):将部分的字符数组构造成一个字符串
public String(String original):通过字符串常量构造一个字符串对象
*获取字符串的长度功能:
public int length()
面试题:
数组中有没有length(), 字符串中有没有length(), 集合中有没有length()(集合后面讲)?
数组没有length(),数组有length属性
字符串中有length()
集合中没有length(),获取集合中元素数量:size()
package org.westos_10_string01;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
public class StringDemo {
public static void main(String[] args) throws UnsupportedEncodingException {
//创建一个String对象
String s1 = new String();
System.out.println("s1:"+s1); //s1:
System.out.println("s1.length():"+s1.length());//s1.length():0
System.out.println("---------------------");
//public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
//创建一个字节数组
byte[] bys = {97, 98, 99, 100, 101} ;
String s2 = new String(bys);
System.out.println("s2:"+s2);//s2:abcde 字节的值要找它对应的ASCII码表中的字符
System.out.println("s2.length():"+s2.length());//s2.length():5
System.out.println("----------------------");
/*编码和解码:一定要保证编码格式一致
编码:
把能看懂的东西转换成一个看不懂的东西:String----->byte[]:public byte[] getBytes(String charsetName)
解码:
把当前的byte[]转成能看懂的东西(String):byte[]----->String :public String(byte[] bytes,CharsetName ch)*/
//编码
String s3 = "我在回忆里等你！";
byte[] bys2 = s3.getBytes("GBK");//抛出异常 UnsupportedEncodingException
System.out.println(bys2);//[B@70dea4e
//Arrays:数组工具类:toString(byte[] bys)
System.out.println(Arrays.toString(bys2));
//-50, -46, -44, -38, -69, -40, -46, -28, -64, -17, -75, -56, -60, -29, -93, -95]
//解码
System.out.println("-------");
String str = new String(bys2, "GBK") ;
System.out.println("str:"+str);//str:我在回忆里等你！
//public String(char[] value):将字符数组构造成一个字符串
//定义一个字符数组
char[] chs = {'我','在','回','忆','里','等','你'} ;
String s4 = new String(chs) ;
System.out.println("s4.length():"+s4.length()); //s4.length():7
System.out.println("s4:"+s4); //s4:我在回忆里等你
System.out.println("--------------------");
String s5 = new String(chs, 1, 6) ;
System.out.println("s5:"+s5);//s5:在回忆里等你
System.out.println("s5.length():"+s5.length());//s5.length():6
System.out.println("--------------------");
//public String(String original):通过字符串常量构造一个字符串对象
String s6 = new String("hello") ;//一般不使用
System.out.println("s6:"+s6);//s6:hello
System.out.println("s6.length():"+s6.length());//s6.length():5
String s7 = "iloveyou" ;
System.out.println("s7:"+s7);//s7:iloveyou
System.out.println("s7.length():"+s7.length());//s7.length():8
}
}//创建一个String对象
String s1 = new String();
System.out.println("s1:"+s1); //s1:
System.out.println("s1.length():"+s1.length());//s1.length():0
System.out.println("---------------------");
//public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
//创建一个字节数组
byte[] bys = {97, 98, 99, 100, 101} ;
String s2 = new String(bys);
System.out.println("s2:"+s2);//s2:abcde 字节的值要找它对应的ASCII码表中的字符
System.out.println("s2.length():"+s2.length());//s2.length():5
System.out.println("----------------------");
/*编码和解码:一定要保证编码格式一致
编码:
把能看懂的东西转换成一个看不懂的东西:String----->byte[]:public byte[] getBytes(String charsetName)
解码:
把当前的byte[]转成能看懂的东西(String):byte[]----->String :public String(byte[] bytes,CharsetName ch)*/
//编码
String s3 = "我在回忆里等你！";
byte[] bys2 = s3.getBytes("GBK");//抛出异常 UnsupportedEncodingException
System.out.println(bys2);//[B@70dea4e
//Arrays:数组工具类:toString(byte[] bys)
System.out.println(Arrays.toString(bys2));
//-50, -46, -44, -38, -69, -40, -46, -28, -64, -17, -75, -56, -60, -29, -93, -95]
//解码
System.out.println("-------");
String str = new String(bys2, "GBK") ;
System.out.println("str:"+str);//str:我在回忆里等你！
//public String(char[] value):将字符数组构造成一个字符串
//定义一个字符数组
char[] chs = {'我','在','回','忆','里','等','你'} ;
String s4 = new String(chs) ;
System.out.println("s4.length():"+s4.length()); //s4.length():7
System.out.println("s4:"+s4); //s4:我在回忆里等你
System.out.println("--------------------");
String s5 = new String(chs, 1, 6) ;
System.out.println("s5:"+s5);//s5:在回忆里等你
System.out.println("s5.length():"+s5.length());//s5.length():6
System.out.println("--------------------");
//public String(String original):通过字符串常量构造一个字符串对象
String s6 = new String("hello") ;//一般不使用
System.out.println("s6:"+s6);//s6:hello
System.out.println("s6.length():"+s6.length());//s6.length():5
String s7 = "iloveyou" ;
System.out.println("s7:"+s7);//s7:iloveyou
System.out.println("s7.length():"+s7.length());//s7.length():8
}
}字符串的一个特点:一旦被赋值,其值不能被改变(不可变的字符序列)
* 面试题:
String s = "hello"
和String s = new String("hello") 两个有什么区别?分别创建了几个对象
第一个创建了一个对象
第二个s创建两个对象(堆内存中有new String(),然后字符串常量池中也有这样一个字符串常量(开辟空间的地址))
String类的中常用的判断功能:
boolean equals(Object obj): 当前该对象是否obj这个对象是否相等;
boolean equalsIgnoreCase(String str): 比较字符串是否相等,忽略大小写
boolean contains(String str): 判断str这个字符串是否包含在当前字符串中
boolean startsWith(String str): 是否以str子字符串开头
boolean endsWith(String str): 判断是否以str子字符串结尾
boolean isEmpty(): 判断字符串是否为空
String s = "" ;空字符
String s = " " ;字符串"空格"
String s = null ;当前字符串对象为空
public class StringDemo {
public static void main(String[] args) {
//定义一个字符串
String s1 = "helloworld" ;
String s2 = "HelloWorld" ;
//boolean equals(Object obj):当前该对象是否obj这个对象是否相等;String重写equals(),比较的是两个字符串的内容是否相同
System.out.println("equals:"+s1.equals(s2));
//boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
System.out.println("equalsIgnoreCase:"+s1.equalsIgnoreCase(s2));
//boolean contains(String str):判断str这个字符串是否包含在当前字符串中
System.out.println("contains:"+s1.contains("owo"));
System.out.println("contains:"+s1.contains("ak47"));
//boolean startsWith(String str):是否以str子字符串开头
System.out.println("starsWith:"+s1.startsWith("hel"));
//boolean endsWith(String str):判断是否以str子字符串结尾
//boolean isEmpty():判断字符串是否为空
System.out.println("isEmpty:"+s1.isEmpty());
}
}
//定义一个字符串
String s1 = "helloworld" ;
String s2 = "HelloWorld" ;
//boolean equals(Object obj):当前该对象是否obj这个对象是否相等;String重写equals(),比较的是两个字符串的内容是否相同
System.out.println("equals:"+s1.equals(s2));
//boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
System.out.println("equalsIgnoreCase:"+s1.equalsIgnoreCase(s2));
//boolean contains(String str):判断str这个字符串是否包含在当前字符串中
System.out.println("contains:"+s1.contains("owo"));
System.out.println("contains:"+s1.contains("ak47"));
//boolean startsWith(String str):是否以str子字符串开头
System.out.println("starsWith:"+s1.startsWith("hel"));
//boolean endsWith(String str):判断是否以str子字符串结尾
//boolean isEmpty():判断字符串是否为空
System.out.println("isEmpty:"+s1.isEmpty());
}
}
String类的获取功能(重点):
int length() :获取字符串长度功能
char charAt(int index):返回的是索引处对应的字符
int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
int indexOf(String str):返回指定子字符串在此字符串中第一次出现 的索引
int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索
String substring(int start):从指定位置开始截取字符串,默认截取到末尾
String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引)
public class StringDemo {
public static void main(String[] args) {
//定义一个字符串:
String str = "helloworld" ;
//int length() :获取字符串长度功能
System.out.println("length:"+str.length());
//char charAt(int index):返回的是索引处对应的字符
System.out.println("charAt:"+str.charAt(1));
System.out.println("charAt:"+str.charAt(8));
System.out.println("-------------------------------");
//int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
System.out.println("indexof:"+str.indexOf('l'));
System.out.println("indexof:"+str.indexOf('k'));//-1
//int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引
System.out.println("indexOf:"+str.indexOf("owo"));
System.out.println("-------------------------------");
//int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
System.out.println("indexOf:"+str.indexOf('l', 4));
//int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索
//String substring(int start):从指定位置开始截取字符串,默认截取到末尾(返回一个新的字符串,不再是字符串本身!)
System.out.println("substring:"+str.substring(5));
//String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引)
System.out.println("substring:"+str.substring(4, 8));//owor
}
}
//定义一个字符串:
String str = "helloworld" ;
//int length() :获取字符串长度功能
System.out.println("length:"+str.length());
//char charAt(int index):返回的是索引处对应的字符
System.out.println("charAt:"+str.charAt(1));
System.out.println("charAt:"+str.charAt(8));
System.out.println("-------------------------------");
//int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
System.out.println("indexof:"+str.indexOf('l'));
System.out.println("indexof:"+str.indexOf('k'));//-1
//int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引
System.out.println("indexOf:"+str.indexOf("owo"));
System.out.println("-------------------------------");
//int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
System.out.println("indexOf:"+str.indexOf('l', 4));
//int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索
//String substring(int start):从指定位置开始截取字符串,默认截取到末尾(返回一个新的字符串,不再是字符串本身!)
System.out.println("substring:"+str.substring(5));
//String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引)
System.out.println("substring:"+str.substring(4, 8));//owor
}
}
String类的转换功能(重点)：
byte[] getBytes(): 将字符串转换字节数组
char[] toCharArray(): 将字符串转换成 字符数组 (开发中经常使用)
static String valueOf(char[] chs): 将字符数组转换成字符串
static String valueOf(int i): 将一个int类型的数据转换成字符串
注意:
String类中的valueOf()可以将任何数据类型转换成字符串
String toLowerCase(): 将字符串全部转成小写
String toUpperCase(): 将字符串全部转换成大写
String concat(String str): 字符串拼接方法
public class StringDemo {
//构造方法:
//构造方法不能使用递归
/*public StringDemo(){
StringDemo();
}*/
public static void main(String[] args) {
//定义一个字符串
String s = "JavaSE" ;
//byte[] getBytes():将字符串转换字节数组
byte[] bys = s.getBytes() ;
//遍历字节数组
for(int x = 0 ; x < bys.length ; x++){
System.out.println(bys[x]);
}
System.out.println("---------------------");
//char[] toCharArray():将字符串转换成 字符数组
char[] chs = s.toCharArray() ;
for (int x = 0; x < chs.length; x++) {
System.out.println(chs[x]);
}
System.out.println("---------------------");
//static String valueOf(char[] chs):将字符数组转换成字符串
String s2 = String.valueOf(chs) ;
System.out.println("s2:"+s2);
//static String valueOf(int i):将一个int类型的数据转换成字符串
String s3 = String.valueOf(100) ;
System.out.println("s3:"+s3);
//String toLowerCase():将字符串全部转成小写
System.out.println("toLowerCase:"+s.toLowerCase());
//String toUpperCase():将字符串全部转换成大写
System.out.println("toUpperCase:"+s.toUpperCase());
//String concat(String str):字符串拼接方法
String s4 = "hello" ;
String s5 = "world" ;
System.out.println("contact:"+s4.concat(s5));
String s6 = "java" ;
s6 += "web" ;
System.out.println("s6:"+s6);
/**
*方法嵌套
* Math.max(Math.max(a,b),c);
*
*方法递归:方法调用本身的一种现象
*
* 三个条件:
* 1)需要定义个方法
* 2)方法必须有出口条件
* 3)必须有某一种规律
* public void show(int n){
*
* if(n<0){
* System.exit(0) ; //让jvm退出,程序结束
* }
*
* System.out.println(n) ;
* show(--n) ;
* }
* */
System.out.println("--------------------");
//需求:求5的阶乘
//5! = 5 * 4 * 3 * 2 * 1 ;
//5! = 5 * 4! ;
int jc = 1 ;
//循环思想
for(int x = 2 ; x <=5 ; x ++){
jc *= x;
}
System.out.println("5的阶乘是:"+jc);
System.out.println("-------------------------");
//使用递归的思想:
//需要定义个方法
System.out.println("5的阶乘是:"+jieCheng(5));
}
/**
* 明确返回值类型:
* int类型
* 参数类型:int类型的值
*
* 2)出口条件:
* if(n==1){
* return 1 ;
* }
*
* 3)要有规律
* if(n!=1){
* return n* 方法名(n-1);
* }
* */
public static int jieCheng(int n){
if(n==1){
return 1 ;
}else{
return n* jieCheng(n-1) ; //5 * 4 * 3 * 1 *１
}
}
}
//构造方法:
//构造方法不能使用递归
/*public StringDemo(){
StringDemo();
}*/
public static void main(String[] args) {
//定义一个字符串
String s = "JavaSE" ;
//byte[] getBytes():将字符串转换字节数组
byte[] bys = s.getBytes() ;
//遍历字节数组
for(int x = 0 ; x < bys.length ; x++){
System.out.println(bys[x]);
}
System.out.println("---------------------");
//char[] toCharArray():将字符串转换成 字符数组
char[] chs = s.toCharArray() ;
for (int x = 0; x < chs.length; x++) {
System.out.println(chs[x]);
}
System.out.println("---------------------");
//static String valueOf(char[] chs):将字符数组转换成字符串
String s2 = String.valueOf(chs) ;
System.out.println("s2:"+s2);
//static String valueOf(int i):将一个int类型的数据转换成字符串
String s3 = String.valueOf(100) ;
System.out.println("s3:"+s3);
//String toLowerCase():将字符串全部转成小写
System.out.println("toLowerCase:"+s.toLowerCase());
//String toUpperCase():将字符串全部转换成大写
System.out.println("toUpperCase:"+s.toUpperCase());
//String concat(String str):字符串拼接方法
String s4 = "hello" ;
String s5 = "world" ;
System.out.println("contact:"+s4.concat(s5));
String s6 = "java" ;
s6 += "web" ;
System.out.println("s6:"+s6);
/**
*方法嵌套
* Math.max(Math.max(a,b),c);
*
*方法递归:方法调用本身的一种现象
*
* 三个条件:
* 1)需要定义个方法
* 2)方法必须有出口条件
* 3)必须有某一种规律
* public void show(int n){
*
* if(n<0){
* System.exit(0) ; //让jvm退出,程序结束
* }
*
* System.out.println(n) ;
* show(--n) ;
* }
* */
System.out.println("--------------------");
//需求:求5的阶乘
//5! = 5 * 4 * 3 * 2 * 1 ;
//5! = 5 * 4! ;
int jc = 1 ;
//循环思想
for(int x = 2 ; x <=5 ; x ++){
jc *= x;
}
System.out.println("5的阶乘是:"+jc);
System.out.println("-------------------------");
//使用递归的思想:
//需要定义个方法
System.out.println("5的阶乘是:"+jieCheng(5));
}
/**
* 明确返回值类型:
* int类型
* 参数类型:int类型的值
*
* 2)出口条件:
* if(n==1){
* return 1 ;
* }
*
* 3)要有规律
* if(n!=1){
* return n* 方法名(n-1);
* }
* */
public static int jieCheng(int n){
if(n==1){
return 1 ;
}else{
return n* jieCheng(n-1) ; //5 * 4 * 3 * 1 *１
}
}
}