devbox
人工智能uu
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

day10java基础_canoe面试题

作者：人工智能uu | 2024-08-06 03:28:03

赞

踩

canoe面试题
day10
一.Object类：
    1.类Object是类层次结构的根类，每个类都使用Object作为超类（父类）。所有对象（包括数组）都实现这个类的方法。
      （1）public int hashCode()返回该对象的哈希码值
           hashCode（）：通过哈希算法（哈希表：hashtable）---->地址值（不是实际意义上的地址值）
      （2）public final Class getClass（）返回此Object的运行时类（JAVA反射机制中讲）
           public String getName（）以String的形式返回此Class对象所表示的实体（类、接口、数组类、基本类型或void名称）
           例子： 
  1. public class ObjectDemo {
  2. 	
  3. 	public static void main(String[] args) {
  4. 		
  5. 		//创建学生对象
  6. 		Student s1 = new Student() ;
  7. 		System.out.println(s1.hashCode());//1460821906
  8. 		
  9. 		Student s2 = new Student()  ;
  10. 		System.out.println(s2.hashCode());//2045891656
  11. 		
  12. 		Student s3 = new Student() ;
  13. 		System.out.println(s3.hashCode());
  14. 		
  15. 		
  16. //		System.out.println("hello".hashCode()) ;
  17. 		
  18. //		public final Class getClass()返回此 Object 的运行时类
  19. 		Class c1 = s1.getClass() ;
  20. //		System.out.println("c1:"+c1);//class org.westos.object_01.Student
  21. 		//public String getName():获取当前正在运行的这类的全路径名称!
  22. 		String name = c1.getName() ;
  23. 		System.out.println("name:"+name);//org.westos.object_01.Student :全路径名称
  24. 										//org.westos.object_01.Student
  25. 	}
  26. }
  27. ublic class Student extends Object{
  28. 	
  29. }




  （ 3）public String toString();返回该对象的字符串表示(建议所有的子类都重写此方法)
       Integer类中有一个方法：
        public static String toHexString(int i):将一个int类型的数据转换成一个十六进制的字符串表现形式
        如果直接输出对象名称，想要显示当前对象的成员变量的值，那么必须重写Object类中的toStrinng()方法


        
       在源码里，toString<==>对象名.getClass().getName()+"@"+Integer.toHexString(对象名.hashCode()) 

  1. public static void main(String[] args) {
  2. 		//创建一个学生对象
  3. 		Student s1 = new Student("高圆圆",27) ;
  4. 			
  5. 		//直接输出对象名称
  6. 		/*System.out.println("s1:"+s1);//org.westos.object_02.Student@7439aca7
  7. 		//public String toString()
  8. 		System.out.println("toString():"+s1.toString());//org.westos.object_02.Student@7439aca7
  9. 		System.out.println("--------------------------");*/
  10. 		
  11. 		/**
  12. 		 * 通过查看toString()源码:
  13. 		 *  public String toString() {
  14.         		return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
  15.     		}
  16.     		
  17.     		toString()<==> 对象名.getClass().getName() +"@" +Integer.toHexString(对象名.hashCode())
  18. 		 */
  19. 		
  20. 		System.out.println(s1.getClass().getName()+"@"+Integer.toHexString(s1.hashCode()));
  21. //		System.out.println(s1.toString());
  22. 		//org.westos.object_02.Student@28169674
  23. 		//org.westos.object_02.Student@28169674
  24. 		
  25. 		//直接对象名称,想要显示成员变量的值,怎么办?
  26.                 //去student类里面重写toString（）方法
  27. //		System.out.println(s1);
  28. 		Student s2 = new Student("高圆圆", 27) ;
  29. 		System.out.println("s2:"+s2);
  30. 		System.out.println(s1==s2);		
  31. 	}
  32. }
  33.  
  34. public class Student extends Object {
  35. 	
  36. 	//成员变量
  37. 	private String name;
  38. 	private int age ;
  39. 	
  40. 	public Student() {
  41. 		super();
  42. 	}
  43. 	public Student(String name, int age) {
  44. 		super();
  45. 		this.name = name;
  46. 		this.age = age;
  47. 	}
  48. 	public String getName() {
  49. 		return name;
  50. 	}
  51. 	public void setName(String name) {
  52. 		this.name = name;
  53. 	}
  54. 	public int getAge() {
  55. 		return age;
  56. 	}
  57. 	public void setAge(int age) {
  58. 		this.age = age;
  59. 	}
  60. 	//当前toString()是自己去写的
  61. /*	@Override
  62. 	public String toString() {
  63. 		return name+"---"+age;
  64. 	}*/
  65. 	
  66. 	//alt+shift+s->s
  67. 	//自动生成即可!
  68. 	@Override
  69. 	public String toString() {
  70. 		return "Student [name=" + name + ", age=" + age + "]";
  71. 	}
  72. 	
  73. 	
  74. 	
  75. }


（4）public boolean equals(Object obj):指示其它某个对象是否与此对象“相等”

        面试题:
==和equal()方法的区别
==:比较的是两个对象的地址值是否相同,
   equals()方法默认比较的是两个对象的地址值是否相同,如果重写了Object类中的equals()方法,那么默认比较就是         两个对象的内容是否相同
  
        使用工具自动生产equals()方法：
  
javascript:Array对象,Number对象,String对象,valueOf():====>s1.valueOf(s2) ;比较是内容是否相同

            例子：

       

  1. public class ObjectDemo {
  2. 	
  3. 	public static void main(String[] args) {
  4. 		
  5. 		//创建学生对象
  6. 		Student s1 = new Student("高圆圆", 27) ;
  7. 		Student s2 = new Student("高圆圆",27) ;
  8. 		System.out.println(s1==s2);//false
  9. 		System.out.println("------------------");
  10. 		Student s3 = s1 ;
  11. 		System.out.println(s1==s3);//true
  12. 		System.out.println("-------------------");
  13. 		System.out.println(s1.equals(s2));//由于重写Object中的equals()方法,所以比较的是对象的内容是否相同!
  14. 		
  15. 		/**
  16. 		 * equals()方法的源码
  17. 		 *   public boolean equals(Object obj) {
  18.         	return (this == obj);
  19.     	}
  20.     		由于Object类中的equals()方法底层是通过"=="来实现的,所以默认比较的是地址值,如果想比较内容是否相同,需要重写equals()方法
  21. 		 * */
  22. 	}
  23. }

  1. public class Student {
  2. 	//成员变量
  3. 	private String name;
  4. 	private int age ;
  5. 	
  6. 	public Student() {
  7. 		super();
  8. 	}
  9.  
  10. 	public Student(String name, int age) {
  11. 		super();
  12. 		this.name = name;
  13. 		this.age = age;
  14. 	}
  15.  
  16. 	public String getName() {
  17. 		return name;
  18. 	}
  19.  
  20. 	public void setName(String name) {
  21. 		this.name = name;
  22. 	}
  23.  
  24. 	public int getAge() {
  25. 		return age;
  26. 	}
  27.  
  28. 	public void setAge(int age) {
  29. 		this.age = age;
  30. 	}
  31.  
  32. 	//toString()
  33. 	@Override
  34. 	public String toString() {
  35. 		return "Student [name=" + name + ", age=" + age + "]";
  36. 	}
  37. 	
  38. 	
  39. 	//重写了Object类中的equals()方法
  40. 	@Override
  41. 	public boolean equals(Object obj) { //Studnet s2 = new Student() ;
  42. 		if (this == obj)
  43. 			return true;
  44. 		if (obj == null)  //当前传入过来的对象是否为空
  45. 			return false;
  46. 		if (getClass() != obj.getClass())	//this.getClass() != s2.getClass()		
  47. 			return false;
  48. 		Student other = (Student) obj;
  49. 		if (age != other.age)
  50. 			return false;
  51. 		if (name == null) {
  52. 			if (other.name != null)
  53. 				return false;
  54. 		} else if (!name.equals(other.name))
  55. 			return false;
  56. 		return true;
  57. 	}
  58. 	
  59. 	
  60. 	/**
  61. 	 * 对象名  instanceof 类:判断该对象是否是该类的一个实例
  62. 	 * */

（5）protected void finalize( )throws Throwable:

         当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法，但是，什么时候调用垃圾            回收器不确定。


         System类中的一个方法：

         public void gc（）：运行垃圾回收器，这个垃圾回收器最终调用的就是finalize（）方法。


（6）protected Object clone()throws CloneNotSupportedException{ }:创建并返回此对象的一个副本

         注意事项：

         Object 类的clone方法执行特定的复制操作。首先，如果此对象的类不能实现接口cloneable,则会抛出                          CloneNotException.

        例子：

 

  1. public class ObjectDemo {
  2. 	
  3. 	public static void main(String[] args) throws CloneNotSupportedException {//该异常是编译时期异常
  4. 		//创建s1这个学生对象
  5. 		Student s1 = new Student() ;
  6. 		s1.setName("高圆圆") ;
  7. 		s1.setAge(27) ;
  8. 		
  9. 		System.out.println(s1.getName()+"---"+s1.getAge());
  10. 		
  11. 		//复制s1这个对象
  12. 		Object obj = s1.clone() ;
  13. 		//向下转型:
  14. 		Student s2 = (Student) obj;
  15. 		System.out.println(s2.getName()+"---"+s1.getAge());
  16. 		System.out.println("----------------------");
  17. 		
  18. 		//没有讲clone方法之前:
  19. 		Student s3 = s1; //把s1地址值赋值s3对象,s3指向s1的堆内存中的地址值
  20. 		System.out.println(s3.getName()+"---"+s3.getAge());
  21. 	}
  22. }

  1. public class Student implements Cloneable{
  2. 	
  3. 	private String name ;
  4. 	private int age ;
  5. 	
  6. 	public Student() {
  7. 		super();
  8. 	}
  9. 	public Student(String name, int age) {
  10. 		super();
  11. 		this.name = name;
  12. 		this.age = age;
  13. 	}
  14. 	public String getName() {
  15. 		return name;
  16. 	}
  17. 	public void setName(String name) {
  18. 		this.name = name;
  19. 	}
  20. 	public int getAge() {
  21. 		return age;
  22. 	}
  23. 	public void setAge(int age) {
  24. 		this.age = age;
  25. 	}
  26. 	
  27. 	
  28. 	//重写Object类中clone()
  29. 	@Override
  30. 	protected Object clone() throws CloneNotSupportedException {
  31. 		return super.clone();
  32. 	}
  33. 	
  34. 	
  35. }

二.Scanner

    1.Scanner:用来创建一个文本扫描器(键盘录入)
      2.java高级特性:IO流(后面讲)
  BufferReder:字符缓冲流来键盘录入
                java.util.Scanner;s
         Scanner sc = new Scanenr(System.in);
  
     3.   System类中的静态字段:
  public static final InputStream in:  标准输入流
  InputStream :字节流InputStream is = System.in ;  实质:抽象类多态
public static final OutputStream out:  标准输出流
  
    4.开发步骤:
1)创建键盘录入对象
2)录入数据
3)输出
   5.  Scanner类中常用的方法:
   判断的功能:
   细节:可以添加逻辑判断
hasNextXXX(); 在录入数据之前,加上判断功能,判断是否由下一个可以录入的XXX类型的数据
   nextXXX();//通过录入获取这个int类型的数据
                        举例:
public boolean hasNextInt()
nextInt();
 
nextInt():录入int类型的数据
   nextLine():录入一个字符串类型
  
                异常： java.util.InputMismatchException:输入和想要的数据不匹配

例子：

  1. public class ScannerDemo2 {
  2. 	
  3. 	public static void main(String[] args) {
  4. 		//创建键盘录入对象
  5. 		
  6. 		Scanner sc = new Scanner(System.in) ;
  7. 		
  8. 		if(sc.hasNextInt()){
  9. 			//是否有下一个可以录入的int类型的数据
  10. 			//录入数据
  11. 			int a = sc.nextInt() ;
  12. 			System.out.println("a:"+a);
  13. 		}else{
  14. 			//错误提示
  15. 			System.out.println("录入的数据类型和想要的不匹配!");
  16. 		}
  17. 		
  18. 		//java.util.InputMismatchException:输入和想到的数据不匹配
  19. 		
  20. 	}
  21. }

6.Scanner类中的注意事项:
              先录入int类型的数据,在录入String类型数据,第二次录入的数据没有接收到,直接输出结果了,由于"回车"才能接               收数据回车换行符导致的!
        解决方案:
         在第二次录入String类型数据之前,需要重新创建键盘录入对象录入String类型


例子：

  1. public class ScannerDemo3 {
  2. 	
  3. 	public static void main(String[] args) {
  4. 		
  5. 		//键盘录入对象
  6. 		Scanner sc = new Scanner(System.in) ;
  7. 		
  8. 		//先录入两个int类型的数据
  9. 		/*int a = sc.nextInt() ;
  10. 		int b = sc.nextInt() ;
  11. 		System.out.println("a:"+a+",b:"+b);*/
  12. 		
  13. 		//录入两个String类型的数据
  14. 		//hasNextLine
  15. 		/*String a = sc.nextLine() ;
  16. 		String b = sc.nextLine() ;*/
  17. 		
  18. 		//先录入String类型的数据,在录入int类型的数据
  19. 		/*String a = sc.nextLine() ;
  20. 		int b = sc.nextInt() ;*/
  21. 		
  22. 		//先录入int类型,再录入String类型
  23. 		int a = sc.nextInt() ;
  24. //		String b = sc.nextLine() ;
  25. 		String b = sc.next() ;
  26. 		/*
  27. 		int a = sc.nextInt() ;
  28. 		//创建键盘录入对象
  29. 		Scanner sc2 = new Scanner(System.in) ;
  30. 		String b = sc2.nextLine() ;
  31. 		*/
  32. 		
  33. 		
  34. 		System.out.println("a:"+a+",b:"+b);
  35. 	}
  36. }


三.String类:代表字符串。

   1.Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现;字符串一旦被赋值,其值不能再改变
   2.String类常用的构造方法:
   （1）String():表示一个空字符序列。
   （2） public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
   （3）public String(byte[] bytes,int index,int length):将部分字节数组构造成一个字符串
   （4）public String(char[] value):将字符数组构造成一个字符串
   （5）public String(char[] value,int index,int length):将部分的字符数组构造成一个字符串
   （6）public String(String original):通过字符串常量构造一个字符串对象
  （7） 获取字符串的长度功能:
   public int length()
  面试题:
   数组中有没有length(),字符串(字符串缓冲区:StringBuffer)中没有length(),集合中有没有length()(集合后面讲)?
   数组没有length(),length属性
   字符串中有length()
   集合中没有length(),获取集合中元素数量:size()
        编码和解码:一定要保证编码格式一致
   编码:
                把能看懂的东西转换成一个看不懂的东西:String----->byte[]:public byte[] getBytes(String charsetName)
  解码:
   把当前的byte[]转成能看懂的东西(String):byte[]----->String  :public String(byte[] bytes,CharsetName ch)
 
例子：

  1. public class StringDemo {
  2. 	
  3. 	public static void main(String[] args) throws UnsupportedEncodingException {
  4. 		//创建一个String对象
  5. 		String s1 = new String() ;
  6. 		System.out.println("s1.length():"+s1.length());
  7. 		System.out.println("s1:"+s1);
  8. 		System.out.println("----------------------");
  9. 		
  10. 		//public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
  11. 		//创建一个字节数组
  12. 		byte[] bys = {97, 98, 99, 100, 101} ; 
  13. 		String s2 = new String(bys) ;//字节的值要找它对应的ASCII码表中的字符
  14. 		System.out.println("s2:"+s2);
  15. 		//abcde
  16. 		System.out.println("s2.length():"+s2.length());//5
  17. 		System.out.println("----------------------");
  18. 		
  19. 		/**
  20. 		 * 编码和解码
  21. 		 */
  22. 		//定义一个字符串:
  23. 		String s = "你好" ;
  24. 		//[-60, -29, -70, -61]  :GBK
  25. 		//[-28, -67, -96, -27, -91, -67]:utf-8
  26. //		byte[] bys2 = s.getBytes("utf-8") ;//编码:以:GBK格式编码     utf-8:一个中文:对应三个字节
  27. 		byte[] bys2 = s.getBytes() ;
  28. //		System.out.println(bys2);
  29. 		//Arrays:数组工具类:toString(byte[] bys)
  30. 		System.out.println(Arrays.toString(bys2));
  31. 		
  32. 		System.out.println("-------");
  33. //		String str = new String(bys2, "utf-8") ;
  34. 		String str = new String(bys2) ;
  35. 		System.out.println("str:"+str);
  36. 		
  37. 		System.out.println("------------------");
  38. 		//public String(char[] value):将字符数组构造成一个字符串
  39. 		//定义一个字符数组
  40. 		char[] chs = {'我','爱','高','圆','圆'} ;
  41. 		String s3 = new String(chs) ;
  42. 		System.out.println("s3.length():"+s3.length());
  43. 		System.out.println("s3:"+s3);
  44. 		
  45. 		System.out.println("--------------------");
  46. 		String s4 = new String(chs, 1, 4) ;
  47. 		System.out.println("s4:"+s4);
  48. 		System.out.println("s4.length():"+s4.length());
  49. 		
  50. 		System.out.println("--------------------");
  51. 		//public String(String original):通过字符串常量构造一个字符串对象
  52. 		String s5 = new String("hello") ;
  53. 		System.out.println("s5:"+s5);
  54. 		System.out.println("s5.length():"+s5.length());
  55. 		
  56. 		
  57. 		String s6 = "hello" ;
  58. 		System.out.println("s6:"+s6);
  59. 		System.out.println("s6.length():"+s6.length());
  60. 		
  61. 		
  62. 	}
  63. }

3.字符串的一个特点:一旦被赋值,其值不能被改变(不可变的字符序列)。

   面试题:
String s = "hello"和String s = new String("hello") 两个有什么区别?分别创建了几个对象
  
第一个创建了一个对象
第二个s创建两个对象(堆内存中有new String(),然后字符串常量池中也有这样一个字符串常量(开辟空间的地址))

 例子：

  1. public class StringDemo {
  2. 	public static void main(String[] args) {
  3. 		
  4. 		String s = "hello" ;	// String s = "abc" ;
  5. 		
  6. 		/*s += "world" ;
  7. 		
  8. 		System.out.println("s:"+s);*/
  9. 		
  10. 		change(s) ;
  11. 		
  12. 		//输出字符串变量
  13. 		System.out.println("s:"+s);//hello
  14. 		
  15. 	}
  16.  
  17. 	public static void change(String s) {//String类型作为形式参数和基本数据类型的效果一样
  18. 		
  19. 		s += "javaweb" ;
  20. 	}
  21. }

4.String类的中常用的判断功能:
 *            （1）boolean equals(Object obj):当前该对象是否obj这个对象是否相等;
（2）boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
（3）boolean contains(String str):判断str这个字符串是否包含在当前字符串中
（4）boolean startsWith(String str):是否以str子字符串开头
（5）boolean endsWith(String str):判断是否以str子字符串结尾
（6）boolean isEmpty():判断字符串是否为空

String s = "" ;空字符
String s = " " ;字符串"空格"
String s = null ;当前字符串对象为空


例子： 


  1.  public class StringDemo {
  2. 	
  3. 	public static void main(String[] args) {
  4. 		
  5. 		//定义一个字符串
  6. 		String s1 = "helloworld" ;
  7. 		String s2 = "HelloWorld" ;
  8. 		
  9. //		boolean equals(Object obj):当前该对象是否obj这个对象是否相等;String重写equals(),比较的是两个字符串的内容是否相同
  10. 		System.out.println("equals:"+s1.equals(s2));
  11. 		//boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
  12. 		System.out.println("equalsIgnoreCase:"+s1.equalsIgnoreCase(s2));
  13. 		
  14. 		//boolean contains(String str):判断str这个字符串是否包含在当前字符串中
  15. 		System.out.println("contains:"+s1.contains("owo"));
  16. 		System.out.println("contains:"+s1.contains("ak47"));
  17. 		
  18. 		//boolean startsWith(String str):是否以str子字符串开头
  19. 		System.out.println("starsWith:"+s1.startsWith("hel"));
  20. 		//boolean endsWith(String str):判断是否以str子字符串结尾  自己测试
  21. 		
  22. 		//boolean isEmpty():判断字符串是否为空
  23. 		System.out.println("isEmpty:"+s1.isEmpty());
  24. 	}
  25. }







5.字符串变量相加,先开辟空间,在相加
   字符串常量相加:首先在字符串常量池找,有没有当前这个常量值,有,就直接返回,没有,需要创建!

例子： 


  1. public class StringDemo2 {
  2. 	
  3. 	public static void main(String[] args) {
  4. 		String s1 = "hello";  
  5. 		String s2 = "world";
  6. 		String s3 = "helloworld";
  7. 		System.out.println(s3 == s1 + s2);// false
  8. 		//System.out.println(s3 == (new StringBuilder(String.valueOf(s1))).append(s2).toString());
  9. //		s1+s2 ====>new String("helloworld")
  10. 		System.out.println(s3.equals((s1 + s2)));//true , 
  11.  
  12.  
  13. 		System.out.println(s3 == "hello" + "world");//true
  14. 		System.out.println(s3.equals("hello" + "world"));//true
  15. 		
  16. 		/**
  17. 		 * 通过反编译工具查看第三个输出语句:
  18. 		 * System.out.println(s3 == "helloworld");
  19. 			System.out.println(s3.equals("helloworld"));
  20. 		 * */
  21. 	}
  22. }






6.String类的获取功能:
  int length() :获取字符串长度功能
char charAt(int index):返回的是索引处对应的字符
int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
为什么这里的字符用int来定义: 97 'a'
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索引)

例子： 
  1. public class StringDemo {
  2. 	
  3. 	public static void main(String[] args) {
  4. 		//定义一个字符串:
  5. 		String str = "helloworld" ;
  6. 		
  7. 		//int length()	:获取字符串长度功能
  8. 		System.out.println("length:"+str.length());
  9. 		
  10. 		//char charAt(int index):返回的是索引处对应的字符
  11. 		System.out.println("charAt:"+str.charAt(1));
  12. 		System.out.println("charAt:"+str.charAt(8));
  13. 		System.out.println("-------------------------------");
  14. 		
  15. 		//int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
  16. 		System.out.println("indexof:"+str.indexOf('l'));
  17. 		System.out.println("indexof:"+str.indexOf('k'));//-1
  18. 		
  19. 		//int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引
  20. 		System.out.println("indexOf:"+str.indexOf("owo"));
  21. 		System.out.println("-------------------------------");
  22. 		//int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
  23. 		System.out.println("indexOf:"+str.indexOf('l', 4));
  24. 		
  25. 		//int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索 (自己测试)
  26. 		
  27. 		//String substring(int start):从指定位置开始截取字符串,默认截取到末尾(返回一个新的字符串,不再是字符串本身!)
  28. 		System.out.println("substring:"+str.substring(5));
  29. 		
  30. 		//String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引)
  31. 		System.out.println("substring:"+str.substring(4, 8));//owor
  32. 	}
  33. }






7.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):字符串拼接方法


例子 
  1. public class StringDemo {
  2. 	
  3. 	//构造方法:
  4. 	//构造方法不能使用递归
  5. 	/*public StringDemo(){
  6. 		StringDemo();
  7. 	}*/
  8. 	
  9. 	public static void main(String[] args) {
  10. 		//定义一个字符串
  11. 		String s = "JavaSE" ;
  12. 		
  13. 		//byte[] getBytes():将字符串转换字节数组
  14. 		byte[] bys = s.getBytes() ;
  15. 		//遍历字节数组
  16. 		for(int x = 0 ; x < bys.length ; x++){
  17. 			System.out.println(bys[x]);
  18. 		}
  19. 		System.out.println("---------------------");
  20. 		
  21. 		//char[] toCharArray():将字符串转换成 字符数组
  22. 		char[] chs = s.toCharArray() ;
  23. 		for (int x = 0; x < chs.length; x++) {
  24. 			System.out.println(chs[x]);
  25. 		}
  26. 		
  27. 		System.out.println("---------------------");
  28. 		
  29. 		//static String valueOf(char[] chs):将字符数组转换成字符串
  30. 		String s2 = String.valueOf(chs) ;
  31. 		System.out.println("s2:"+s2);
  32. 		
  33. 		//static String valueOf(int i):将一个int类型的数据转换成字符串
  34. 		String s3 = String.valueOf(100) ;
  35. 		System.out.println("s3:"+s3);
  36. 		
  37. 		//String toLowerCase():将字符串全部转成小写
  38. 		System.out.println("toLowerCase:"+s.toLowerCase());
  39. 		//String toUpperCase():将字符串全部转换成大写
  40. 		System.out.println("toUpperCase:"+s.toUpperCase());
  41. 		
  42. 		//String concat(String str):字符串拼接方法
  43. 		String s4 = "hello" ;
  44. 		String s5 = "world" ;
  45. 		System.out.println("contact:"+s4.concat(s5));
  46. 		
  47. 		String s6 = "java" ;
  48. 		s6 += "web" ;
  49. 		System.out.println("s6:"+s6);


8.方法嵌套
  Math.max(Math.max(a,b),c);
  
9.方法递归:方法调用本身的一种现象
 
三个条件:
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 *１　
}
}
}






声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/人工智能uu/article/detail/935614
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号