ApiString

package com.newedu.jb.day14.api;


/**
 * String 类的常用方法测试：
 * 
 * String 类代表字符串。
 * 概念：多个字符组成的一串数据(字符序列)
 * 
 * 注意事项：
 * 1：Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。
 * 2：字符串是常量；它们的值在创建之后不能更改
 * 3：字符串可以看成是字符数组。
 *    char data[] = {'a', 'b', 'c'};
 *    String str = new String(data);
 * 构造方法
 * public String():无参构造
 * public String(byte[] bytes)：byte数组类型
 * public String(byte[] bytes,int offset,int length): offset = index
 * public String(char[] value)
 * public String(char[] value,int offset,int count): offset = index
 * public String(String original): 提供一个字符串常量，来创建一个对象
 * @author jerry
 *
 */


 1， public class StringDemo {


public static void main(String[] args) {


String str0 = new String();
// 正常的方式，创建一个对象 方式1
String str1  = new String("jerry");

// 方式2
String str2 = "jerry";

/**
* 方式2 比方式1 简单，所以工作中非常常用。
*/


char[] array = {'j','e','r','r','y'};

String str3 = new String(array);

// -128 ~ 127
byte[] array2 = {97,98,99};

String str4 = new String(array2);//"abc"
String str5 = new String(array2,0,1);//"abc"

System.out.println(str0);
System.out.println(str1);
System.out.println(str2);
System.out.println(str3);
System.out.println(str4);
System.out.println(str5);


//字符串是常量,它的值在创建之后不能更改
//String s = “hello”; s += “world”; 问s的结果是多少?


String s = "hello";
s +="world";
// s = "helloworld"
System.out.println(s);



//String s = new String(“hello”)
//和String s = “hello”;的区别?

String s1 = new String("hello");
String s2 = "hello";
String s3 = new String("hello");
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
System.out.println(s3.hashCode());

/**
* java 设计之前，String的日常的增加，删除操作等操作，
* 操作效率不高。String作为特殊的 类型处理
*  有常量池的概念
*/






}


}
2 package com.newedu.jb.day14.api;


/**
 * 关于String类型中常量池的概念的练习题
 * @author jerry
 *
 */
public class StringDemo2 {


public static void main(String[] args) {
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1==s2);
System.out.println(s1.equals(s2));


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

String s5 = "hello";
String s6 = "hello";
System.out.println(s5==s6);
System.out.println(s5.equals(s6));

System.out.println("=============");
String s11 = "hello";
String s12 = "world";
String s13 = "helloworld";
// String常量相加时，将两个常量先拼接到一起，然后再到常量池里面。
System.out.println("helloworld"==("hello"+"world"));

// String变量相加时，现在堆内存中，创建一个新的堆空间，堆空间再引用常量池的内容
System.out.println(s13==s11+s12);
System.out.println(s13.equals(s11+s12));

/**
* 变量拼接，被jvm优化为 使用stringbuilder 这个可变字符串来处理，
* 以减少常量池中，临时常量的数量
* 
* 假如： String s1 = "hello"
*      String s2 ="world1"
*      String s3 ="world2"
*      String s4 = "world3"
*         
*         
*         s1+s2+s3+s4
*         
*         "hello"
*         "world1"
*         "world2"
*         "world3"
*      System.out.println(s1+s2+s3+s4);
*      
*      建议 工作中，少用 字符串 变量的+ 拼接；建议使用StringBuilier来拼接字符串
*      但是现在，不用操这个心
*      因为 jdk 1.8 编译器编译的时候，以及自动帮我优化为了 String
*      
*      这个可以字符串来处理。不会增加常量池中，临时常量的数量
*       
*/


String[] array = {"jerry","susan","peter","william",""};


String temp = "";
for(int i=0;i<100;i++){
temp += array[i];
System.out.println(temp);
}

/**
* 
* for  第一次： 
* 
* 常量池中
*  ""
*  "jerry"
*  "jerrysusan"
*  "jerrysuanpeter"
*  "jerrysusanpterwilliam..."
*  
* 
*/
}


}
3，package com.newedu.jb.day14.api;


/**
 * String 类的其他常用方法
 * 
 * -- 判断功能
 * boolean equals(Object obj)：是否相等
 * boolean equalsIgnoreCase(String str)：忽略大小写 来比较是否相等
 * boolean contains(String str)：判断字符串中是否包含子字符串
 * boolean startsWith(String str)：判断字符串是否以 某个子字符串开头
 * boolean endsWith(String str)：判断字符串是否以 某个子字符串结尾
 * boolean isEmpty()：判断字符串是否为空
 * 
 * 
 *--获取功能
 * int length()： 返回该字符串的长度，其实就是内部数组的长度
 * char charAt(int index)：返回指定索引位置的字符串中的单个字符，其实就是内部数组的元素值
 * int indexOf(int ch)：返回一个字符在整个字符串中的第一次出现的索引位置；如果找不到返回-1
 *           这里的入参请注意， 使用了一个技巧： char ，byte，short 自动转换int类型。
 *           indexOf(char ch);
 *           indexOf(byte ch);
 *           indexOf(short ch);
 *           indexOf(int ch);
 * int indexOf(String str): 返回一个指定的子字符串在整个字符串中第一次出现的索引位置；如果找不到返回-1
 * int indexOf(int ch,int fromIndex)：返回一个字符在整个字符串中的第一次出现的索引位置；同时
 *     指定查找开始的索引位置；如果找不到返回-1
 * int indexOf(String str,int fromIndex)：返回一个指定的子字符串在整个字符串中第一次出现的索引位置
 *     同时指定查找开始的索引位置；如果找不到返回-1
 * String subString(int start)：截取整个字符串的一部分，按照指定的索引位置开始，到字符串结尾
 * String subString(int start,int end)：按照指定的开始索引和结束索引，截取整个字符串的一部分；
 * @author jerry
 *
 */
public class StringDemo3 {


public static void main(String[] args) {


//测试String的判断功能

//创建一个字符串对象
String str = "jerrysusanpeter";


boolean result = str.equals("jerrysusanpeter");//发生了向上类型的转换

System.out.println(result);

//ctrl+shift +x 
//ctrl+shift+y
String anotherString = "Jerrysusanpeter";

System.out.println(str.equals(anotherString));
System.out.println(str.equalsIgnoreCase(anotherString));


System.out.println(str.contains("susan"));
System.out.println(str.startsWith("Jerry"));
System.out.println(str.endsWith("r"));
System.out.println(str.isEmpty());
System.out.println(" ".isEmpty());//按照数组的长度来处理


System.out.println("===========截取功能==========");

System.out.println(str.length());
System.out.println(str.charAt(7));// 是从零开始计数的，指定7，其实是返回第8个元素
System.out.println(str.indexOf('s'));
System.out.println(str.indexOf("s"));
System.out.println(str.indexOf('s',6));// 7
System.out.println(str.indexOf("s",7));
System.out.println(str.substring(6));
System.out.println("截取字符串后，原有的字符串变了没有？没变："+str);
System.out.println(str.substring(6,9));
}


}
4， package com.newedu.jb.day14.api;


/**
 * String类型的常用方法
 * 
 * -- 转换功能
 * byte[] getBytes()：将字符串转换为byte数组
 * char[] toCharArray()：将字符串转换为char数组
 * static String valueOf(char[] chs)：将字符数组转化为String类型的对象
 * static String valueOf(int i)：将整数转化为String类型的对象
 * String toLowerCase()：字符串转小写
 * String toUpperCase()：字符串转大写
 * String concat(String str)：字符串拼接
 * 
 * -- 其他功能
 * 
 * 替换功能
 * String replace(char old,char new)
 * String replace(String old,String new)
 * 去除字符串两端空格
 * String trim()
 * 按字典顺序比较两个字符串  
 * int compareTo(String str)：并返回 正数,0，负数
 * int compareToIgnoreCase(String str) 
 * @author jerry
 *
 */
public class StringDemo4 {


public static void main(String[] args) {
String str = "jerrysusanpeter";

byte[] bytes = str.getBytes();
System.out.println(bytes);
for(int i=0;i<bytes.length;i++){
System.out.println(bytes[i]);
}
System.out.println("=========");

char[] charArray = str.toCharArray();
System.out.println(charArray);

for(int i=0;i<charArray.length;i++){
System.out.println(charArray[i]);
}

System.out.println("===============");
//将char数组，转换为一个String类型的对象
String str1 = String.valueOf(charArray);

//将基本数据类型 ，转换为String类型
String str2 = String.valueOf(100);//"100"


System.out.println(str.toUpperCase());
System.out.println(str);
System.out.println(str.toUpperCase().toLowerCase().toUpperCase()
.toLowerCase().toUpperCase());

// concat()拼接

String str3 = "hello";
String str4 = "world";
System.out.println(str3.concat(str4));
//拼接完成后，str3 改变了吗？没有
System.out.println(str3);

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


System.out.println(str3.replace('e', 'a'));
//替换完成后，str3 改变了吗？没有
System.out.println(str3);


String str5 = " jerry  susan   ";
System.out.println(str5.trim());
// trim()后，原先的字符串有没有变？没有
System.out.println(str5);


//int compareTo(String str)：两个字符串判断是否大于小于等于；并返回 正数（大于）,0，负数（小于）

String str6 = "jerry";
String str7 = "jerry";
String str8 = "jerre";
String str9 = "jerrz";

System.out.println(str6.compareTo(str7));
System.out.println(str6.compareTo(str8));
System.out.println(str6.compareTo(str9));




}


}