Sting

//java基础视频教程第13天-01-String(概述)
/*
记住:
1.它是一个对象
2.它是一个常量，不能改变
3.
*/
class StringDemo
{
    public static void main(String[] args) 
    {
        String s1 = "abc";                            //s1是一个类类型变量，"abc"其实是一个对象
        //s1 = "dsaflsaf";                            //其实是s1的地址改变了，而"abc"的内容并没有改变，所以字符串一点初始化就不会改变
        String s2 = new String("abc");                
        
            //s1和s2有什么区别:s1是一个对象，s2是两个对象，说明一下，内存中有个常量池，每一个变量都从中会从中抽取a-z等的字符组成一个对象

        System.out.println(s1==s2);
        System.out.println(s1.equals(s2));        //Object中的equal方法是比较地址值，但是String继承过来之后重写了方法，比较的是字符串的内容是否相同
    }
}

//java基础视频教程第13天-02-String(常见功能-获取和判断)
/*
    
    1.查询
        1.1查找字符串长度
        int lengch();
        1.2根据s索引查字符
        char charAt(int index);    //从查找指定位置的字符    
        1.3根据字符查索引或者从指定位置开始查
        int indexOf(int ch)        //z注意：传的值是ASSIC码，也可以传ASSIC对应的数字，所以这里是int
        int indexOf(int ch,int int fromindex);        //重指定的位置fromindex开始查找ch出现的位置,注意，如果查询的ch没有就会返回-1，如果查询位置fromindex超过了角标，会出角标越界错误
        
        int indexOf(String str)                        //indexof不仅可以查询单个字符还可以查找字符串
        int indexOf(String str,int fromindex)        

        反向索引：
        lastIndexOf(int ch);        //从最后面开始查询你要查的字符
        codePointAt(int index);        //返回给定的字符的ASSIC码

    2.判断
        2.1字符串中是否为空
        boolean isEmpty()    //""这是一个对象，null这个是空            //1.6以后才有，其实就是判断字符串长度是否为0
        2.2字符串中是否包含某个字符
        boolea contains(CharSequence s)        //CharSequence是一个接口 
            还有一个也可以判断字符串中是否包含某个字符，
             int indexOf(String str),当返回结果是-1时表示没有，这个既可以判断是否有某个字符，也可以判断某个字符在那个位置
             if(indexOf("aa")!=-1);表示存在aa这个字符

        2.3查看字符串是否以某个字符开始的
        boolean startsWith(String str)
        2.4查看字符串是否以某个字符结束的
        boolean endsWith(String str);
        2.5查看字符串的内容是否一样，复写了Object的方法
        boolean equals(str); 
            忽略大小写
        boolean equalsIgnoreCase(str);
*/
class StringMethodDemo 
{
    private static String str = "ArrayDemo.java";
    public static void GetValue()
    {
        sop(str.length());
        sop(str.charAt(4));
        sop(str.indexOf("a"));
        sop(str.indexOf("a",11));
        sop(str.indexOf("Demo"));
        sop(str.lastIndexOf("a"));
        sop(str.codePointAt(5));
    }
    public static void Search()
    {
        sop(str.isEmpty());
        sop(str.contains("Demo"));
        sop(str.startsWith("Array"));
        sop(str.endsWith(".java"));
    }
    public static void main(String[] args) 
    {
        /*
        String s1 ="abc";
        String s2 = new String("abc");

        String s3 = "abc";
        
        System.out.println(s1==s2);
        System.out.println(s1==s3);            //结果为true，当字符串在常量池中已经定义了，就不会在重新定义了，另一个类类型变量指向它时，其实是相同的字符串，常量池存在于静态区
        */
        GetValue();
        Search();
    }
    public static void sop(Object obj)    //基本数据类型的类型提升，1.5版本之后的一个新特性，装箱。
    {
        System.out.println(obj);
    }
}


 

//java基础视频教程第13天-03-String(常见功能-转换)
/*
3.转换：
    3.1把一个字符串数组或者字节数组字转换为一个字符串
        构造方法
        String(char[] arr)
        String(char[] arr,int offset,int count)    //从数组中第几个位置取多少个字符转换成字符窜

        String(byte[] arr)
        String(byte[] arr,int offset,int count)    //字节数组也是一样的转换的

        静态方法
        static String copyValueOf(char[] arr)
        static String copyValueOf(char[] arr,int offset,int count)
        还有一个相同功能的
        static String valueOf(char[] arr)
        static String valueOf(char[] arr,int offset,int count)
        valueOf()比copyValueOf()多一个功能，它可以将基本数据类型转换为字符串
        static String valueOf(int);        //3+""就相当于String.valueOf(3);
        static String valueOf(double);
    3.2将字符串转换为字符数组或者字节数组
        char[] toCharArray();        //转换成字符串数组
        byte[] getBytes();            //转换成字节数组


    特殊：字符串和字符数组在转换的过程中，是可以指定编码表的？？？？？不懂
*/
class  StringChangeDemo
{
    public static void Change()
    {
        String s = "slfjglalgjlsgla";
        String s1 = "334940"; 
        char[] str= {'a','c','d','d','s','r'};
        byte[] num= {2,3,5,6,9,3,4};
        String s2 = new String(str,2,3);
        String s3 = new String(str);
        sop(s2);
        sop(s3);
        String s4 = new String(num);
        String s5 = new String(num,2,2);
        sop(s4);
        sop(s5);


        sop(String.copyValueOf(str));
        sop(String.copyValueOf(str,2,3));
        //sop(String.copyValueOf(num));        //注意copyValueOf没有转换字节数组的功能
        //sop(String.copyValueOf(num,2,4));    //注意copyValueOf没有转换字节数组的功能

        char[] arr = s.toCharArray();
            for (int x=0;x<arr.length;x++ )
            {
                sop(arr[x]);
            }
        byte[] count = s1.getBytes();
            for (int x=0;x<count.length;x++ )
            {
                sop(count[x]);                    //结果令我很不理解？？？
            }

            sop(String.valueOf(3));
                    
    }
    public static void main(String[] args) 
    {
        Change();
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

//java基础教程第13天-04-String(常见功能-切割和替换)
/*
    4.替换
    String replace(String old,String new);        //可以替换单个字符也可替换字符串
    5.分割
    String[] split(regex);                //按照指点的规则分割字符，返回的是一个字符串数组
    6.获取字符串中的一部分，即获取子串
    String substring(int begin);        //从指点位置取到结尾，如果没有指定位置，就会出现角标越界
    String substring(int begin,int end);    //可以取到头，但是娶不到尾
*/

class StringReplaceDemo
{
    public static void replace()
    {
        String str = "hallojava";
        String s = "StringReplaceDemo.java";
        sop(str.replace("a","e"));        //要注意一点，替换后是一个新字符串，原来的字符串并没有改变
        sop(s.replace("java","txt"));    //因为字符串一旦定义就不会改变
    }
    public static void split()
    {
        String str="张三，李四，王五，马六";
        String[] name =str.split("，");
        for (int x=0;x<name.length;x++ )
        {
            sop(name[x]);
        }
    }
    public static void subString()
    {
        String str = "StringReplaceDemo.java";
        sop(str.substring(0,6));        //从指定位置取出字符。
    }
    public static void main(String[] args) 
    {
        replace();
        split();
        subString();
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

 

//java继承视频教程第13天-05-String(常见功能-比较和去除空格)
/*
7.转换，去除空格，比较
    7.1转换字符串大小写
    String toUpperCase();
    String toLowerCase();
    7.2去除字符串两端的空格
    String trim();
    7.3比较两个字符串的ascall码
    int compareTo(String str);    //相同为0，小于为负数，大于为正数，比较的是每个为指上字符的ascall值大小
*/
class trimDemo
{
    public static void change()
    {
        String str1 = "hsgkkasghk";
        String str2 = "SHKFSKGAGL";
        sop(str1.toUpperCase());
        sop(str2.toLowerCase());
    }
    public static void trim()
    {
        String str = "  fall java   ";
        sop(str.trim());
    }
    public static void compareTo()
    {
        String str1 = "acc";
        String str2 = "aaa";
        sop(str1.compareTo(str2));
    }
    public static void main(String[] args) 
    {
        change();
        trim();
        compareTo();
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

}

 

//java视频教程13天-06-String(字符串练习1)
/*
    自己写一个去掉字符串首尾空格的功能
    思路：
    通过循环查询空字符位置，把指针定位到不是空字符上的位置上，然后通过该位置抽取字符串首尾不是空格的片段
*/
class StringTest1
{
    public  static void main(String[] args)
    {
    String str ="   ddaf  dda d ";
    int start =0;
    int end =str.length()-1;    //为什么要减去1，因为，字符长度和下标差1，如果不减1的话，charAt(length)会角标越界
    if(end>=start)        //确保这是一个有字符的字符串
        {
            while(str.charAt(start)==' ')
            start++;
            while(str.charAt(end)==' ')
            end--;
        }


    System.out.println(str.substring(start,end+1)); //这里加1是因为substring只能取头不能取尾巴，加上就可以把最后那个字符算上
    }
}

 

//java基础视频教程第13天-07-String(字符串练习)
/*
    要求：将一个字符串翻转
    思路：
    1.将字符串变成数组
    2.将数组反转
    3.将数组变成字符串
*/
class StringTest2
{
    static String str = "abcdefg";
    public static String reverseString(String str,int start,int end)        //改变某一段位置上的字符顺序
    {
        char[] arr = str.toCharArray();
        reverse(arr,start,end);
        return new String(arr);
    }
    public static String reverseString(String str)
    {
            return reverseString(str,0,str.length());            //调用复写的方法
    }

    public static void reverse(char[] arr,int x,int y)
    {
        for (int start=x,end = y-1 ; end>start ; start++,end--)            //这里的y-1是考虑到取头不取尾，思考方向在数组角标和数组长度的问题上，如果这里不减的话，调用者那个地方就要减1
        {
            swap(arr,start,end);
        }
    }
    public static void swap(char[] arr,int x,int y)
    {
        char temp =arr[x];
        arr[x] = arr[y];
        arr[y] = temp;
    }
    public static void main(String[] args) 
    {
        System.out.println(reverseString(str,2,6));    //指定位置反转
        System.out.println(reverseString(str));        //整个字符串反转
    }

}

 

//java基础视频教程第13天-08-String(字符串练习)
/*
    获取一个字符串在另一个字符串中出现的次数
    "ddffssaadd ddsssdddsssssddd"
    思路：通过indexof查询并计数
*/
class StringTest3
{
    //方法一:用indexOf(int key)和substring
    public static int getCount(String str,String key)
    {
        int index = 0;
        int count = 0;
        while((index=str.indexOf(key))!=-1)
        {
            sop("str="+str);
            str =str.substring(index+key.length());
            count++;
        }
        return count;    
    }
    //方法二:用indexOf(int key,int fromindex)
    public static int getCount1(String str,String key)
    {
        int index =0;
        int count =0;
        while((index = str.indexOf(key,index))!=-1)
        {
            sop(index);
            index = index+key.length();
            count++;
        }
        return count;
    }
    public static void main(String[] args) 
    {
        String str = "ddffssaadd ddsssdddsssssddd";
        String key= "dd";
        sop(getCount(str,key));
        sop(getCount1(str,key));
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

//java基础视频教程第13天-09-String(字符串练习)
/*
    两个字符串作比较，获取两个字符串相同的最大部分字符串
    思路：通过不断缩小小的那一个字符串得到它的字串，然后查看大字符串中是否包含它的这些字串

    //等待研究???????????????????????????????????????????????????????????????????????????????????????????????????
*/
class StringTest4 
{
    public static String getMaxSubString(String s1,String s2)
    {
        String max,min;
        max = (s1.length()>s2.length())?s1:s2;        //为了提高效率判断一下传进来的字符那个短，那个长
        min = (max==s1)?s2:s1;
        sop(max+"-----------------"+min);
        for (int x=0; x<s2.length(); x++)
        {
            for (int y=0,z=min.length()-x; z!=min.length()+1; y++,z++)            //不懂z!=s2.length()+1????????????????????
            {
                String temp = min.substring(y,z);
                sop(temp);
                if(max.contains(temp))//if(s1.indexOf(temp)!=1)
                    return temp;
            }
        }
        return "";
    }
    public static void main(String[] args) 
    {
        String s1="abcwerthelloyuiodef";
        String s2="cvhellobnm";
        sop(getMaxSubString(s1,s2));
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

//java基础视频教程第13天-10-StringBuffer(常见功能-添加)
/*
    字符串缓冲区
    StringBuffer缓冲区特点就像一个容器，首先明白，StringBuffer是一个写了final关键字的类，并且它有很多构造方法，可以直接传值，也可以不传，其次是它的方法append，insert返回类型也是StringBuffer
    特点：
    1.长度是可以变化的
    2.可以存任意类型数据
    3.最终通过toString方法变成字符串
CURD:creat update read delete
    1.存储：
    StringBuffer append() 将参数添加到已有的数据的结尾处
    StringBuffer isnert(int 插入的位置，要插入的数据)，将数据插入到指点的位置上
*/
class StringBufferDemo
{
    public static void main(String[] args) 
    {
        StringBuffer sb = new StringBuffer();                    //面盆理论
        StringBuffer sb1 = sb.append(88);
        sb.append("abc").append(34).append(true).insert(2,"xxxxx");    //方法调用链
        sop(sb.toString());
        //sop(sb1.toString());        
    }
    public static void sop(String str)
    {
        System.out.println(str);
    }
}

//java基础视频教程13天-11-StringBuffer(常见功能-删除和修改)
/*
删除：
delete(int start,int end)        //删除包含头不包含尾
deleteCharAt(int index)            //删除指点位置上的单个字符
delete(0,sb.length())            //清空缓冲区数据

获取：
获取字符串缓冲区中的字符串的长度
int length();
根据索引获取字符
char charAt(int index)
根据字符查索引
int indexOf(String str)
int indexOf(String str,int fromIndex)
获取子字符串
substring(int start)
substring(int sart,int end)

修改：
StringBuffer replace(int start,int end,String str);            //注意：替换之包含头不包含尾
void setCharAt(int index,char ch);            //修改单个字符                    //注意：无返回值


反转
StringBuffer reverse();            //反转之后任是一个字符串缓冲区

把字符串缓冲区中的指定数据存到指定的数组中
void getChars(int srcBegin,int srcEnd,char[] dst,int dstiBegin)            //说明：srcBegin表示从字符串缓冲区中选择一个开始位置，选择一个srcEnd结束位，char[] det指定的字符数组，desiBegin，重数组的第几位开始存
//还有要注意一点，取字符的时候取头不取尾//由于Stringbuffer中没有toCharArray()方法才有这个方法
*/
class StringBufferDeleteDemo
{
    public static void StringBufferDelete()
    {
        StringBuffer sb = new StringBuffer("abcdef");
        sop(sb.toString());
        //sop(sb.delete(2,4));            //delete删除包含头不包含尾,delete返回的也是StringBuffer字符串缓冲区对象，所以可以直接打印
        //sb.delete(2,3);                //删除一个字符c，相当于deleteCharAt()
        sb.deleteCharAt(2);
        sb.delete(0,sb.length());        //清空缓冲区，字符串缓冲区对象也是有长度方法的，
        sop(sb.toString());            
    }
    public static void StringBufferReplace()
    {
        StringBuffer sb = new StringBuffer("abcdef");
        sb.replace(1,4,"java");                        //只包含头不包含尾部，其实替换的是1-3的bcd
        sb.setCharAt(4,'x');
        sop(sb.toString());
    }
    public static void StringBufferArray()
    {
        StringBuffer sb = new StringBuffer("abcdef");
        char[] ch = new char[8];
        sb.getChars(1,6,ch,2);                    //看见没有我要取f,f是5号，就要设置成6，取头不取尾巴
        for (int x=0;x<ch.length;x++ )
        {
            sop("ch"+"["+x+"}="+ch[x]);
        }

    }
    public static void main(String[] args) 
    {
        StringBufferDelete(); 
        StringBufferReplace();
        StringBufferArray();
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
} 
 

//java基础视频教程第13天-12-(StringBuilder)
/*
JDK1.5之后出现了替换StringBuffer类StringBuilder
不同之处在于，StringBuilder不支持线程同步，提高了效率
而StringBuffer支持线程同步，但是效率低下
所以以后开发用StringBuilder，对于安全同步的的问题，可以自己加锁

JDK的更新升级通过以下三点来判读：
1.提高效率
2.简化代码
3.提高 安全问题 

*/

//java基础视频教程第13天-13-（基本数据类型对象包装类）
/*
    基本数据类型对象包装类
    byte Byte
    short Short
    int Integer        //不同
    long Long 
    double Bouble
    float Float
    char Character        //不同
    boolean Boolean

基本数据类型和字符串类型之间的转换

基本数据类型转换成字符串类型
基本数据类型+""
static toString(int num);

字符串类型转换成基本数据类型
静态方法转换：
    xxx a = Xxx.parsexxx(String str)
    int a = Integer.parseInt("123");
    double b = Double.parseDouble("12.44");

    特殊:
    Boolean.parseBoolean("true/false")

    还有character没有这个方法，
非静态方法转换：
    还有一种方法可以把字符串或者整数作为参数通过构造方法传入创建一个对象
    然后用，然后用intValue把这个对象变成int类的值
    Integer i = new Integer("34342"/234234);
    int num = i.intValue();        //返回int类型的值


进制转换
    static toBinaryString()
    static toHexString()
    static toOctalString()

把其他进制转换成十进制
    其实就是把字符串转换成基本数据类型的那个方法，只不过要加上想对应进制的参数 readix
    static parseInt(String s,int radix)

 

*/
class IntegerDemo
{
    public static void main(String[] args) 
    {
            sop("int max :"+Integer.MAX_VALUE);
            sop(Integer.toString(344235));
            int num = Integer.parseInt("434");        //必须传入数字格式的字符串
            sop(num+4);
            sop(Integer.toBinaryString(6));
            sop(Integer.toHexString(60));
            sop(Integer.toOctalString(8));

            sop(Integer.parseInt("3c",16));
            sop(Integer.parseInt("10",8));
            sop(Integer.parseInt("1010",2));    //第二个数代表进制数
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

//java基础视频教程第13天-14-（基本数据类型对象包装类新特性）
/*JDK1.5版本以后出现的新特性
    自动装箱，自动拆箱
*/
class IntegerDemo1
{
    public static void main(String[] args) 
    {
            Integer c = new Integer("123");
            Integer d = new Integer(123);
            sop("c==d:"+(c==d));        //不等，因为是两个对象
            sop("c.equals(d):"+c.equals(d));        //Integer复写了Object里面的equals方法，比较的是数字是否相同，所以为true
            sop("c.compartTo(d):"+c.compareTo(d));    //比较两个Integer对象中的数字类容是否相同，相同为0.不同为-1

            //JDK1.5之后出现的新特性：自动装箱和自动拆箱

            Integer s = new Integer("3");
            Integer g = 3;        //g是一个引用数据类型，指向的是一个对象，这里3相当于new Integer("3")，是一个对象，这就是新特性，自动装箱
            g = g/*g.intValue(),拆箱原理*/+2;        //    这里的g是一个对象，然后自动拆箱成为int类型，然后与2进行运算，最后把和自动装箱赋给g
            sop("g="+g);

            Integer x = 128;            //对于JDK以后的新特性，超出byte之后的数都会产生新对象
            Integer y = 128;
            sop("x+y:"+(x==y));            //false
            Integer a = 127;            //对于JDK1.5以后的新特性,在byte之内的数不会产生新对象
            Integer b = 127;
            sop("a+b:"+(a==b));            //true
    }
    public static void sop(String str)
    {
        System.out.println(str);
    }
}