package com.pb.string.demo1;public class Demo1 {    public static void main(String[] args) {        /*         * s1一个字符串类类型变量，abc是一个对象         * 一旦被初始化，就不可以被改变         */        String str1="abc";         /*         * new 就是在堆内存中再开辟一个新的空间         * s1只有一个对象abc         * s2有2个对象abc和new String("abc");         */        String str2=new String("abc");                System.out.println(str1==str2);//false ==比较内存地址        /*         * String 类重写了Object中的equals方法，用来比较字符串内容是否相同         */        System.out.println(str1.equals(str2));//true 比较地址中的值            }}

package com.pb.string.demo1;public class StringDemo1 {    public static void main(String[] args) {        String str="abcdefghijklmnab"; //长度16        //长度        sop(str.length());        //根据索引获取字符        sop(str.charAt(5));        //sop(str.charAt(33));//下标越界        //根据字符获取索引        sop(str.indexOf('b')); //从0开始查找        //从指字位置开始        sop(str.indexOf('b',5));//从索引为5的字符形开始查找        //查找没的字符        sop(str.indexOf('v',5));//-1 如果没有找到返回-1        //从后向前查找        sop(str.lastIndexOf('b'));        sop(str.lastIndexOf("b"));        //    }    public static void sop(Object obj){        System.out.println(obj);    }}

package com.pb.string.demo1;public class StringDemo2 {    public static void main(String[] args) {        String str="ArrayDemo.java";        sop(str.startsWith("Array")); //判断是否以Array开头 true        sop(str.endsWith(".java"));//判断是否以.java结尾 true        sop(str.contains("Demo"));//判断是否有(包含)Demo子串 true        sop(str.equals("ArrayDemo.java"));//判断字符串内容是否相同 true        sop(str.equalsIgnoreCase("ArrayDemo.java"));//判断字符串内容是否相同并忽略大小字书 true    }    public static void sop(Object obj){        System.out.println(obj);    }}

package com.pb.string.demo1;public class StringDemo3 {    public static void main(String[] args) {        char [] ch={'a','b','c','d','e','f','g'};        //将字符数组转换成字符串        String str1=new String(ch);        sop(str1);        String str2=new String(ch,1,4);//第下标为1开始转换4个字符s        sop(str2);        //静态方法        String str3=String.copyValueOf(ch);        sop(str3);        String str4=String.copyValueOf(ch,1,5);        sop(str4);        String str5=String.valueOf(ch);        sop(str5);        String str6=String.valueOf(ch,1,4);        sop(str6);    }    public static void sop(Object obj){        System.out.println(obj);    }}

package com.pb.string.demo1;public class StringDemo4 {    public static void main(String[] args) {        String str="abcdefg";        //将字符串转换为字符数组        char [] ch=str.toCharArray();        //遍历        for (int i = 0; i < ch.length; i++) {            System.out.print(ch[i]+",");        }        //将字符串转换为字节数组        byte [] b=str.getBytes();        for (int i = 0; i < b.length; i++) {            System.out.print((char)b[i]);        }    }    }

package com.pb.string.demo1;public class StringDemo5 {    public static void main(String[] args) {        int i=3; //可以是double,float,short,long,char,byte        String str1=i+"";        String str2=String.valueOf(i);        }}

package com.pb.string.demo1;import java.util.Arrays;public class SplitString {    public static void main(String[] args) {        String str1="zhangsa,lisi,wangwu,zhaoliu";        String[] arr=str1.split(",");        System.out.println(Arrays.toString(arr));    }}

package com.pb.string.demo1;public class ReplaceDemo {    public static void main(String[] args) {        String str1="Hello,Java!";        String str2=str1.replace('a', 'n');        String str3=str1.replace('q', 'n');//如果替换的不在,返回的还是原来的        String str4=str1.replace("Java", "World");        System.out.println(str1);        System.out.println(str2);        System.out.println(str3);        System.out.println(str4);    }}

package com.pb.string.demo1;public class SubStringDemo6 {    public static void main(String[] args) {    String s="abcdef";    System.out.println(s.substring(2));//cdef,从第二开始到结尾    System.out.println(s.substring(2, 4));//cd 从第二个到第4个但不包含第4个    System.out.println(s.substring(0,s.length())); //获取全部    System.out.println(s.substring(0));    }}

package com.pb.string.demo1;public class StringDemo6 {    public static void main(String[] args) {        String s="           Hello Java!           ";        //转换为小写        System.out.println(s.toLowerCase());        //转换为大写        System.out.println(s.toUpperCase());        //去除2边的空格        System.out.println(s.trim());    }}

           hello java!                      HELLO JAVA!           Hello Java!

package com.pb.string.demo2;/** * 模拟一个trim方法，去除字符串2边的空格 * @author Denny * 判断字符串开始第一个位置是不是空格，是断续直到不是空格 为步 * 结尾处判断空格一样 * 当开始和结尾都不是空格时，就是要获取的字符串 *  *  */public class StringDemo1 {    public static void main(String[] args) {        String str="           Hello Java!            ";        sop(str);//去空格前        str=myTrim(str);        sop(str);//去空格后    }    public static String myTrim(String str){        int start=0,end=str.length()-1;        //开始的空格        while(start<=end&&str.charAt(start)==' '){            start++;        }        //结尾的空格        while(start<=end&&str.charAt(end)==' '){            end--;        }        return str.substring(start,end+1);//截取            }        public static void sop(Object obj){        System.out.println(obj);    }}

           Hello Java!            Hello Java!

package com.pb.string.demo2;/** * 将一个字符串返转 * @author denny *思路： *可以将字符串变成数组，对数组反转 *将反转后的数组，转换成字符串 *只要将或者反转的部分的开始和结束位置作为参数传递即可 */public class StringDemo2 {    public static void main(String[] args) {                String str="abcdef";        sop(str);        str=reverseString(str,1,5);        System.out.println(str);    }    //从某个位置开始反转到某个位置结束    public static String reverseString(String s,int start,int end){        char [] ch=s.toCharArray();        reverse(ch,start,end);        return new String(ch);            }    //方法重载，反转全部    public static String reverseString(String s){                return reverseString(s,0,s.length());            }    //反转  参数，开始位到结束位置，但不包含结束位    private  static void reverse(char [] arr,int x,int y){        for(int start=x,end=y-1;start<end;start++,end--){            swap(arr,start,end); //交换值                    }    }    //交换    private static void swap(char [] arr,int start,int end){        char tmp=arr[start];        arr[start]=arr[end];        arr[end]=tmp;    }            public static void sop(Object obj){        System.out.println(obj);    }}

abcdefaedcbf

package com.pb.string.demo2;/** * 获取字符串在另一个字符串中出现的次数 *  * @author Denny 定义一个计数器 获取第一次出现的位置 从第一次出现的位置后，剩余的字符串中继续获取再现的位置 每获取一次就加1 *         当获取不到时计数完成 */public class StringDemo3 {    public static void main(String[] args) {        String s1 = "kkabkkcdkkefkkskk";        String s2 = "kk";                    int count = getCount_2(s1, s2);            System.out.println("count="+count);    }    public static int getCount(String s1, String key) {        int count = 0;        int index=0;//下标                while((index=s1.indexOf(key))!=-1){            sop("index="+index);            sop("s1="+s1);            s1=s1.substring(index+key.length()); //截取字符串，再赋值给字符串            count++;        }        return count;    }    public static int getCount_2(String s1, String key) {        int count = 0;        int index=0;//下标                while((index=s1.indexOf(key,index))!=-1){                    index=index+key.length();            sop("index="+index);            count++;        }        return count;    }    public static void sop(Object obj){        System.out.println(obj);    }}

index=2index=6index=10index=14index=17count=5

package com.pb.string.demo2;/** *  * @author Denny 获取2个字符串最大相同的串， 将短的字符进行一长度递减的子串打印 将知的字符串按照长度弟减的方式获取到 如果包含就找到! */public class StringDemo4 {    public static void main(String[] args) {        String s1 = "abcwerthelloyuiodef";        String s2 = "cvhelloybnm";        sop("最大相同的是:"+getMaxString(s2,s1));    }    public static String getMaxString(String s1, String s2) {        String max = "", min = "";        //判断哪个字符串长        max = (s1.length() > s2.length()) ? s1 : s2;        min=(max==s1)?s2:s1;        //System.out.println("max="+max+",min="+min);        //使用小的字符串做循环        for (int i = 0; i < min.length(); i++) {            //每次都从0开始，从后减少            for(int y=0,z=min.length()-i;z!=min.length()+1;y++,z++){                String temp=min.substring(y,z);                sop(temp);                if(max.contains(temp)){                    return temp;                }            }        }        return "";            }    public static void sop(Object obj){        System.out.println(obj);    }}

cvhelloybnmcvhelloybnvhelloybnmcvhelloybvhelloybnhelloybnmcvhelloyvhelloybhelloybnelloybnmcvhellovhelloyhelloybelloybnlloybnmcvhellvhellohelloy最大相同的是:helloy

package com.pb.stringbuffer.demo1;public class StringBufferDemo1 {    public static void main(String[] args) {        StringBuffer sb=new StringBuffer();        sb.append("abcd").append(123).append("mmmmmmmm");        //插入        sb.insert(2, "qqqqqqqqqqq");        System.out.println(sb);    }}

package com.pb.stringbuffer.demo1;public class StringBufferDemo2 {    public static void main(String[] args) {                getChar();    }    //获取指定字符串，并存放在字符数组中    public static void getChar(){        StringBuffer sb=new StringBuffer("abcdef");        char [] ch=new char[8];        sb.getChars(1, 4, ch, 2);        for (int i = 0; i < ch.length; i++) {            sop("ch["+i+"]="+ch[i]);        }            }        //修改    public static void update(){        StringBuffer sb=new StringBuffer("abcdef");        sb.replace(1, 4, "33333333333");        sop(sb);        //替换一个        sb.setCharAt(1, 'k');        sop(sb);    }        public static void del(){        StringBuffer sb=new StringBuffer("abcdefghi");        sb.delete(1, 3);        sop(sb);        //删除一个                sb.deleteCharAt(sb.indexOf("i"));        sop(sb);        //清空缓冲区        sb.delete(0, sb.length());        sop(sb);    }    //添加，插入    public static void add_insert(){        StringBuffer sb=new StringBuffer();        sb.append("abcd").append(123).append("mmmmmmmm");        //插入        sb.insert(2, "qqqqqqqqqqq");        System.out.println(sb);    }        public static void sop(Object obj){        System.out.println(obj);    }}

package com.pb.demo.packclass.demo1;public class Interger {    public static void main(String[] args) {        Integer max=Integer.MAX_VALUE;//最大值        Integer min=Integer.MIN_VALUE;//最小值        System.out.println("max="+max);        System.out.println("min="+min);    }}

package com.pb.demo.packclass.demo1;/** * 转换为字符串 * @author Denny * */public class Demo1 {    public static void main(String[] args) {                double d=33.4;        String s1=d+"";        String s2=Double.toString(d);        String s3=String.valueOf(d);                            }}

package com.pb.demo.packclass.demo1;public class Demo2 {    public static void main(String[] args) {        String s1="32";        int i=Integer.parseInt(s1);//转换为int类型        String s2="22.4";        double d=Double.parseDouble(s2);//转换为double        String s3="11.3";        float f=Float.parseFloat(s3);//转换为float类型        long l=Long.parseLong("88888888");        boolean b=Boolean.parseBoolean("true");//或者false        Integer x=new Integer(33);        int num=x.intValue(); //动态方法 转换为基本数据类型    }}

package com.pb.demo.packclass.demo1;public class Demo3 {    public static void main(String[] args) {        //转换为二进制        System.out.println(Integer.toBinaryString(10));        //八进制        System.out.println(Integer.toOctalString(10));        //十六进制        System.out.println(Integer.toHexString(10));        //转换为2进制        System.out.println(Integer.parseInt("110", 2));        //转换为8进制        System.out.println(Integer.parseInt("17", 8));        //转换为16进制        System.out.println(Integer.parseInt("af", 16));    }}

101012a615175

package com.pb.demo.packclass.demo1;public class Demo4 {    public static void main(String[] args) {                Integer x=4;// 自动装箱，==new Integer(4)，        x=x+2;//自对拆箱 x.intValue()转换为int类型，+2运算，再进行自动装箱    }        public static void sop(Object obj){            System.out.println(obj);        }}

package com.pb.demo.packclass.demo1;public class Demo5 {    public static void main(String[] args) {        Integer i=128;        Integer j=128;        sop("i==j: "+(i==j));//false                /*         * 如果指向同一个Integr对象         * 当数值在byte范围内里-128-127之间         * 1.5后的新特性         * 如果该值已经存在，就不会开辟新的空间         */                        Integer x=127;        Integer y=127;        sop("x==y:"+(x==y));//true    }    public static void sop(Object obj){        System.out.println(obj);    }}

package com.pb.demo.packclass.demo1;public class Demo6 {    public static void main(String[] args) {        Integer x=3;        Integer y=8;        sop(x.compareTo(y)); //-1 小于        sop(Integer.compare(y, x));//大于1        sop(Integer.compare(5, 5));//等于 0            }    public static void sop(Object obj){        System.out.println(obj);    }}