package day01;
/**
 * 文档注释只能定义在三个地方:
 * 类，方法，常量
 * 
 * 文档注释是功能注释，用来说明功能作用
 * 在类上使用的目的是说明当前类的设计目的
 * 
 * @author adminitartor
 * @version 1.0
 * @see java.lang.String
 * @since JDK1.0
 *
 */
public class DocApiDemo {
    /**
     * sayHello方法中的问候语
     */
    public static final String INFO = "你好!";
    
    /**
     * 对给定用户添加一个问候语
     * @param name 给定的用户名
     * @return 添加了问候语的字符串
     */
    public String sayHello(String name){
        return "你好!"+name;
    }
}

package day01;
/**
 * 频繁修改字符串带来的性能开销问题
 * @author adminitartor
 *
 */
public class StringDemo2 {
    public static void main(String[] args) {
        String str = "a";
        for(int i=0;i<1000000;i++){
            str += "a";
        }
        
    }
}

package day01;

import java.util.Random;

/**
 * 字符串常量池
 * java对字符串做了一个优化措施，即:使用字面量形式
 * 创建字符串对象时，会将该对象存入常量池缓存起来，
 * 当再次创建该内容字符串时会重用对象，减少内存开销。
 * 正因为重用相同内容字符串对象，所以该对象变为"公用"
 * 对象，那么字符串被规定为是不便对象，即字符串对象一
 * 旦创建内容不可改变，若改变必定创建新对象。
 * @author adminitartor
 *
 */
public class StringDemo1 {
    public static void main(String[] args) {
        String s1 = "123abc";
        //字面量形式创建字符串会重用之前创建的对象
        String s2 = "123abc";//重用s1创建的对象
        
        System.out.println(s1==s2);//true
        
        String s3 = "123abc";
        System.out.println(s1==s3);//true
        
        //new 一定创建新对象
        String s4 = new String("123abc");
        System.out.println(s1==s4);//false
        
        //修改内容会创建新对象
        s1 = s1+"!";
        System.out.println(s1);//123abc!
        System.out.println(s2);//123abc
        System.out.println(s1==s2);//false
        
        /*
         * 编译器在编译源程序时当发现一个计算表达式
         * 计算符号两边的内容都是字面量时，会直接运算
         * 并将结果编译到class文件中，所以下面的代码
         * 在class文件中的样子为:
         * 
         * String s5 = "123abc";
         * 
         * 所以s5会重用s2对象
         */
        String s5 = "123"+"abc";
        System.out.println(s2==s5);
        
        String s = "123";
        String s6 = s + "abc";
        System.out.println(s2==s6);
        
        String s7 = 1+"23"+"abc";
        System.out.println(s2==s7);
        
        String s8 = ‘1‘+23+"abc";
        System.out.println(s2==s8);
    
    }
    
}

package day01;
/**
 * String substring(int start,int end)
 * 截取指定范围内的字符串
 * JAVA API有一个特点，通常使用两个数字表示范围
 * 时都是"含头不含尾"的
 * @author adminitartor
 *
 */
public class String_Substring {
    public static void main(String[] args) {
        //            01234567890123
        String str = "www.oracle.com";
        //截取域名
        String sub = str.substring(4, 10);
        System.out.println(sub);
        
        sub = str.substring(4);
        System.out.println(sub);
    
        //通用截取域名操作
        str = "www.sohu.com.cn";
        int s = str.indexOf(".")+1;
        int e = str.indexOf(".",s);
        sub = str.substring(s, e);
        System.out.println(sub);
        
        
    
    }
}

package day01;
/**
 * String toUpperCase()
 * String toLowerCase()
 * 将当前字符串中的英文部分转换为全大写或全小写
 * @author adminitartor
 *
 */
public class String_ToUpperCase {
    public static void main(String[] args) {
        String str = "我爱Java";
        String upper = str.toUpperCase();
        System.out.println(upper);
        
        String lower = str.toLowerCase();
        System.out.println(lower);
    }
}

package day01;
/**
 * String trim()
 * 去除当前字符串两边的空白字符
 * @author adminitartor
 *
 */
public class String_Trim {
    public static void main(String[] args) {
        String str = "   hello            ";
        System.out.println(str);
        str = str.trim();
        System.out.println(str);
    }
}

package day01;
/**
 * String提供了一组静态方法valueOf
 * 作用是将java中其他类型转换为一个字符串
 * 常用来将基本类型转换为字符串
 * @author adminitartor
 *
 */
public class String_ValueOf {
    public static void main(String[] args) {
        int a = 123;
        String iStr = String.valueOf(a);
        System.out.println(iStr+4);
        
        double d = 123.123;
        String dStr = String.valueOf(d);
        System.out.println(dStr+4);
        
        iStr = a + "";
        
    }
}

package day01;
/**
 * java.lang.StringBuilder
 * 该类为了解决频繁修改字符串带来的性能损耗问题
 * 其提供了编辑字符串的相关方法:
 * 增，删，改，插 
 * @author adminitartor
 *
 */
public class StringBuilderDemo {
    public static void main(String[] args) {
        String str = "努力学习java";
        /*
         * 想修改字符串则创建StringBuilder并将
         * 要修改的字符串内容传入。
         */
        StringBuffer builder
            = new StringBuffer(str);
        
        
        /*
         * StringBuilder append(String str)
         * 在当前字符串末尾追加给定内容
         * 
         * 努力学习java
         * 努力学习java,为了找个好工作!
         */
        builder.append(",为了找个好工作!");
        //toString可以获取builder内部的字符串
        str = builder.toString();
        System.out.println(str);
        
        /*
         * StringBuilder replace(int s,int e,String str)
         * 将当前字符串指定范围内的字符串内容替换为给定内容
         * 
         * 努力学习java,为了找个好工作!
         * 努力学习java,就是为了改变世界!
         */
        builder.replace(9, 16, "就是为了改变世界");
        System.out.println(builder.toString());
        
        
        /*
         * StringBuilder delete(int s,int e)
         * 删除指定范围内的字符串
         * 
         * 努力学习java,就是为了改变世界!
         * ,就是为了改变世界!
         */
        builder.delete(0, 8);
        System.out.println(builder.toString());
        
        /*
         * StringBuilder insert(int index,String str)
         * 在指定位置插入指定字符串
         * 
         * ,就是为了改变世界!
         * 活着,就是为了改变世界!
         */
        builder.insert(0, "活着");
        System.out.println(builder.toString());
        
        //反转字符串
        builder.reverse();
        System.out.println(builder.toString());
    }
}

package day01;
/**
 * 使用StringBuilder修改字符串的效率
 * @author adminitartor
 *
 */
public class StringBuilderDemo2 {
    public static void main(String[] args) {
        StringBuilder builder 
            = new StringBuilder("a");
        for(int i=0;i<1000000;i++){
            builder.append("a");
        }
    }
}

package day01;
/**
 * char charAt(int index)
 * 返回当前字符串中指定位置处的字符
 * @author adminitartor
 *
 */
public class String_CharAt {
    public static void main(String[] args) {
//                      0123456789012345
        String str = "thinking in java";
        char c = str.charAt(9);
        System.out.println(c);//‘i‘
        
        /*
         * 检测回文
         * 上海自来水来自海上
         */
        str = "上海自来水自来海上";
        for(int i=0;i<str.length()/2;i++){
            if(str.charAt(i)!=
               str.charAt(str.length()-1-i)        
            ){
                System.out.println("不是回文");
                return;//结束方法
            }
        }
        System.out.println("是回文");
    }
}

package day01;
/**
 * int indexOf(String str)
 * 查找给定字符串在当前字符串中的位置(下标)
 * 若当前字符串不含有给定内容则返回指为-1
 * @author adminitartor
 *
 */
public class String_IndexOf {
    public static void main(String[] args) {
        //java编程思想
        //            0123456789012345
        String str = "thinking in java";
        
        int index = str.indexOf("in");
        System.out.println("index:"+index);
        //从指定位置处开始查找"in"第一次出现的位置
        index = str.indexOf("in",3);
        System.out.println("index:"+index);
        //查找最后一次出现"in"的位置
        index = str.lastIndexOf("in");
        System.out.println("index:"+index);
        
    }
}

package day01;
/**
 * int length()方法
 * 返回当前字符串的长度(字符个数)
 * @author adminitartor
 *
 */
public class String_Length {
    public static void main(String[] args) {
        String str = "我爱java";
        int len = str.length();
        System.out.println("len:"+len);
    }
}

package day01;
/**
 * boolean startsWith(String str)
 * boolean endsWith(String str)
 * 判断当前字符串是否是以给定字符串起始或结尾的
 * @author adminitartor
 *
 */
public class String_StartsWith {
    public static void main(String[] args) {
        String str = "thinking in java";
        boolean starts = str.startsWith("think");
        System.out.println("starts:"+starts);
        
        boolean ends = str.endsWith("ava");
        System.out.println("ends:"+ends);
    }
}