常用类:Object,String,StringBuffer,Charcter,Integer-CSDN博客

一，Object

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

    public static void main(String[] args) {

        //创建学生对象
        Student s1 = new Student() ;
        System.out.println(s1.hashCode());//1460821906

        Student s2 = new Student()  ;
        System.out.println(s2.hashCode());//2045891656

        Student s3 = new Student() ;
        System.out.println(s3.hashCode());


//      System.out.println("hello".hashCode()) ;

//      public final Class getClass()返回此 Object 的运行时类
        Class c1 = s1.getClass() ;
//      System.out.println("c1:"+c1);//class org.westos.object_01.Student
        //public String getName():获取当前正在运行的这类的全路径名称!
        String name = c1.getName() ;
        System.out.println("name:"+name);//org.westos.object_01.Student :全路径名称
                                        //org.westos.object_01.Student
    }
}

直接输出一个类的对象，输出的是：这个对象的所在的包名+类名+@+哈希码值
public String toString() {
return this.getClass().getName() + “@” + Integer.toHexString(this.hashCode());
}
要想通过直接输出一个对象而输出这个对象的内容，必须重写这个类从object继承而来的to String()方法

package object;

//学生类
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;
    }
    //当前toString()是自己去写的
/*  @Override
    public String toString() {
        return name+"---"+age;
    }*/

    //alt+shift+s->s
    //自动生成即可!
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }   
}

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

    public static void main(String[] args) {
        //创建一个学生对象
        Student s1 = new Student("高圆圆",27) ;

        //直接输出对象名称
        /*System.out.println("s1:"+s1);//org.westos.object_02.Student@7439aca7
        //public String toString()
        System.out.println("toString():"+s1.toString());//org.westos.object_02.Student@7439aca7
        System.out.println("--------------------------");*/

        /**
         * 通过查看toString()源码:
         *  public String toString() {
                return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
            }

            toString()<==> 对象名.getClass().getName() +"@" +Integer.toHexString(对象名.hashCode())
         */
        System.out.println(s1.getClass().getName()+"@"+Integer.toHexString(s1.hashCode()));
//      System.out.println(s1.toString());
        //org.westos.object_02.Student@28169674
        //org.westos.object_02.Student@28169674

        //直接对象名称,想要显示成员变量的值,怎么办?
//      System.out.println(s1);
        Student s2 = new Student("高圆圆", 27) ;
        System.out.println("s2:"+s2);

        System.out.println(s1==s2); 
    }
}

由于Object类中的equals()方法底层是通过”==”来实现的,所以默认比较的是地址值,如果想比较内容是否相同,需要重写equals()方法
面试题:
* ==和equal()方法的区别
* ==:比较的是两个对象的地址值是否相同,
* equals()方法默认比较的是两个对象的地址值是否相同,如果重写了Object类中的equals()方法,那么默认比较就是两个对象的内容是否相同（String类已经对equals()方法进行了重写，所以要比较String的内容是否相同，最好用equals()方法进行比较）

package org.westos.object_03;

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 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;
    }

    //toString()
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
    //重写了Object类中的equals()方法
    @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;
    }
    /**
     * 对象名  instanceof 类:判断该对象是否是该类的一个实例
     * */   
}

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

    public static void main(String[] args) {

        //创建学生对象
        Student s1 = new Student("高圆圆", 27) ;
        Student s2 = new Student("高圆圆",27) ;
        System.out.println(s1==s2);
        System.out.println("------------------");
        Student s3 = s1 ;
        System.out.println(s1==s3);
        System.out.println("-------------------");
        System.out.println(s1.equals(s2));//由于重写Object中的equals()方法,所以比较的是对象的内容是否相同!

        /**
         * equals()方法的源码
         *   public boolean equals(Object obj) {
            return (this == obj);
        }
            由于Object类中的equals()方法底层是通过"=="来实现的,所以默认比较的是地址值,如果想比较内容是否相同,需要重写equals()方法
         * */
    }
}

package org.westos.object_04;
/**
 * Object类中的其他两个方法:
 *      protected void finalize()throws Throwable:当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法,但是,什么时候调用垃圾回收器
 * 不确定;
 *  
 *      System类中的一个方法:
 *          public void gc():运行垃圾回收器,这个垃圾回收器最终调用的就是finalize()方法
 *      
 *protected Object clone()创建并返回此对象的一个副本
                throws CloneNotSupportedException

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

    public static void main(String[] args) throws CloneNotSupportedException {//该异常是编译时期异常
        //创建s1这个学生对象
        Student s1 = new Student() ;
        s1.setName("高圆圆") ;
        s1.setAge(27) ;

        System.out.println(s1.getName()+"---"+s1.getAge());

        //复制s1这个对象
        Object obj = s1.clone() ;
        //向下转型:
        Student s2 = (Student) obj;
        System.out.println(s2.getName()+"---"+s1.getAge());
        System.out.println("----------------------");

        //没有讲clone方法之前:
        Student s3 = s1; //把s1地址值赋值s3对象,s3指向s1的堆内存中的地址值
        System.out.println(s3.getName()+"---"+s3.getAge());
    }
}

package org.westos.object_04;

//学生类
//要去使用clone()方法,当前对象所在的类一定要实现cloneable接口,
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;
    }
    //重写Object类中clone()
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

二, String

字符串变量相加,先开辟空间,在相加
字符串常量相加:首先在字符串常量池找,有没有当前这个常量值,有,就直接返回,没有,需要创建!
面试题:
String s = “hello”
和String s = new String(“hello”) 两个有什么区别?分别创建了几个对象
- 第一个创建了一个对象
第二个s创建两个对象(堆内存中有new String(),然后字符串常量池中也有这样一个字符串常量(开辟空间的地址))
String s1=”hello”;
s1+=”world”;
- s3=new String(“helloworld”);

内存图解：

这里写图片描述

面试题二：
注意区分string.length()和array.length

编码和解码:一定要保证编码格式一致
编码:
把能看懂的东西转换成一个看不懂的东西:String—–>byte[]:public byte[] getBytes(String charsetName)
String s = “你好” ;
// byte[] bys2 = s.getBytes(“utf-8”) ;//编码:以:GBK格式编码 utf-8:一个中文:对应三个字节
byte[] bys2 = s.getBytes() ;
// System.out.println(bys2);
//Arrays:数组工具类:toString(byte[] bys)
System.out.println(Arrays.toString(bys2));
解码:
把当前的byte[]转成能看懂的东西(String):byte[]—–>String :public String(byte[] bytes,CharsetName ch)
System.out.println(“——-“);
// String str = new String(bys2, “utf-8”) ;
String str = new String(bys2) ;
System.out.println(“str:”+str);
将字符数组构造成一个字符串
//public String(char[] value):
//定义一个字符数组
char[] chs = {‘我’,’爱’,’高’,’圆’,’圆’} ;
String s3 = new String(chs) ;

/**
 * 看程序写结果:
 * @author Apple
 */
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

        String s3 = "hello" ;
        String s4 = "hello" ;
        System.out.println(s3==s4);
        System.out.println(s3.equals(s4));

        String s5 = new String("world") ;
        String s6 = "world" ;
        System.out.println(s5==s6);
        System.out.println(s5.equals(s6));
    }
}

String类中的其他功能:
* 替换功能:
* public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换
* public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新的字符串去替代
* 去除字符串两端空格:
* public String trim()
* 两个字符串进行比较:
* public int compareTo(String anotherString) 是Comparable接口中的方法(该接口可以实现一个自然排序)
* Comparator接口可以比较器排序

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()拼接:字符串拼接方法
 * */
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) ;

            //将得到s1字符串转换成小写
            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:"+result);
            System.out.println("------------------------------");

            //链式编程
            String result2 = line.substring(0, 1).toLowerCase().concat(line.substring(1).toUpperCase()) ;
            System.out.println("result2:"+result);
        }
}

package org.westos.string_01;

import java.util.Scanner;

/**
 * 需求:键盘录入一个字符串,将字符串进行反转
 * 
 * 举例:
 *      "abc"--->"cba"
 * 
 * 分析:
 *      1)创建键盘录入对象,录入并接收一个字符串
 *      2)定义空字符串
 *      3)可以将字符串转换成字符数组:toCharArray();
 *      4)遍历字符数组,倒着遍历
 *      5)遍历之后获取到字符串中的每一个字符,然后使用空串进行拼接
 *      6)输出即可!
 * @author Apple
 */
public class StringTest3 {

    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 x = chs.length-1; x >=0 ; x --){
            //获取到每一个字符
            result+= chs[x] ;
        }*/

        String result = myReverse(line) ;

        //输出
        System.out.println("result:"+result);
    }

    //写一个功能实现
    public static String myReverse(String s){
        //定义空字符串
        String result = "" ;

        //将字符串字符数组
        char[] chs = s.toCharArray() ;

        //遍历字符数组
        for(int x = chs.length -1 ; x >=0; x --){
            //拼接每一个字符
            result+= chs[x];
        }

        return result ;
    }
}

==与equals()的小练习：

看程序写结果
public class StringDemo {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        String s3 = "helloworld";
        System.out.println(s3 == s1 + s2);
        System.out.println(s3.equals((s1 + s2)));

        System.out.println(s3 == "hello" + "world");
        System.out.println(s3.equals("hello" + "world"));

    }
}

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

*
* 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_04;
/**
 * 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索引)

 * @author Apple
 */
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
    }
}

三，StringBuffer

package 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 Apple
 */
public class StringBufferDemo {

    public static void main(String[] args) {
//      StringBuffer sb = "hello" ;
//      String s = "hello" ;
//      StringBuffer sb = s ;

//      public StringBuffer ()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
        //创建一个字符串缓冲区对象
        StringBuffer sb = new StringBuffer() ;
        System.out.println("sb.length:"+sb.length());//0
        System.out.println("sb.capacity:"+sb.capacity());//16

        System.out.println("----------------------------");

        //  public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区
        StringBuffer sb2 = new StringBuffer(50) ;
        System.out.println("sb2.length:"+sb2.length());//0
        System.out.println("sb2.capacity:"+sb2.capacity());//50

        System.out.println("----------------------------");

        StringBuffer sb3 = new StringBuffer("hello") ;
        System.out.println("sb3.length:"+sb3.length());//5
        System.out.println("sb3.capacity:"+sb3.capacity());//默认:初始容量16 + 当前字符串长度//21    
    }
}

package org.westos.stringbuffer_02;
/**
* StringBuffer中的和添加有关的方法
* public StringBuffer append(int/String/char/boolean/double/float….):当前这个方法追加,给缓冲中追加数据,返回字符串缓冲区本身(经常使用的)
* public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身
* @author Apple
*/
public class StringBufferDemo2 {

public static void main(String[] args) {

    //创建一个字符串缓冲区对象
    StringBuffer sb = new StringBuffer() ;

    //追加数据
/*  sb.append("hello") ;
    sb.append(true) ;
    sb.append(13.45) ;
    sb.append('A') ;
    sb.append(12.56F);*/

    //链式编程
    sb.append("hello").append(true).append(13.45).append('A').append(12.56F);

    //public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身

    sb.insert(5, "world") ;
    //输出
    System.out.println("sb:"+sb);
}

}

package org.westos.stringbuffer_02;
/**
* StringBuffer的删除功能:
* public StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回的是字符串缓冲区本身!
* public StringBuffer delete(int start,int end):删除从指定位置开始到指定位置结束的字符,返回的是字符串缓冲区本身!
* @author Apple
*/
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)
    //需求:要删除当前缓冲区中'e'这个字符

// sb.deleteCharAt(1) ;
//需求:要删除当前缓冲区中第一个’l’这个字符
// sb.deleteCharAt(1) ;

// public StringBuffer delete(int start,int end)
// sb.delete(5, 9) ;
//从0索引开始,当前缓冲的字符串全部删除掉
sb.delete(0, sb.length()) ;

    //输出
    System.out.println("sb:"+sb);
}

}

package org.westos.stringbuffer_02;

import java.util.Scanner;

/**
* StringBuffer的反转功能:
* public StringBuffer reverse():将此字符串中的字符序列直接反转
* @author Apple
*/
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) ;
    //public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String
    //反转功能
     String result = sb.reverse().toString() ;
     System.out.println("result:"+result);


}

}

package org.westos.stringbuffer_02;
/**
* StringBuffer的替换功能:
* public StringBuffer replace(int start, int end,String str)
* 从指定位置开始到指定位置结束的字符用str子字符串去替代
* @author Apple
*/
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:"+sb);
}

}

package org.westos.stringbuffer_02;
/**
* StringBuffer的截取功能:
* public String substring(int start):从指定位置默认截取到末尾,返回值是一个新的字符串
* public String substring(int start,int end):从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串
* @author Apple
*/
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:”+s1);

    //public String substring(int start,int end)
    String s2 = sb.substring(5,10) ;
    System.out.println("s2:"+s2);
    System.out.println("sb:"+sb);
}

}

package org.westos.stringbuffer_02;
/**
* 面试题:
* String,StringBuffer,StringBuilder的区别?
*
* String:一个不可变的字符序列,StringBuffer:和StringBuilder是可变的字符序列,在单个线程时候的时候(优先采用StringBuilder)
* 从线程角度考虑:
* StringBuilder线程不安全,不同步,执行效率高!它比StringBuffer要快!
*
* String和StringBuffer作为形式参数
*
* String类型作为形式参数和基本数据类型作为形式参数的效果一样!
*
* @author Apple
*/
public class StringBufferDemo7 {

public static void main(String[] args) {

    //定义两个字符串
    String s1 = "hello" ;
    String s2 = "world" ;
    System.out.println(s1+"---"+s2);
    change(s1,s2) ;
    System.out.println(s1+"---"+s2);

    //定义两个字符串缓冲区对象
    StringBuffer sb1 = new StringBuffer("hello") ;
    StringBuffer sb2 = new StringBuffer("world") ;
    System.out.println(sb1+"---"+sb2);//hello---world
    change(sb1,sb2);
    System.out.println(sb1+"---"+sb2);//hello---worldworld
    //缓冲区是不变
}

public static void change(StringBuffer sb1 ,StringBuffer sb2){
    sb1 = sb2 ;  //缓冲区不变"world"
    sb2.append(sb1) ;//worldworld
}

public static void change(String s1,String s2){
    s1 = s2 ;
    s2 = s1 + s2 ;
}

}

package org.westos.stringbuffer_02;
/**
*
* 类与类之间的转换
* A类型—>B类型
* 这里面可能最终使用B类型里面的功能
* B类型—>A类型
* 有时候需要的不是B类型,所以又要将B类型–>A类型
*
* StringBuffer—>String之间的相互转换
*
* 面试题:
* StringBuffer和数组的区别?
*
* 两个共同特点:都属于容器类型的变量
* 数组:只能存储同一种数据类型的元素,数组的长度是固定的
* int[] arr = {10,20,40,50,”hello”} 错误的
* StringBuffer:字符串缓冲区,可以存储任意类型的元素,可以不断的去给缓冲区中追加(append),字符串缓冲区中:在内存始终返回的字符串
*
* @author Apple
*/
public class StringBufferTest {

public static void main(String[] args) {
    //String--->StringBuffer
    //定义一个字符串
    String s = "hello" ;

    /*StringBuffer sb = "hello" ;
    StringBuffer sb = s ;*/
    //方式1)使用StringBuffer的构造方式:StringBuffer(String str)
    //创建一个字符串缓冲区并指向这个字符串
    StringBuffer sb = new StringBuffer(s) ;
    System.out.println("sb:"+sb);

    //方式2)创建字符串缓冲区对象,使用无参构造StringBuffer(),利用append()
    StringBuffer sb2 = new StringBuffer() ;
    sb2.append(s) ;
    System.out.println("sb2:"+sb2);

    System.out.println("--------------------");

    //StringBuffer--->String
    //有一个字符串缓冲区对象
    StringBuffer buffer = new StringBuffer("world") ;
    //1)方式1String的另一种构造方法:String(StringBuffer buffer)
    String s2 = new String(buffer) ;
    System.out.println("s2:"+s2);
    //2)方式2:/public String toString():现在的数据类型StirngBuffer类型,需要将StringBuffer类型转换String
    String s3 = buffer.toString() ;
    System.out.println("s3:"+s3);
}

}

package org.westos.stringbuffer_02;
/**
* 将数组拼接成一个字符串,分别使用String和StringBuffer实现(定义功能方法)
*
* int[] arr = {11,55,33 ,44 ,22} ;
* 形成这样一个字符串:[11, 55, 33, 44, 22]
* 分析:
* 1)存在一个数组,静态初始化
* 2)分别使用String和StringBuffer类型去完成
*
* @author Apple
*/
public class StringBufferTest2 {

public static void main(String[] args) {
    //定义一个数组,静态初始化!
    int[] arr = {11,55,33,44,22} ;

    //方式1)使用String类型实现
    String result = arrayToString(arr) ;
    System.out.println("result:"+result);

    System.out.println("------------------------");
    //方式2:使用StringBuffer的append功能
    String result2 = arrayToString2(arr) ;
    System.out.println("result2: " + result2);
}

public static String arrayToString2(int[] arr){
    //1)创建字符串缓冲区对象
    StringBuffer sb = new StringBuffer() ;
    //sb对象追加左中括号
    sb.append("[") ;
    //遍历数组
    for(int x = 0 ; x < arr.length ; x ++){
        //判断是否是最大索引
        if(x==arr.length-1){
            //append追加
            sb.append(arr[x]);
        }else{
            sb.append(arr[x]).append(", ") ;
        }
    }

    sb.append("]") ;

    return sb.toString() ; //将StringBuffer--->String
}

/**
 * 明确返回值类型:String
 * 明确参数类型:int[] arr
 */
public static String arrayToString(int[] arr){

    //定义一个空字符串
    String result = "" ;

    //拼接左中括号
    result +="[" ;

    //遍历int数组
    for(int x = 0 ; x < arr.length ; x ++){
        //判断是否最大索引
        if(x==arr.length-1){
            //拼接元素以及"]"
            result += arr[x] ;
            result += "]" ;
        }else{
            result += arr[x] ;
            result += ", " ;
        }
    }
    return result ;
}

}

package org.westos.stringbuffer_02;

import java.util.Scanner;

/**
* 分别使用String和StringBuffer实现字符串的反转
* @author Apple
*/
public class StringBufferTest3 {

public static void main(String[] args) {

    //创建键盘录入对象
    Scanner sc = new Scanner(System.in) ;

    //录入并接收
    System.out.println("请您输入一个字符串:");
    String str = sc.nextLine() ;

    //方式1:使用String类型进行拼接
    String result = myReverse(str) ;
    System.out.println("result:"+result);
    //方式2:使用StringBuffer的reverse()功能

    String result2 = myReverse2(str) ;
    System.out.println("result2:"+result2);
}

//StringBuffer的rever()方法实现
public static String myReverse2(String s){
    //创建字符串缓冲区对象h
    /*StringBuffer sb = new StringBuffer(s) ;
    //开始调用反转功能
    sb.reverse() ;
    //返回
    return sb.toString() ;*/

    //一步完成:
    return new StringBuffer(s).reverse().toString() ;
}


//String类型的方式进行反转
public static String myReverse(String s){
    //定义空串
    String result = "" ;

    //可以字符组其转成字符数组
    char[] chs = s.toCharArray() ;

    //倒着遍历
    for(int x = chs.length-1 ; x >=0 ; x --){
        //空串进行拼接
        result += chs[x] ;
    }

    return result ;
}

}

package org.westos.stringbuffer_02;

import java.util.Scanner;

/**
* 1判断一个字符串是否是对称字符串

例如”abc”不是对称字符串，”aba”、”abba”、”aaa”、”mnanm”是对称字符串
使用(String和StringBuffer实现这个功能)

分析:
        用第一个字符和倒数第一个字符相比较
        用二个字符和倒数第二个字符进行比较
        ...

* @author Apple
*/
public class StringBufferTest4 {

public static void main(String[] args) {

    //创建键盘录入对象
    Scanner sc = new Scanner(System.in) ;

    //录入并接收数据
    System.out.println("请您输入一个字符串:");
    String line = sc.nextLine() ;

    //方式1:String类型的转换功能
    boolean flag = isSame(line) ;
    System.out.println("flag:"+flag);

    //方式2:间接的使用StringBuffer的reverse()功能
    boolean flag2 = isSame2(line) ;
    System.out.println("flag2:"+flag2);
}

public static boolean isSame2(String s){
    //直接一步
    //new StringBuffer(s).reverse().toString()--->StirngBuffer--->String
    return new StringBuffer(s).reverse().toString().equals(s) ;
}

/**
 * 两个明确:
 *      返回值类型:boolean
 *      参数类型:String s
 */
/*public static boolean isSame(String s){

    //将字符串转换成字符数组
    char[] chs = s.toCharArray() ;

    for(int start = 0,end = chs.length -1 ; start<=end;start++,end--){
        //判断
        if(chs[start] != chs[end]){
            return false ;
        }

    }
    return true ;
}*/

public static boolean isSame(String s){
    //定义一个标记:假设返回值是true
    boolean flag = true ;

    //需要字符串转换成字符数组
    char[] chs = s.toCharArray();
    //遍历字符数组,获取前面索引对应的字符和后面索引的字符
    for(int start = 0 ,end = chs.length -1 ; start<=end ; start++,end--){
        //判断
        if(chs[start]!= chs[end]){
            //修改标记
            flag = false ;
            break ;
        }
    }
    return flag ;
}

}

四，Character

Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段
* 构造方法:
* public Character(char value)构造一个新分配的 Character 对象，用以表示指定的 char 值。

package character_flower;
import java.util.Scanner;

/**
 * /**
 * Character类的判断功能:
 *  public static boolean isLowerCase(char ch)确定指定字符是否为小写字母。
 *  public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
 *  public static boolean isDigit(char ch)确定指定字符是否为数字。
 * 
 * Character常用的转换功能:
 *      public static char toUpperCase(char ch):将指定字符转换成大写
 *      public static char toLowerCase(char ch):将指定字符转换成小写
 *  
 * 需求:键盘录入一个字符串,统计该字符串中大写字母字符,小写字母字符,数字字符有多少个(不考虑其他字符,使用Character提供的判断功能去完成)
 * 
 *  分析:
 *      1)定义三个统计变量
 *          bigCount 
 *          smallCount
     *      numberCount
     * 2)创建键盘录入对象,录入并接收一个字符串
     * 3)将字符串转换成字符数组
     * 4)遍历字符数组,获取到每一个字符
     * 5)使用Character类中的判断功能判断是否是大写,小写,数字字符
     * 6)输出
 *      
 * @author Apple
 */
public class CharacterTest {

    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 x = 0 ; x < chs.length ; x ++){
            //获取每一个字符
            char ch = chs[x] ;

            //判断
            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+"个");
    }
}

运行结果：
这里写图片描述

五，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 Apple
 */
public class IntegerDemo {

    public static void main(String[] args) {
        //public static String toBinaryString(int i)
        System.out.println(Integer.toBinaryString(100)) ;

        //public static String toOctalString(int i)
        System.out.println(Integer.toOctalString(100));

        //public static String toHexString(int i)
        System.out.println(Integer.toHexString(100));

        //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);//-2147483647
    }
}

我觉得可以吧这种转换添加到计算器中，对于学计算机的人还是挺有用的。

/**
 * Integer类的构造方式:
 *  public Integer(int value):将一个int类型的数据封装成一个引用类型
 *  public Integer(String s):将一个字符数类型封装成一个Integer类型
 *          注意事项:
 *              该字符串必须是数字字符串!,否则:java.lang.NumberFormatException
 * @author Apple
 */
public class IntegerDemo2 {

    public static void main(String[] args) {
//      public Integer(int value)
        //创建一个Integer对象
        Integer i = new Integer(100);
//      Integer i = 100 ;//jdk5以后的自动装箱!
        System.out.println("i:"+i);

        //public Integer(String s)
//      String s = "abc" ;
        String s = "20" ;
        Integer ii = new Integer(s) ;
        System.out.println("s:"+s);
    }
}

int类型和String类型的相互转换
例如：

int到String类型的转换

int i=100;
(1)字符串拼接法： String s=“”+100；

(2)利用Integer类的toString方法public String toString()
Integer a=new Interger(i);
s=a.toString();

(3)public static String toString(int i)
s=Integer.toString(i);

(4)public static Integer valueOf(int i)
Integer b= Integer.valueOf(i) ;
String s4 = b.toString() ;

String到int类型的转换

//定义一个字符串:
String s = “10” ;
//方式1:String—>Integer—->int
Integer ii = new Integer(s) ;
//public int intValue()以 int 类型返回该 Integer 的值
int num = ii.intValue() ;
System.out.println(“num:”+num);

/public static int parseInt(String s)
int num2 = Integer.parseInt(s) ;
System.out.println(“num2:”+num2);

其实这么多中方式也记不清，选一种自己觉得好用的就行。
我选的：
int–>String

int i=6;
String s=Integer.toString(i);

String–>int

String s=”123”;
int i=Integer.parseInt(s);
我经常用这一种因为其他数据类型：字符串转换到double float的形式与这很相似
Double.parseDouble(double i)
Float.parseFloat(float i)

//Integer的内存缓存区:IntegerCache
//low = -128
//high=127
Integer i1 = 127 ; //—–>底层在封装的时候:Integer integer = Inteter.valueOf(int i) ;
Integer i2 = 127 ;

/**
 * Jdk5.0以后的新特性:自动拆装箱
 * @author Apple
 */
public class IntegerTest2 {

    public static void main(String[] args) {
        //创建一个Integer对象
        Integer i = new Integer(100) ;
        i += 200 ;
        System.out.println("i:"+i);

        /**
         * 通过反编译工具查看源码:
         *  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());
         */
    }
}