java第十天~第十一天/10.28~10.29

javaSE第十天/10.28

一、Object类

Object类:
* 类 Object 是类层次结构的根类。每个类都使用 Object 作为超类(父类)。所有对象（包括数组）都实现这个类的方法。
* public int hashCode()返回该对象的哈希码值
* hashCode()—–>通过哈希算法(哈希表:hashtable)—->地址值(不是实际意义上的地址值!)
*
* public final Class getClass()返回此 Object 的运行时类 (Java反射机制中讲!)
* Class类中有一个方法:
* public String getName()以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。

Object类中的常用方法
（1）public static getClass（）；返回当前运行的那个类 class 包名.类名

package org.westos.Object_01;

public class ObjectDemo {
public static void main(String[] args) {
    Student s1=new Student();
    Class c1=s1.getClass();
    System.out.println(c1);//class org.westos.Object_01.Student
    String name=c1.getName();
    System.out.println(name);//org.westos.Object_01.Student 全路径名称

}
}

public class Student extends Object {

}

（2）hashCode（）；底层是根据哈希表（哈希算法）算出来的，理解为地址值

package org.westos.Object_01;

public class ObjectDemo {
public static void main(String[] args) {
    Student s1=new Student();
    System.out.println(s1.hashCode());//582051183
    Student s2=new Student();
    System.out.println("hello".hashCode());//常量的哈希值是不变的---99162322  
}
}

public class Student extends Object {

}

（3）public String toString（）；就是来构造一个字符串，建议所有子类都重写此方法
直接输出对象名和适用对象名调用toString（）；结果一样 全路径名称：包名.类名
Object的另一个方法:
* public String toString();返回该对象的字符串表示(建议所有子类都重写此方法)
*
* Integer类中有一个方法:
* public static String toHexString(int i):将一个int类型的数据转换成一个十六进制的字符串表现形式
*
* 如果直接输出对象名称,想要显示当前对象的成员变量的值,那么必须重写Object类中的toString()方法

package org.westos.object_02;

public class ObjectDemo {
public static void main(String[] args) {
    Student s1=new Student("sunshine",20);
    System.out.println(s1);
    //org.westos.object_02.Student@6f404c51
    //没有重写toString（）时
    System.out.println(s1);
    //Student [name=sunshine, age=20]
    //重写了toString（）方法后
    System.out.println(s1.toString());
    //Student [name=sunshine, age=20]
    //两次结果一样，做了同一个功能
    /*通过查看toString()源码:
     *  public String toString() {
            return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
        }
        toString()<==> 对象名.getClass().getName() +"@" +Integer.toHexString(对象名.hashCode())
     */
    System.out.println(s1.getClass()+"@"+Integer.toString(s1.hashCode()));
    //class org.westos.object_02.Student@1119746574
    Student s2=new Student("sunshine",20);
    System.out.println(s2);
    System.out.println(s1==s2);//false
}
}
package org.westos.object_02;

public class Student extends Object{
private String name;
private int age;
public Student() {
    super();
}
public Student(String name, int age) {
    super();
    this.name = name;
    this.age = age;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}
//Alt+shift+s-->s
//自动生成
@Override
public String toString() {
    return "Student [name=" + name + ", age=" + age + "]";
}

}

（4）equal（）；默认比较地址值，重写了Object类中的equal（）方法，就会比较两个对象的内容是否相同。
Object中的另一个方法：
* public boolean equals(Object obj)指示其他某个对象是否与此对象“相等”。
*
* 面试题:
* ==和equal()方法的区别
* ==:比较的是两个对象的地址值是否相同,
* equals()方法默认比较的是两个对象的地址值是否相同,如果重写了Object类中的equals()方法,那么默认比较就是两个对象的内容是否相同
*
* 使用工具自动生产equals()方法
*
* javascript:Array对象,Number对象,String对象,valueOf():====>s1.valueOf(s2) ;比较是内容是否相同

package org.westos.object_03;

public class ObjectDemo {
public static void main(String[] args) {
    Student s1=new Student("sunshine",20);
    Student s2=new Student("sunshine",20);
    System.out.println(s1==s2);//false
    System.out.println("--------------");
    Student s3=s1;
    System.out.println(s1==s3);//true
    System.out.println("--------------");
    System.out.println(s1.equals(s2));//true，已经重写了equal()
    /**
     * equals()方法的源码
     *   public boolean equals(Object obj) {
        return (this == obj);
    }
        由于Object类中的equals()方法底层是通过"=="来实现的,所以默认比较的是地址值,如果想比较内容是否相同,需要重写equals()方法
     * */
}
}

public class Student {
private String name;
private int age;
 public Student(){
     super();
 }
 public Student(String name,int age){
     super();
     this.name=name;
     this.age=age;
 }
 public void setName(String name){
     this.name=name;
 }
 public String getName(){
     return name;
 }
 public void setAge(int age){
     this.age=age;
 }
 public int getAge(){
     return age;
 }
@Override
public String toString() {
    return "Student [name=" + name + ", age=" + age + "]";
}
@Override
public boolean equals(Object obj) { //Studnet s2 = new Student() ;
    if (this == obj)
        return true;
    if (obj == null)  //当前传入过来的对象是否为空
        return false;
    if (getClass() != obj.getClass())   //this.getClass() != s2.getClass()      
        return false;
    Student other = (Student) obj;
    if (age != other.age)
        return false;
    if (name == null) {
        if (other.name != null)
            return false;
    } else if (!name.equals(other.name))
        return false;
    return true;
}

}

（5）clone（）；要使用该方法，那么当前对象所在的那个类一定要实现cloneable接口，重写Object类中clone（）方法，才能复制对象。
Object类中的其他两个方法:
* protected void finalize()throws Throwable:当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法,但是,什么时候调用垃圾回收器
* 不确定;
*
* System类中的一个方法:
* public void gc():运行垃圾回收器,这个垃圾回收器最终调用的就是finalize()方法
*
*protected Object clone()创建并返回此对象的一个副本
throws CloneNotSupportedException

        注意事项:
        Object 类的 clone 方法执行特定的复制操作。首先，如果此对象的类不能实现接口 Cloneable，则会抛出 CloneNotSupportedException。

package org.westos.object_04;

public class ObjectDemo{
public static void main(String[] args) throws CloneNotSupportedException{
    Student s1=new Student();
    s1.setName("sunshine");
    s1.setAge(20);
    System.out.println(s1.getName()+"---"+s1.getAge());//sunshine---20
    System.out.println("------------");
    Object obj=s1.clone();
    Student s2=(Student) obj;
    System.out.println(s2.getName()+"---"+s2.getAge());//sunshine---20
    System.out.println("------------");
    //没讲clone()之前
    Student s3=s1;//把s1地址值赋给s3对象，s3指向s1的堆内存地址
    System.out.println(s3.getName()+"---"+s3.getAge());//sunshine---20
}
}

public class Student implements Cloneable{
private String name;
private int age;
public Student() {
    super();
}
public Student(String name, int age) {
    super();
    this.name = name;
    this.age = age;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}
@Override
    protected Object clone() throws CloneNotSupportedException {

        return super.clone();
    }
}

（6）finalize（）；和垃圾回收器有关。

二、Scanner类

1、创建键盘录入

• 1)Scanner:用来创建一个文本扫描器(键盘录入)
• 2)java高级特性:IO流(后面讲)
• BufferReder:字符缓冲流来键盘录入
  *java.util.Scanner;s
• Scanner sc = new Scanenr(System.in);
• 
  
  • System类中的静态字段:
• public static final InputStream in: 标准输入流
• InputStream :字节流 InputStream is = System.in ; 实质:抽象类多态
• public static final OutputStream out: 标准输出流
• 
  
  • 开发步骤:
• 1)创建键盘录入对象
• 2)录入数据
• 3)输出

package org.westos.scanner;
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args) {
    //创建键盘录入对象
    Scanner sc=new Scanner(System.in);
    //录入数据
    System.out.println("请您输入一个数");
    int a=sc.nextInt();
    System.out.println("您输入的数是：");
    System.out.println(a);
}
}

2、 Scanner类中常用的方法:

• 判断的功能:
• 细节:可以添加逻辑判断
• hasNextXXX(); 在录入数据之前,加上判断功能,判断是否有下一个可以录入的XXX类型的数据
• nextXXX();//通过录入获取这个int类型的数据
• 
  
  • 举例:
• public boolean hasNextInt()
• nextInt();
• 
  
  • nextInt():录入int类型的数据
• nextLine():录入一个字符串类型
• 
  
  • java.util.InputMismatchException:输入和想到的数据不匹配

package org.westos.scanner;
import java.util.Scanner;

public class ScannerDemo2 {
public static void main(String[] args) {
    //创建键盘录入
    Scanner sc=new Scanner(System.in);
    System.out.println("请您输入一个数据");
    if(sc.hasNextInt()){
        int a=sc.nextInt();
        System.out.println(a);
    }
    else{
        //错误提示
        System.out.println("录入的数据与想要的数据类型不匹配");
    }
}
}

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

package org.westos.scanner;
import java.util.Scanner;
public class ScannerDemo3 {
public static void main(String[] args) {
    //创建键盘录入对象
    Scanner sc=new Scanner(System.in);

    /*
    //录入两个int类型数据
    System.out.println("请输入两个数");
    int a1=sc.nextInt();
    int b1=sc.nextInt();
    System.out.println(a1+"---"+b1);//8---24
    System.out.println("-------------");
    */

    /*
    //录入两个String类型数据
    System.out.println("请输入两个字符串");
    String a2=sc.nextLine();
    String b2=sc.nextLine();
    System.out.println(a2+"---"+b2);//kobe---bryant
    System.out.println("-------------");
    */

    /*
    //先录入一个String类型，再录入一个int类型
    System.out.println("请先输入一个字符串，再输入一个数");
    String a3=sc.next();
    int b3=sc.nextInt();
    System.out.println(a3+"---"+b3);//kobe---24
    System.out.println("--------------");
    */

    /*
    //先录入一个int类型，再录入一个String类型
    System.out.println("请先输入一个数，再输入一个字符串");
    int a4=sc.nextInt();
    String b4=sc.nextLine();
    System.out.println(a4+"---"+b4);//24---
    //先录入int类型的数据,在录入String类型数据,第二次录入的数据没有接收到,直接输出结果了,由于"回车"才能接收数据
    //回车换行符导致的!
     */
    System.out.println("请先输入一个数，再输入一个字符串");
    int a4=sc.nextInt();
    Scanner sc2=new Scanner(System.in);
    String b4=sc2.nextLine();
    System.out.println(a4+"---"+b4);//24---kobe
}
}

三、String类

1、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(),字符串(字符串缓冲区: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)

• 举例:
• 谍战片:
• 今天老地方见:
• 
  
  • 编码:”今”—–>字节数组:byte[]—->字节类型:形成一种二进制数据
• 解码:二进制数据—->十进制进制数据—–>String:”今”

package org.westos.string_01;

public class StringDemo {
public static void main(String[] args) {
    String s1=new String();
    System.out.println(s1.length());//0
    System.out.println(s1); //底层已经重写String()，什么也没有
    System.out.println("---------");

    byte[] bys={97, 98, 99, 100, 101};
    String s2=new String(bys);
    System.out.println(s2);//abcde
    System.out.println(s2.length());
}
}

2、字符串的一个特点
一旦被赋值,其值不能被改变(不可变的字符序列)
*
* 面试题:
* String s = “hello”
* 和String s = new String(“hello”) 两个有什么区别?分别创建了几个对象
*
* 第一个创建了一个对象
* 第二个s创建两个对象(堆内存中有new String(),然后字符串常量池中也有这样一个字符串常量(开辟空间的地址))

package org.westos.string_02;

public class StringDemo {
public static void main(String[] args) {
    String s="hello";
    s += "world";
    System.out.println(s);//helloworld
    System.out.println("----------");
    System.out.println(s);//helloworld
}
public static void change(String s){//String类型作为形式参数和基本数据类型的效果一样
    s+="javaweb";
}
}

3、看程序写结果

package org.westos.string_02;
/**
 * 看程序写结果
 * @author 小鑫
 */
public class StringDemo2 {
public static void main(String[] args) {
    String s1=new String("hello");
    String s2=new String("hello");
    System.out.println(s1==s2);//false
    System.out.println("----------");
    String s3="java";
    String s4="java";
    System.out.println(s3==s4);//true
    System.out.println(s3.equals(s4));//true
    System.out.println("----------");
    String s5=new String("world");
    String s6="world";
    System.out.println(s5==s6);//flase既指向new String 又指向world
    System.out.println(s5.equals(s6));//true
}
}

4、练习
* 需求:模拟用户登陆,给3次机会,并给提示
* 分析:
* 假设:定义一个用户和密码
* String name = “sunshine” ;
* String password = “12345” ;
* 2)创建键盘录入对象,录入用户名和密码
* 3)给3次机会,使用for循环进行操作for(int x = 0 ; x <3 ; x ++){}
*
* 录入:录入的用户和密码来和已经存在的用户名和密码进行比较,
* 判断:如果一致:
* 登陆成功
* 不一致:
* 有一个不符合,就登陆不成功
* if((2-x)==0){
* }else{
* //输出还有(2-x)次机会
* }

package org.westos.string_03;
import java.util.Scanner;
/**
 * 需求:模拟用户登陆,给3次机会,并给提示
 *      
 *  分析:
 *      假设:定义一个用户和密码
 *      String name = "sunshine" ;
 *      String password = "12345" ;
 *      2)创建键盘录入对象,录入用户名和密码
 *      3)给3次机会,使用for循环进行操作for(int x = 0 ; x <3 ; x ++){}
 *          
 *      录入:录入的用户和密码来和已经存在的用户名和密码进行比较,
 *          判断:如果一致:
 *              登陆成功
 *          不一致:
 *              有一个不符合,就登陆不成功
 *              if((2-x)==0){
 *              }else{
 *                  //输出还有(2-x)次机会
 *              }
 * */
public class StringTest {
public static void main(String[] args) {
    //定义用户名和密码
    String name="sunshine";
    String password="12345";
    //提供三次登录机会
    for(int i=0;i<3;i++){
        //创建键盘录入对象
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入用户名");
        String newUserName=sc.nextLine();
        System.out.println("请输入密码");
        String newPassword=sc.nextLine();
        if(name.equalsIgnoreCase(newUserName)&&password.equalsIgnoreCase(newPassword)){
            System.out.println("登录成功，开始玩游戏");
            GuessNumberGame.start();
            break;
        }else{
            if((2-i)==0){
                System.out.println("您已登录错误三次，请与管理员联系");
            }else{
                System.out.println("登录错误，你还有"+(2-i)+"次机会");
            }
        }
    }
}
}
package org.westos.string_03;
import java.util.Scanner;
public class GuessNumberGame {

    public static void start(){
        //生成一个随机数：Math.random();
        int number=(int)(Math.random()*100+1);
        //定义一个统计变量
        int count=0;
        //多次录入
        while(true){
            Scanner sc=new Scanner(System.in);
            System.out.println("请您输入一个数字：");
            int guessNumber=sc.nextInt();
            count++;
            //判断
            if(guessNumber>number){
                System.out.println("您猜的数字："+guessNumber+"大了");
            }else if(guessNumber<number){
                System.out.println("您猜的数字"+guessNumber+"小了");
            }else{
                System.out.println("恭喜您"+count+"次猜中了");
                break;
            }
        }
    }
}

5、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 ;当前字符串对象为空

package org.westos.string_03;
/**
 * 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 ;当前字符串对象为空
 * @author 小鑫
 */
public class StringDemo {
 public static void main(String[] args) {
    //定义一个字符串
     String s1="helloworld";
     String s2="helloworld";

     //boolean equals(Object obj):当前该对象与obj这个对象是否相等
     System.out.println("equals"+s1.equals(s2));//equalstrue
     //boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
     System.out.println("equalsIgnoreCase"+s1.equalsIgnoreCase(s2));//equalsIgnoreCasetrue
     //boolean contains(String str):判断str这个字符串是否包含在当前字符串中
     System.out.println("contains"+s1.contains("owo"));//containstrue
     System.out.println("contains"+s1.contains("abc"));//containsfalse
     //boolean startsWith(String str):是否以str子字符串开头
     System.out.println("startWith"+s1.startsWith("hel"));//startWithtrue
     //boolean endsWith(String str):判断是否以str子字符串结尾
     System.out.println("endWith"+s1.endsWith("ld"));//endWithtrue
     //boolean isEmpty():判断字符串是否为空
     System.out.println("isEmpty"+s1.isEmpty());//isEmptyfalse
}
}

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

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

 * @author 小鑫
 */
public class StringDemo {
  public static void main(String[] args) {
    //定义一个字符串
      String str="helloworld";

      //int length()    获取字符串长度
      System.out.println("length"+str.length());//10

      //char charAt(int index):返回的是索引处对应的字符
      System.out.println("chatAt"+str.charAt(1));//e
      System.out.println("chatAt"+str.charAt(6));//o
      System.out.println("--------------------");

      //int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
      System.out.println("indexOf"+str.indexOf('l'));//2
      System.out.println("indexOf"+str.indexOf('k'));//负数

      //int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引
      System.out.println("indexOf"+str.indexOf("owo"));//4
      System.out.println("--------------------");

      //String substring(int start):从指定位置开始截取字符串,默认截取到末尾
      System.out.println("substring"+str.substring(2));//lloworld

      //String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引)
      System.out.println("substring"+str.substring(5,10));//world


}
}

7、字符串的遍历

package org.westos.string_04;
/**
 * 字符串的遍历
 * @author 小鑫
 *
 */
public class StringTest1 {
  public static void main(String[] args) {
    //定义字符串
      String s="helloworld";

      //开始的做法
      System.out.println(s.charAt(0));
      System.out.println(s.charAt(1));
      System.out.println(s.charAt(2));
      System.out.println(s.charAt(3));
      System.out.println(s.charAt(4));
      System.out.println(s.charAt(5));
      System.out.println(s.charAt(6));
      System.out.println(s.charAt(7));
      System.out.println(s.charAt(8));
      System.out.println(s.charAt(9));
      System.out.println("---------");
      //代码重复度高，使用for循环
      for(int i=0;i<s.length();i++){
          System.out.print(s.charAt(i)+" ");
      }
}
}

8、把数组中的数据按照指定个格式拼接成一个字符串举例：

package org.westos.string_04;
/**
 * 把数组中的数据按照指定个格式拼接成一个字符串举例：
 *      int[] arr = {1,2,3};    输出结果：[1, 2, 3]
 *      
 * 分析:
 *      1)定义数组:int[] arr = {1, 2, 3}
 *      2)定义空字符串:String s = "" ;
 *      3)用空串拼接一个"["
 *      4)遍历int类型的数组,获取到每一个数组中的元素
 *          判断当前某一个索引是否是最大索引
 *          如果是:用空串+= arr[x] ;
 *              用空串 +="]";
 *          不是:
 *              用空串+= arr[x]
 *              用空串+= ", "
 * @author 小鑫
 *
 */
public class StringTest2 {
   public static void main(String[] args) {
    int[] arr={1,2,3,4,5};
    String result = arrayToString(arr);
    System.out.println(result);//[1,2,3,4,5]
  }
   //明确返回值是String类型
   //明确参数类型是int[] arr
   public static String arrayToString(int[] arr){
      //定义空川
       String result="";
      //拼接左[
       result+="[";
       for(int i=0;i<arr.length;i++){
           if(i==arr.length-1){
               result+=arr[i];
               result+="]";
           }else{
               result+=arr[i];
               result+=",";
           }
       }
      return result; 
   }
}

9、统计一串字符串中出现字母，数字的个数。

package org.westos.string_04;
import java.util.Scanner;
/**
 * 需求：使用键盘录入一个字符串:统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数，和其他字符出现的次数。
 * 
 * 举例:
 *      "Hello 123 World"
 * 
 *      大写字母字符:2个
 *      小写字母字符:8个
 *      数字字符:3个
 * 
 * 分析:
 *      1)定义三个统计变量
     *      int bigCount = 0 ;
     *      int smallCount = 0 ;
     *      int numberCount = 0 ;
     *      int otherCount = 0;
 *      2)创建键盘录入对象,录入一个字符串
 *      3)使用for循环遍历字符串
 *      4)
 *          ASCII码表中
 *                  'a'         97
 *                  'A'         65
 *                  '0'         48  
 *      遍历的时候获取到字符
 *          ch>='a' && ch<='z'
 *              属于小写字母字符
 *              smallCount++;
 *          ch>='A' && ch<='Z'
 *              属于大写字母字符
 *              bigCount++
 *          ch>='0' && ch<='9'
 *              属于数字字符
 *              numberCount++
 *          其他
 *              otherCount++
 *      5)输出
 * 
 * */
public class StringTest3 {
  public static void main(String[] args) {
      //统计个数
      int bigCount=0;
      int smallCount=0;
      int numberCount=0;
      int otherCount=0;
      //创建键盘录入对象
    Scanner sc=new Scanner(System.in);
     //录入
    System.out.println("请输入一串字符");
    String line=sc.nextLine();
    //遍历字符串
    for(int i=0;i<line.length();i++){
        //获取每一个字符
        char ch=line.charAt(i);
        if(ch>='a'&&ch<='z'){
            smallCount++;
        }else if(ch>='A'&&ch<='Z'){
            bigCount++;
        }else if(ch>='0'&&ch<='9'){
            numberCount++;
        }else{
            otherCount++;
        }
    }
    System.out.println("当前字符串中大写字母字符有："+bigCount+++"个");
    System.out.println("当前字符串中小写字母字符有："+smallCount+++"个");
    System.out.println("当前字符串中数字字符有："+numberCount+++"个");
    System.out.println("当前字符串中其他字符有："+otherCount+++"个");
}
}

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

package org.westos.string_05;
/**
 * 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):字符串拼接方法
 * @author 小鑫
 */
public class StringDemo {
   public static void main(String[] args) {
    //定义一个字符串
       String s="HelloJavaSE";

       //byte[] getBytes():将字符串转换字节数组
       byte[] bys=s.getBytes();
        for(int i=0;i<bys.length;i++){
            System.out.print(" "+bys[i]);//72 101 108 108 111 74 97 118 97 83 69
        }
        System.out.println("");
        System.out.println("------------");

        //char[] toCharArray():将字符串转换成 字符数组 (开发中经常使用)
        char[] chs=s.toCharArray();
        for(int i=0;i<chs.length;i++){
            System.out.print(" "+chs[i]);// H e l l o J a v a S E
        }
        System.out.println("");
        System.out.println("-------------");

        //static String valueOf(char[] chs):将字符数组转换成字符串
        String s2=String.valueOf(chs);
        System.out.println(s2);//HelloJavaSE
        //static String valueOf(int i):将一个int类型的数据转换成字符串
        String s3=String.valueOf(1024);
        System.out.println(s3);//1024
        System.out.println("--------------");

        //String toLowerCase():将字符串全部转成小写
        System.out.println("toLowerCase"+s.toLowerCase());//toLowerCasehellojavase
        //String toUpperCase():将字符串全部转换成大写
        System.out.println("toUpperCase"+s.toUpperCase());//toUpperCaseHELLOJAVASE
        System.out.println("--------------");

        //String concat(String str):字符串拼接方法
        String s4="hello";
        String s5="world";
        System.out.println(s4.concat(s5));//helloworld
}
}

javaSE第十一天/10.29

一、String类

1、练习

package org.westos.string_01;
import java.util.Scanner;
/**
 * 需求:键盘录入一个字符串,将该字符串的第一个字母转换成小写,其余的字母字符转换成大写(不考虑其他的字母字符)
 * 
 * 举例:  "Helloworld"
 *  
 *      H--->h
 *      elloworld--->ELLOWORLD
 *  
 * 分析:
 *      A:创建键盘录入对象,录入一个字符串
 *      B:截取:substring(int begin,int end)
 *      C:将上面获取的字符串转换小写
 *      D:在截取刚才录入的这个字符串,substring(int begin):从指定位置截取到末尾,返回一个新的字符串
 *      E:将的得到新的字符串---->转换大写
 *      F:将C和E,使用concat()拼接:字符串拼接方法
 * @author 小鑫
 */
public class StringTest {
   public static void main(String[] args) {
    //创建键盘录入对象
       Scanner sc=new Scanner(System.in);
    //录入接受数据
       System.out.println("请您输入一个字符串");
       String line=sc.nextLine();
       //将收到的数据截取
       String s1=line.substring(0, 1);
       //将得到的第一个字符转换成小写
       String s2=s1.toLowerCase();
       //将line字符串中的其余字母截取出来,默认截取到最后
       String s3=line.substring(1);
       //转换成大写
       String s4=s3.toUpperCase();
       //s2和s4做拼接
       String result=s2.concat(s4);
       System.out.println(result);
       System.out.println("-----------");
       //链式编程
       String result2=line.substring(0, 1).toLowerCase().concat(line.substring(1).toUpperCase());
       System.out.println(result2);
}
}

2、compareTo()源码

package org.westos.string_01;

public class StringDemo2 {
  public static void main(String[] args) {
    String s1="hello";
    String s2="hel";
    String s3="ha";
    System.out.println(s1.compareTo(s2));//2
    /**comparTo()的源码
     *   public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }
     * 
     * */
    System.out.println(s1.compareTo(s3));//4
}
}

3、键盘录入一个字符串,将字符串进行反转

package org.westos.string_01;
import java.util.Scanner;
/**
 * 需求:键盘录入一个字符串,将字符串进行反转
 * 
 * 举例:
 *      "abc"--->"cba"
 * 
 * 分析:
 *      1)创建键盘录入对象,录入并接收一个字符串
 *      2)定义空字符串
 *      3)可以将字符串转换成字符数组:toCharArray();
 *      4)遍历字符数组,倒着遍历
 *      5)遍历之后获取到字符串中的每一个字符,然后使用空串进行拼接
 *      6)输出即可!
 * @author 小鑫
 */
public class StringDemo3 {
   public static void main(String[] args) {
    //创建键盘录入
       Scanner sc=new Scanner(System.in);
    //录入接收数据
       System.out.println("请您输入一个字符串");
       String line=sc.nextLine();
/*  //定义一个空串
       String result="";
    //将字符串转换成字符数组
       char[] chs=line.toCharArray();
    //遍历字符数组，倒着遍历
       for(int i=chs.length-1;i>=0;i--){
           result+=chs[i];
       }
*/
       String result=myReverse(line);
       System.out.println(result);//hello--->olleh 
}
   //写一个功能实现  
   public static String myReverse(String s){
       String result="";
       char[] chs=s.toCharArray();
       for(int i=chs.length-1;i>=0;i--){
          result+=chs[i]; 
       }
       return result;
   }
}

二、StringBuffer类

一、回顾代码块面试题

package org.westos.stringbuffer;
//面试题
import java.util.ArrayList;
class B{
    public static B t1=new B();
    public static B t2=new B();
    {
        System.out.println("构造代码块");
    }
    static{
        System.out.println("静态代码块");
    }
}
public class Demo {
  public static void main(String[] args) {
    B b=new B();
    /*
    构造代码块
    构造代码块
    静态代码块
    构造代码块
    */

    //静态代码块 ,构造代码块,构造方法的优先级问题:
    //静态代码块>构造代码块>构造方法...
}
}

2、StringBuffer类的长度和容量（默认长度为16）

package org.westos.stringbuffer;
/**
 * * 线程(多线程中讲)
 * 线程安全---->同步---->执行效率低!
 * 举例:
 *      银行的网站,医院的平台
 * 线程不安全--->不同步--->执行效率高
 * 举例:
 *      一些论坛网站,相亲网站..
 * 是在开发中,线程不安全可能会造成死锁的现象!
 * 线程安全和执行效率是相对的,并且也是困扰开发者的因素!
 * 
 * StringBuffer:线程安全的可变字符序列
 * 
 * 面试题:
 *      StringBuffer和String 的区别?
 *      StringBuffer会构造一个字符串缓冲区,从内存角度考虑,一般情况使用StringBuffer比较多(在单线程程序中使用StringBulider替代
 * StringBuffer:线程不安全,单线程单纯为了提供执行效率!)
 *      String:普通的一个字符串,从内存角度考虑,耗费空间!
 * 
 * StringBuffer的构造方法:
 *  public StringBuffer ()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
 *  public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区
 *  public StringBuffer(String str)
 *      构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度。
 * 
 *  常用的功能:
 *      public int length():获取字符串长度数
 *      public int capacity():获取当前字符串缓冲区的容量
 * @author 小鑫
 */
public class StringBufferDemo1 {
   public static void main(String[] args) {
    StringBuffer sb=new StringBuffer();
    System.out.println(sb.length());//0
    System.out.println(sb.capacity());//16
    System.out.println("-----------");

    StringBuffer sb2=new StringBuffer(100);
    System.out.println(sb2.length());//0
    System.out.println(sb2.capacity());//100
    System.out.println("-----------");

    StringBuffer sb3=new StringBuffer("hello");
    System.out.println(sb3.length());//5
    System.out.println(sb3.capacity());//21
  }
}

3、StringBuffer中的和添加有关的方法

package org.westos.stringbuffer;
/**
 * StringBuffer中的和添加有关的方法
 *      public StringBuffer append(int/String/char/boolean/double/float....):当前这个方法追加,给缓冲中追加数据,返回字符串缓冲区本身(经常使用的)
 *      public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身
 * @author 小鑫
 */
public class StringBufferDemo2 {
   public static void main(String[] args) {
    //创建字符串缓冲区对象
       StringBuffer sb=new StringBuffer();
       //追加数据
      /* sb.append("hello");
       sb.append(true);
       sb.append(12.34);
       sb.append('A');
       sb.append(12.34F);
       System.out.println(sb);//hellotrue12.34A12.34
       System.out.println("----------");
       */
       //链式编程
       sb.append("hello").append(true).append(12.34).append('A').append(12.34F);
       //public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身
       sb.insert(5,"world");
       System.out.println(sb);//helloworldtrue12.34A12.34
}
}

4、StringBuffer的删除功能:

package org.westos.stringbuffer;
/**
 * StringBuffer的删除功能:
 *      public StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回的是字符串缓冲区本身!
 *      public StringBuffer delete(int start,int end):删除从指定位置开始到指定位置结束的字符,返回的是字符串缓冲区本身!
 * @author 小鑫
 */
public class StringBufferDemo3 {
   public static void main(String[] args) {
    StringBuffer sb=new StringBuffer();
    sb.append("hello");
    sb.append("world");
    sb.append("java");
    //public StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回的是字符串缓冲区本身!
    sb.deleteCharAt(5);//helloorldjava
    sb.delete(5,9);//hellojava
    //全部删除
    sb.delete(0,sb.length());//删完了，打印台不打印
    System.out.println(sb);
}
}

5、 StringBuffer的反转功能:

package org.westos.stringbuffer;
import java.util.Scanner;
/**
 * StringBuffer的反转功能:
 *      public StringBuffer reverse():将此字符串中的字符序列直接反转
 * @author 小鑫
 */
public class StringBufferDemo4 {
   public static void main(String[] args) {
    //创建键盘录入对象
       Scanner sc=new Scanner(System.in);
       //录入接受数据
       System.out.println("请输入一个字符串");
       String line=sc.nextLine();
       StringBuffer sb=new StringBuffer(line);
       String result=sb.reverse().toString();
       System.out.println(result);//hello--->olleh
}
}

6、StringBuffer的替换功能

package org.westos.stringbuffer;
/**
 * StringBuffer的替换功能:
 *  public StringBuffer replace(int start, int end,String str)
 *  从指定位置开始到指定位置结束的字符用str子字符串去替代
 * @author 小鑫
 *
 */
public class StringBufferDemo5 {
  public static void main(String[] args) {
    StringBuffer sb=new StringBuffer();
    sb.append("hello");
    sb.append("world");
    sb.append("java");
    //public StringBuffer replace(int start, int end,String str)
    sb.replace(5, 10, "节日快乐");
    System.out.println(sb);//hello节日快乐java

}
}

7、StringBuffer的截取功能

package org.westos.stringbuffer;
/**
 * /**
 * StringBuffer的截取功能:
 *      public String substring(int start):从指定位置默认截取到末尾,返回值是一个新的字符串
 *      public String substring(int start,int end):从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串
 * @author 小鑫
 *
 */
public class StringBufferDemo6 {
  public static void main(String[] args) {
    StringBuffer sb=new StringBuffer();
    sb.append("hello");
    sb.append("world");
    sb.append("java");
    //public String substring(int start):从指定位置默认截取到末尾,返回值是一个新的字符串
    String s1=sb.substring(5);
    System.out.println(s1);//worldjava
    String s2=sb.substring(5, 10);
    System.out.println(s2);//world
}
}

8、String,StringBuffer,StringBuilder的区别

package org.westos.stringbuffer;
/**
 * 面试题:
 *      String,StringBuffer,StringBuilder的区别?
 *      
 *      String:一个不可变的字符序列,StringBuffer:和StringBuilder是可变的字符序列,在单个线程时候的时候(优先采用StringBuilder)
 *      从线程角度考虑:
 *              StringBuilder线程不安全,不同步,执行效率高!它比StringBuffer要快!
 * 
 * String和StringBuffer作为形式参数
 * 
 * String类型作为形式参数和基本数据类型作为形式参数的效果一样!
 * @author 小鑫
 *
 */
public class StringBuferDemo7 {
   public static void main(String[] args) {
    String s1="hello";
    String s2="world";
    System.out.println(s1+"---"+s2);//hello---world
    System.out.println("-----------------");
    change(s1,s2);
    System.out.println(s1+"---"+s2);//hello---world
    //定义两个字符串缓冲区对象
    StringBuffer sb1=new StringBuffer("hello");
    StringBuffer sb2=new StringBuffer("world");
    System.out.println(sb1+"---"+sb2);//hello---world
    System.out.println("------------------");
    change(sb1,sb2);
    System.out.println(sb1+"---"+sb2);//hello---worldworld
    //缓冲区不变
}
   public static void change(StringBuffer sb1,StringBuffer sb2){
       sb1=sb2;//缓冲区不变，等号并不能改变缓冲区的内容
       sb2.append(sb1);//worldworld
   }
   public static void change(String s1,String s2){
       s1=s2;
       s2=s1+s2;
   }
}

9、String和StringBuffer作为形式参数的区别

String作为形式参数：形参的改变，对实参没有影响，和基本数据类型一致！
StringBuffer作为形式参数：形参的改变会直接影响实参，但是"="不会影响实参的改变!实参是什么，就输出什么 
   append()方法如果去追加缓冲区，那么将对应的缓冲区的值追加过来，返回调用者所在的缓冲区对象

三、Integer类

1、Integer类型范围
就是为了和String类型作为转换

package org.westos.integer;
/**
 * 需求:求一个整数100对应的二进制,八进制,十六进制
 * 需求:要求出Integer类型范围:
 * 
 * java的jkd5.0以后:还有一些新特性:自动拆装箱,可变参数,增强for循环,静态导入,枚举...
 *  
 * 对于每个基本数据类型都会被自动封装成一个引用类型
 *      基本类型                引用类型
 *      int                 Integer
 *      char                Character
 *      byte                Byte
 *      boolean             Boolean
 *      double              Double
 *      float               Float
 *      long                Long
 *      short               Short
 * 
 * 将基本类型--->引用类型的作用:就是为了和String类型作为转换
 * @author 小鑫
 *
 */
public class IntegerDemo {
  public static void main(String[] args) {
    //public static String toBinaryString(int i)
      System.out.println(Integer.toBinaryString(100));//1100100
    //public static String toOctalString(int i)
      System.out.println(Integer.toHexString(100));//64
    //public static String toHexString(int i)
      System.out.println(Integer.toOctalString(100));//144
    //public static final int MAX_VALUE
    //public static final int MIN_VALUE 
      System.out.println(Integer.MAX_VALUE);//2147483647
      System.out.println(Integer.MIN_VALUE);//-2147483648
}
}

2、Integer类的构造方式

package org.westos.integer;
/**
 * Integer类的构造方式:
 *  public Integer(int value):将一个int类型的数据封装成一个引用类型
 *  public Integer(String s):将一个字符数类型封装成一个Integer类型
 *          注意事项:
 *              该字符串必须是数字字符串!,否则:java.lang.NumberFormatException
 * @author 小鑫
 *
 */
public class IntegerDemo2 {
   public static void main(String[] args) {
    //public Integer(int value)
    //创建一个Integer对象
       Integer i=new Integer(100);//将int类型数据封装成引用类型
       //Integer i=100;//jdk5以后的自动装箱
       System.out.println(i);
       //public Integer(String s)
       //String s="abc";必须是数字字符串，否则java.lang.NumberFormatException
       String s="1024";
       Integer ii=new Integer(s);//将一个字符型封装成一个Integer类型
       System.out.println(s);


}
}

3、int类型和String类型的相互转换

package org.westos.integer;
/**
 * int类型和String类型的相互转换
 * @author 小鑫
 *
 */
public class IntegerTest {
   public static void main(String[] args) {
    int number=100;

    //方式1 字符串拼接符
    String s1=""+number;
    System.out.println(s1);

    //方式2 int--->Integer类型
    Integer i=new Integer(number);
    String s2=i.toString();
    System.out.println(s2);

    //方式3 public static String toString(int i)  
    String s3=Integer.toString(number);
    System.out.println(s3);

    //方式4 public static Integer valueOf(int i)
    Integer integer =Integer.valueOf(number);
    String s4=integer.toString();
    System.out.println(s4);
    System.out.println("-------------");
    //定义一个字符串
    String s="100";

    // String--->Integer--->int
    Integer ii=new Integer(s);
    int num=ii.valueOf(s);
    System.out.println(num);
    int num2=Integer.parseInt(s);
    System.out.println(num2);

    //Integer的内存缓存区：IntegerCashe
    //low=-128
    //high=127

    Integer i1=127;     //底层在封装的时候：nteger integer = Inteter.valueOf(int i) ;
    Integer i2=127;
    System.out.println(i1==i2);//ture

    Integer i3=128;
    Integer i4=128;
    System.out.println(i3==i4);//false
}
}

4、Jdk5.0以后的新特性:自动拆装箱

package org.westos.integer;
/**
 * Jdk5.0以后的新特性:自动拆装箱
 * @author 小鑫
 *
 */
public class IntegerTest2 {
  public static void main(String[] args) {
    Integer i=new Integer(100);
    i+=200;
    System.out.println(i);//300
    /**
     * 通过反编译工具查看源码:
     *  Integer i = new Integer(100); //将int类型值通过构造的形式自动装箱为Integer类型
        i = Integer.valueOf(i.intValue() + 200);//i.intValue()--->int类型的数据:把Integer--->int:自动拆箱
        自动装箱了
        System.out.println((new StringBuilder("i:")).append(i).toString());
     */
}
}

四、Character类

1、Character类的基本用法

package org.westos.character;
/**
 * Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段
 * 构造方法:
 *      public Character(char value)构造一个新分配的 Character 对象，用以表示指定的 char 值。 
 * @author 小鑫
 *
 */
public class CharacterDemo {
   public static void main(String[] args) {
    Character character =new Character((char)97);
    Character character1 =new Character('a');
    System.out.println(character);//a
    System.out.println(character1);//a
}
}

2、Character类的判断功能

package org.westos.character;
/**
 * Character类的判断功能:
 *  public static boolean isLowerCase(char ch)确定指定字符是否为小写字母。
 *  public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
 *  public static boolean isDigit(char ch)确定指定字符是否为数字。
 * 
 * 需求:键盘录入一个字符串,统计该字符串中大写字母字符,小写字母字符,数字字符有多少个(不考虑其他字符,使用Character提供的判断功能去完成)
 * @author 小鑫
 *
 */
public class CharacterDemo2 {
  public static void main(String[] args) {

      //public static boolean isLowerCase(char ch)确定指定字符是否为小写字母。
      System.out.println(Character.isLowerCase('a'));//true
      System.out.println(Character.isLowerCase('A'));//false
      System.out.println(Character.isLowerCase('0'));//false
      System.out.println("------------------------");
      //public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
      System.out.println(Character.isUpperCase('a'));//false
      System.out.println(Character.isUpperCase('A'));//true
      System.out.println(Character.isUpperCase('0'));//false
      System.out.println("------------------------");
      //    public static boolean isDigit(char ch)确定指定字符是否为数字。
      System.out.println(Character.isDigit('a'));//fasle
      System.out.println(Character.isDigit('A'));//fasle
      System.out.println(Character.isDigit('0'));//true
}
}

3、Character常用的转换功能

package org.westos.character;
/**
 * Character常用的转换功能:
 *      public static char toUpperCase(char ch):将指定字符转换成大写
 *      public static char toLowerCase(char ch):将指定字符转换成小写
 *  
 * @author 小鑫
 *
 */
public class CharacterDemo3 {
   public static void main(String[] args) {

    //public static char toUpperCase(char ch):将指定字符转换成大写
     System.out.println(Character.toUpperCase('a'));//A
    //public static char toLowerCase(char ch):将指定字符转换成小写
     System.out.println(Character.toLowerCase('A'));//a
}
}

4、统计字符串中大小写字母和数字的个数

package org.westos.character;
import java.util.Scanner;
/**
 * 需求:键盘录入一个字符串,统计该字符串中大写字母字符,小写字母字符,数字字符有多少个(不考虑其他字符,使用Character提供的判断功能去完成)
 *  分析:
 *      1)定义三个统计变量
 *          bigCount 
 *          smallCount
     *      numberCount
     * 2)创建键盘录入对象,录入并接收一个字符串
     * 3)将字符串转换成字符数组
     * 4)遍历字符数组,获取到每一个字符
     * 5)使用Character类中的判断功能判断是否是大写,小写,数字字符
     * 6)输出
 * @author 小鑫
 *
 */
public class ChanacterTest {
  public static void main(String[] args) {
      //定义三个统计变量
      int bigCount=0;
      int smallCount=0;
      int numberCount=0;
      //创建键盘录入
    Scanner sc=new Scanner(System.in);
      //录入并接收
    System.out.println("请您输入一个字符串");
    String line=sc.nextLine();
    //将字符串转换成字符数组
    char[] chs=line.toCharArray();
    for(int i=0;i<line.length();i++){
        char ch=chs[i];
        if(Character.isUpperCase(ch)){
            bigCount++;
        }else if(Character.isLowerCase(ch)){
            smallCount++;
        }else if(Character.isDigit(ch)){
            numberCount++;
        }
    }
    System.out.println("大写字母字符有："+bigCount+"个");
    System.out.println("小写字母字符有："+smallCount+"个");
    System.out.println("数字字符有："+numberCount+"个");
}
}

5、冒泡排序的思想
两两比较，大的往后放，第一次比较完之后，最大值出现在最大索引处。依次比较

package org.westos.array;
/**
 * 冒泡排序的思想:
 *          两两比较,大的往后放,第一次比完,最大值出现在最大索引处,依次进行这样的比较....
 * @author 小鑫
 *
 */
public class ArrayDemo {
   public static void main(String[] args) {
    //定义一个数组，静态初始化
       int[] arr={24,8,13,23,1,41,80};
       System.out.println("遍历：");
       printArray(arr);
       bubbleSort(arr);
       printArray(arr);
}
   public static void printArray(int[] arr){
       System.out.print("[");
       //遍历数组
       for(int i=0;i<arr.length;i++){
           if(i==arr.length-1){
               System.out.println(arr[i]+"]");
           }else{
               System.out.print(arr[i]+", ");
           }
       }
   }
   public static void bubbleSort(int[] arr){
       for(int i=0;i<arr.length-1;i++){
           for(int j=0;j<arr.length-1-i;j++){
              if(arr[j]>arr[j+1]){
                  int temp=arr[j];
                   arr[j]=arr[j+1];
                   arr[j+1]=temp;
              }
           }
       }
       System.out.println("冒泡排序后:");

   }
}