黑马程序员--学习日记8(String)

-------android培训、java培训、期待与您交流！ ----------

 

 

 

 

String概述

 1.java.lang包-->String
  (1)public final class String
  此类不能有子类，也就是操作字符串的功能不可以被复写。
  (2)String类代表字符串，java程序中所有的字符串字面值(如："abc")都作为此类的实例实现。
  (3)字符串是常量，它们的值在创建后不能更改。
  (4)String类有多种构造方法：
  String s = new String(); <==> String s1 = "";
 2.String s1 = "abc";
  (1)s1是一个类类型变量，"abc"是一个对象，
  (2)字符串最大的特点：一旦被初始化就不可以被改变。
 3.String类复写了Object中的equals方法之后，建立了自己独特的内容，用于判断字符串
  是否相同，equals比较的是地址值。
 4.s1和s2的区别：
  String s1="abc";
  String s2=new String("abc");
  s1在内存中有一个对象。
  s2在内存中有两个对象。
 5.String 类在内存中的原理分析：
  String类在内存中有一个常量池，也就是一个数组，将字符按指定顺序存入数组来组成字符串。

02.String常见功能

 1.获取：
  (1)获取长度：int length()
  (2)根据位置获取字符：char charAt(int index)
  (3)根据字符获取位置：
  int indexOf(int ch):返回ch在字符串中第一次出现的位置。
  int indexOf(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中出现的位置。
  int indexOf(String str):返回str在字符串中第一次出现的位置。
  int indexOf(String str,int fromIndex):从fromIndex指定位置开始，获取str在字符串中出现的位置。
  int lastIndexOf(int ch):返回字符在字符串中最后一次出现的索引位置。
 2.判断：
  (1)字符串中是否包含某一个子串：boolean contains(str)
  (2)字符串中是否有内容：boolean isEmpty()
  (3)字符串是否是以指定内容开头：boolean startsWith(str)
  (4)字符串是否是以指定内容结尾：boolean endsWith(str)
  (5)判断字符串内容是否相同(复写Object类中的equals方法):boolean equals(str)
  (6)判断内容是否相同并忽略大小写：boolean equalsIgnoreCase()
 3.转换：
  (1)将字符数组转成字符串：
  构造函数：
      String(char[])
      String(char[],offset,count)//将字符数组中的一部分转成字符串。
  静态方法：
      static String copyValueOf(char[])
      static String copyValueOf(char[] data,int offset,int count)
      static String valueOf(char[])
  (2)将字符串转成字符数组：char[] toCharArray()
  (3)将字节数组转成字符串:
        String(byte[])
        String(byte[],offset,count)
  (4)将字符串转成字节数组：byte[] getBytes()
  (5)将基本数据类型转成字符串:
         static String valueOf(int)
         static String valueOf(double)
  注:3+"" <==> String.valueOf(3);
   字符串和字节数组在转换过程中，是可以指定编码表的。
 4.替换和切割：
  (1)String replace(oldChar,newChar);
  (2)String replace(charSequence target,charSequence replacem):替换字符串
  (3)切割：String[] split(regex)
  (4)获取子串：
    String substring(begin)
    String substring(begin,end)
 5.比较和去除空格：
  (1)将字符串转成大写或小写：
        String toUpperCase();
        String toLowerCase();
  (2)将字符串两端的多个空格去除：String trim();
  (3)对两个字符串进行自然顺序的比较：int compareTo(String);

03.StringBuffer

 1.关于StringBuffer
  (1)字符串的组成原理就是通过该类实现的。
  (2)StringBuffer可以对字符串内容进行增删。
  (3)StringBuffer是一个容器。
  (4)很多方法与String相同。
  (5)StringBuffer是可变长度的。
 2.public final class StringBuffer
  StringBuffer不能被继承，它是字符串的缓冲区。
  缓冲区特点：
     长度可变。
     可操作多个数据类型。
     最终会通过toString方法变成字符串.
 3.StringBuffer中方法：
  (1)存储：
  StringBuffer append():将指定数据作为参数添加到已有数据结尾处。
  StringBuffer insert(index,data):可将数据插入到指定index位置。
  (2)删除：
  StringBuffer delete(start,end):删除缓冲区中的数据，包含start,不包含end.
  StringBuffer deleteCharAt(index):删除指定位置的字符。
  (3)获取：
  char charAt(int index);
  int indexOf(String str);
  int lastIndexOf(String str);
  int length();
  String substring(int start,int end);
  (4)修改：
  StringBuffer replace(start,end,String str);
  void setCharAt(int index,char ch);
  (5)反转：
  StringBuffer reverse();
  (6)将缓冲区中指定数据存储到指定字符数组中：
  void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin);

04.StringBuilder
 
 1.StringBuffer是线程同步，多线程中使用。
   StringBuilder是线程不同步，单线程使用。

   注：多线程也可用StringBuilder,自己另外加锁Lock.开发建议用StringBuilder.
 2.StringBuilder:
  是一个可变的字符序列，此类提供一个与StringBuffer兼容的API，但不保证同步，
  被设计用作StringBuffer的一个间易替换。用在字符串缓冲区被单线程使用时，比
  StringBuffer快。
 
05。基本数据类型对象包装类：

 1.基本数据类型对象包装类:
  byte Byte
  short Short
  int  Integer
  long Long
  boolean Boolean
  float Float
  double Double
  char Character
 2.基本数据类型对象包装类的最常见作用：
   ---就是用于基本数据类型和字符串类型之间做转换
  (1)基本数据类型转成字符串：
     基本数据类型 + "";
     基本数据类型.toString(基本数据类型值);如：Integer.toString(34)
  (2)字符串转成基本数据类型：
   xxx a = XXX.parseXXX(String str);//静态方法
   如：int a = Integer.parseInt("123");
    double b = Double.parseDouble("12.23");
    boolean b = Boolean.parseBoolean("true");
 3.十进制---->其他进制
  toBinaryString();//2
  toHexString();//16
  toOctalString();//8
 4.其他进制--->十进制
  parseInt(string,radix);如：parseInt("110",10);
 5.基本数据类型对象包装类新特性
  Integer x=4;//自动装箱，隐式完成了new Integer(4)动作。
  x=x+2;//x进行自动拆箱，变成了int类型，和2进行加法运算，再将和进行装箱赋给x;

  注：x的拆箱原理：x.intValue();
   Integer x=null;//NullPointException空指针异常

 

 

 

以下是我的程序代码：

 

/*
class StringDemo01{
 public static void method_is(){
  String str = "ArrayDemo.java";
  //判断文件名称是否是Array单词开头。
  sop(str.startsWith("Array"));
  //判断文件名称是否是.java的文件。
  sop(str.endsWith(".java"));
  //判断文件中是否包含Demo
  sop(str.contains("Demo"));
 }
 public static void method_get(){
  String str = "abcdeaf";
  
  sop(str.length());
  //当访问到字符串中不存在的角标时会发生StringIndexOfBoundsException.
  sop(str.charAt(4));//根据索引获取字符。
  //当没有角标时，将返回-1。
  sop(str.indexOf('a'));//根据字符获取索引。
  sop(str.lastIndexOf("a"));
  method_is();

 }
 public static void main(String args[]){
  method_get();

 }
 public static void sop(Object obj){
  System.out.println(obj);
 }
}
*/

/*
String 类适用于描述字符串事物。
那么它就提供了多个方法对字符串进行操作。
常见的操作有：
1 ，获取：
 1.1字符串中包含的字符数，也就是字符串的长度。
  int length():获取长度。
 1.2根据位置获取位置上某个字符。
  char charAt(int index);
 1.3根据字符获取该字符在字符串中的位置
  int indexOf(int ch)：返回的是ch在字符串中第一次出现的位置。
  int indexOf(int ch,int fromIndex):从fromIndex指定位置开始， 获取ch在字符串中出现的位置。
  int indexOf(String str):返回的是str在字符串中第一次出现的位置。
  int indexOf(String str,int fromIndex):从fromIndex指定位置开始，获取str在字符串中出现的位置。
  int lastIndexOf(int ch):

2 ,判断
 2.1字符串中是否包含某一个子串。
  boolean contains(CharSequence)//String 和StringBuffer都实现了此接口
  特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1，表示该str不在字符串中存在
  if(str.indexOf("aa")!=-1)<如果有内容>而且该方法既可以判断，又可以获取出现的位置。
 2.2字符中是否有内容。
  boolean inEmpty():原理就是判断长度是否为0. "":表一个内容为空的对象 ，null:表引用指向为空；
 2.3字符串是否以指定内容开头。
  boolean startWith(str);
 2.4字符串是否以指定内定结尾。
  boolean endsWith(str);
 2.5判断字符串内容是否相同，覆写了Object类中的equals方法。
  boolean equals(str);
 2.6判断内容是否相同，并忽略大小写。
  boolean equalsIgnoreCase();

  */

 

/*
    字符串去空格
class StringDemo01{
 public static void sop(Object str){
  System.out.println(str);
 }
 public static void main(String args[]){
  String s = "     ab   cd     ";
  sop("("+s+")");
  s = myTrim(s);
  sop("("+s+")");
 }
 public static String myTrim(String str){
  int start = 0;
  int end = str.length()-1;
  while(start<=end && str.charAt(start)==' ')
   start++;
  while(start<=end && str.charAt(end)==' ')
   end--;
  return str.substring(start,end+1);
 }
}

*/

/*    //字符串的反转！！！
class StringDemo01{
 public static void sop(Object str){
  System.out.println(str);
 }
 public static void main(String args[]){
  String s = "     ab   cd     ";
  sop("("+s+")");
  //reverse(s);
  sop("("+s+")");
  sop("("+reverseString(s)+")");
  
 }
 public static String reverseString(String s){
  char[] c =s.toCharArray();
  reverse(c);
  return new String(c);
 }
 public static void reverse(char[] c){
  for(int start=0,end=c.length-1;start<end;start++,end--)
   swap(c,start,end);
 }
 public static void swap(char[]c,int x,int y){
  char temp = c[x];
  c[x] = c[y];
  c[y] = temp;
 }

}

*/

/*    //字符串中子串的反转！！！
class StringDemo01{
 public static void sop(Object str){
  System.out.println(str);
 }
 public static void main(String args[]){
  String s = "ab cd";
  sop("("+s+")");
  
  sop("("+reverseString(s,0,s.length()-1)+")");//开发中此种常见
  
 }
 public static String reverseString(String s,int x,int y){
  char[] c =s.toCharArray();
  reverse(c,x,y);
  return new String(c);
 }
 public static void reverse(char[] c,int start,int end){
  for( end--;start<end;start++,end--)
   swap(c,start,end);
 }
 public static void swap(char[]c,int x,int y){
  char temp = c[x];
  c[x] = c[y];
  c[y] = temp;
 }

}
*/
/* //  字符串中间位置的改变。
class StringDemo01{
 public static void sop(Object str){
  System.out.println(str);
 }
 public static void main(String args[]){
  String s = "ab   cd     ";
  sop("("+s+")");
  //reverse(s);
  sop("("+s+")");
  sop("("+reverseString(s,0,2)+")");
  
 }
 public static String reverseString(String s,int x ,int y){
  char[] c =s.toCharArray();
  reverse(c,x,y);
  return new String(c);
 }
 public static void reverse(char[] c,int x,int y){
  //for(int start=0,end=c.length-1;start<end;start++,end--)
   swap(c,x,y);
 }
 public static void swap(char[]c,int x,int y){
  char temp = c[x];
  c[x] = c[y];
  c[y] = temp;
 }

}

*/

class StringDemo01{
 public static void sop(Object str){
  System.out.println(str);
 }
 public static void main(String args[]){
  String str = "abkkcdkkefkkskk";
  sop(getSubCount(str,"kk"));
 }
 public static int getSubCount(String str,String key){
  int count = 0;
  int index = 0;
 while((index=str.indexOf(key))!=-1){//如果位置不为-1。
   sop("str\t"+str);
   str = str.substring(index+key.length());
   count++;
  }
  return count;
 }
 

}
*/
/*
//第二种获取方式，其中通过截取是不通用的！！！！
class StringDemo01{
 public static void sop(Object str){
  System.out.println(str);
 }
 public static void main(String args[]){
 
  String str = "kkab kk cd kk ef kk s ";
  //sop(getSubCount_2(str,"kk"));
  sop("count="+str.split("kk").length);

 }
 public static int getSubCount_2(String str,String key){
  int count = 0;
  int index = 0;
  while((index = str.indexOf(key,index))!=-1){
   sop("count="+index);
   index = index+key.length();
   count++;
  }
  return count;
 }
 

}
*/

/*
//获取两个字符中最大相同子串，第一个动作：将短的那
//个串进行长度一次递减的子串打印
class StringDemo01{
 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="+max+"...main="+min);
  for(int x =0;x<s2.length();x++){
   for(int y=0,z=s2.length()-x;z!=s2.length()+1;y++,z++){
    String temp = s2.substring(y,z);
    sop(temp);
    if(s1.contains(temp))
     return temp;
   }
  }
  return "";
 }
 public static void main(String args[]){
  String s1 = "abcwerthelloyiodef";
  String s2 = "cvhellobnm";
  sop(getMaxSubString(s1,s2));
 }
 public static void sop(Object obj){
  System.out.println(obj);
 }
}
*/

/*

StringBuffer是字符串缓冲区，为一个容器，里面的值是可以改变的。
可以对它里面的内容：
C create
U update
R read
D delete

1 ,存储。
 StringBuffer append():将指定数据作为参数添加到已有数据结尾处。返回的还是原缓冲区对象。
 StringBuffer insert(index,数据)：可以将数据插入到指定index位置。
 特点：①长度是可变化的②可添加多个数据类型③最终会通过toString方法变为字符串用

 class StringDemo01{
 
 
 public static void main(String args[]){
  StringBuffer sb = new StringBuffer();
  sb.append("abc").append(true).append(34);
  sb.insert(1,"qq");
  sop(sb.toString());
  //StringBuffer sb = new StringBuffer();
  //StringBuffer sb1 = sb.append(34);
  //sop("sb == sb1:"+(sb==sb1));
  //sop(sb.toString());
  //sop(sb1.toString());
 }
 public static void sop(Object obj){
  System.out.println(obj);
 }
}

2 ，删除
 StringBuffer delete(start,end):删除缓冲区中的内容，包含头不包含尾.
 StringBuffer deleteCharAt(index);删除指定位置的字符。

class StringDemo01{
 public static void main(String args[]){
  method_del();
  
 }
 public static void method_del(){
  StringBuffer sb = new StringBuffer("abcde");

  //清空缓冲区
  //sb = new StringBuffer();//sb指向了一个新的面盆
  //sb.delete(0,sb.length());//不包含性，所以sb.length()不用-1；//清空缓冲区
  sb.delete(2,2);//先包含2，后又不包含2.
  sb.deleteCharAt(2);
  
  sb.delete(1,3);//bc没了。

  sop(sb.toString());
 }
 public static void sop(Object obj){
  System.out.println(obj);
 }
}

3 ，获取。
 char charAt(int index)
 int indexOf(String str)
 int lastIndexOf(String str)
 int length()
 String substring(int start,int end)

4 ,修改。
 把原来串里面的东西修改一下，不是在此基础上加东西。把原来串中数据改变。
 StringBuffer replace(int start,int end,String str)
 void setCharAt(int index,char ch)//此方法相当特殊，只替换，不返回！！！ 

class StringDemo01{
 public static void main(String args[]){
  method_update();
 }
 public static void method_update(){
  StringBuffer sb = new StringBuffer("abcde");
  sb.replace(1,4,"java");//不包含尾
  sb.setCharAt(2,'k');
  sop(sb.toString());
 }
 public static void sop(Object obj){
  System.out.println(obj);
 }
}

5 ,反转。
 StringBuffer reverse();
6 ,将缓冲区中指定数据存储到指定字符数组中。

 void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)

 class StringDemo01{
 public static void main(String args[]){
  StringBuffer sb = new StringBuffer("abcdef");
  char[] chs = new char[6];
  sb.getChars(1,4,chs,1);
  for(int x =0;x<chs.length;x++){
   sop("chs["+x+"]="+chs[x]+";");
  }
 }
 
 public static void sop(Object obj){
  System.out.println(obj);
 }
}

JDK1.5之后出现了StringBuildar.
StringBuffer 是线程同步的，用在多线程中。如用在单线程中，效率低，
StringBuilder 是线程不同步的，用在单线程中。无需判断锁，
 
JAVA的升级围绕三点：
①提高效率StringBuilder是为了提高效率。
②减化书写  
③提高安全性

基本数据类型对象包装类。
byte(基本数据类型，关键字） Byte（引用数据类型，类）

基本数据类型对象最常见的作用：
①就是用于基本数据类型和字符串类型之间的转换。

 基本数据类型转成字符串。
  基本数据类型+""
  基本数据类型.toString(基本数据类型值);
  如：Integer.toString(34);//将34整数变成“34”
 字符串转成基本数据类型。 
  <静态转换方式>!!!!!
  static int paseInt(String s)
  xxx a = Xxx.parseXxx(String);
  int a = Integer.parseInt("123" );//必须传入数字格式的字符串
  boolean b = Boolean.parseBoolean("true");
  Character不行，它本身就是字符，字符串中的单位。
     <非静态转换方法>!!!!!
  Integer(int value)//将字符串或整数封装成Integet对象
  int intValue() //以int类型返回该Integer的值。
  Integer i = new Integer("123");
  int num =i.intValue();//对象调用方式。

 

  字符串的操作：
  ①static char toUpperCase(char ch)
  ②static char toLowerCase(char ch)

  十进制转成其他进制。
   toBinaryString();
   toHexString();
   toOctalString();
  其它进制转成十进制
  parseInt(String,radix);

class StringDemo01{
 public static void main(String args[]){
  sop("int max:"+Integer.MAX_VALUE);
  int num = Integer.parseInt("123");
  
  long x = Long.parseLong("123");
  sop("num="+(num+4));
  sop(Integer.toBinaryString(-6));
  sop(Integer.toHexString(60));
  int x = Integer.parseInt("110",2);//要转换的数，和需要转换的进制作为参数。
  sop("x="+x);
 }
 public static void sop(String str){
  System.out.println(str);

 }
}

class StringDemo01{
 public static void main(String args[]){
  Integer x = new Integer("123");
  Integer y = new Integer(123);
  sop("x==y:"+(x==y));
  sop("x.equals(y):"+x.equals(y));
 }
 public static void sop(String str){
  System.out.println(str);

 }
}

 

  //JDK1.5版本新特性。
//自动拆装箱，健壮性稍差，Integer多了一个null值，所以
//在自动拆箱时，可能抛出空指针异常，因为null对象调用
//了intValue方法。Integer x = null;x.intValue()拆箱时要，
//进行判断，不然有可能抛异常。！！！！！！！！

class StringDemo01{
 public static void main(String args[]){
  Integer x = new Integer(4);
  Integer x = 4;//自动装箱。
//类类型引用变量必然指向对象。所以右边应为对象，它自
//动装箱了，相当于new Integer(4);
  x = x+2;//怎么对象能和数据2相运算？
//x+2:x,进行了自动拆箱，变成了int类型，和2进行加法运算
//再将和进行装箱赋给x.

 }
 public static void sop(String str){
  System.out.println(str);

 }
}

//当数值在byte范围内，对于新特性，如果该数值已存在，
//，为节省内存，则不会在开辟新空间了。而超出了byte范
//围，则开辟新空间，创建又一个对象。

class StringDemo01{
 public static void main(String args[]){
  Integer m = 128;
  Integer n = 128;
  sop("m==n:"+(m==n));
  Integer a = 127;
  Integer b = 127;
  sop("a==b:"+(a==b));
 }
 public static void sop(String str){
  System.out.println(str);

 }
}

 

在毕老师视频中有这样的一道作业题：
"12 0 99 -7 30 4 100 13"
要求对字符串中的数值进行排序。生成一个数值从小到大新字符串。
"-7 0 4 12 13 30 99 100"
*/
import java.util.Arrays;

public class Exercise1 {
 public static void main(String[] args) {
  sortPrint();
 }
 public static void sortPrint(){
  String str = "12 0 99 -7 30 4 100 13";
  String[] strArr = str.split(" ");
  int[] intArr = new int[strArr.length];
  //s(Arrays.asList(strArr));
  for(int i=0;i<strArr.length;i++){
    intArr[i] = Integer.parseInt(strArr[i]);
  }
  Arrays.sort(intArr);
  String s = "";
  for(int i=0;i<intArr.length;i++){
   s+=intArr[i]+" ";
  }
  s(s);
  //s(Arrays.asList(intArr));
 }
 public static void s(Object o){
  System.out.println(o);
 }

}

 

/*
class StringDemo01{
 public static void main(String args[]){
  StringDemo01 sd = new StringDemo01();
  sd.consMethod();
 }
 
 public static void consMethod()
       {
              String s = new String();
              String s1 = "";
              System.out.println(s.equals(s1));
       //将字节数组的一部分变成字符串对象
              byte[] arr = {98,99,100};
              String s2 = new String(arr,0,arr.length);
              System.out.println("s2="+s2);
       //将字符数组的一部分变成字符串对象
              char[] arr1 = {'q','c'};
              String s3 = new String(arr1,1,1);
              System.out.println("s3="+s3);
        //将字节数组的一部分变成字符串对象
              int[] arr2 = {65,66,67};
              String s4 = new String(arr2,0,arr2.length);
              System.out.println("s4="+s4);
       }
}

1，判断。
       1.1 判断两个字符串内容是否相同。
              boolean equals(Object)：覆盖了Object类中的方法。
       1.2 判断两个字符串内容是否相同，忽略大小写。
              boolean equalsIgnoreCase(string)
       1.3 判断一个字符串中是否包含另一个字符串。
              boolean contains(string):jdk1.5出现的功能。
       1.4 判断一个字符串是否以一个字符串开头。
              boolean startsWith(string):
       1.5 判断一个字符串是否以一个字符串结尾。
              boolean endsWith(string);
       1.6 判断字符串是否有具体的字符数据。或者成为判断字符串是否有内容。
              boolean isEmpty():原理就是判断字符串的长度是否为0.该方法是jdk1.6版本。
              public boolean isEmpty(){
                     return this.length()==0;
              }
       代码体现：
       public static void method(){
              //判断字符串内容是否相同，忽略大小写。
              String s1 = "abc";
              String s2 = "Abc";
              System.out.println("s1.equals(s2):"+s1.equals(s2));
              System.out.println(("s1.equalsIgnoreCase(s2):"+s1.equalsIgnoreCase(s2));
        //判断字符串是否包含指定字符串
              String s3 = "kkabcde";
              System.out.println(("s3.contains(s1)="+s3.contains(s1));
        //判断字符串是否是以指定字符串开头
              System.out.println(("s3.startsWith(ab)="+s3.startsWith("kk"));
        //判断字符串是否是以指定字符串结尾
              String s4 ="StringDemo.java";
              System.out.println("s4.endsWith(.java)="+s4.endsWith(".java"));
        //判断字符串是否有内容
              String s5 = "";
              System.out.println("s5.isEmpty()="+s5.isEmpty());
       }

    2.获取
              2.1 获取字符串的长度。
                     int length();
              2.2 根据指定的位置获取该位置对应的字符。
                     char charAt(index);
              2.3 根据字符获取该字符第一次出现的位置
                     int indexOf(ch);
                     int idnexOf(ch,fromIndex):从fromIndex位置开始获取ch第一次出现的位置。
                     找到了就返回第一次出现角标位，没找到，就返回-1.所以，
                     可以通过-1这种方式判断一个字符是否在字符串存在。
              2.4 根据字符串获取该字符串第一次出现的位置
                     int indexOf(string);
                     intidnexOf(string,fromIndex):从fromIndex位置开始获取string第一次出现的位置。找到了就返回第一次出现角标位，没找到，就返回-1.所以，可以通过-1这种方式判断一个字符串是否在字符串存在。这既是contains方法原理。
              2.5 同样是获取一个字符或者字符串第一次出现的位置，但是是通过反向索引完成。
                     功能和indexOf一致。
                     int lastIndexOf(ch);
                     intlastIdnexOf(ch,fromIndex):
                     int lastIndexOf(string);
                     intlastIdnexOf(string,fromIndex):
              2.6 获取字符串中的一部分字符串。
                     String substring(start):从start开始到结尾。
                     Stringsubstring(start,end);获取到的字符串包含start位，不包含end位。
classStringMethodDemo {
   public static void sop(String str){
   System.out.println(str);
}
   public static void main(String[] args) {
    method();
}
   public static void method(){
   String s1 = "abcedfckk";
   sop(s1);
   //根据指定位置获取该位置的字符
   sop("s1.charAt(2):"+s1.charAt(2));
   //从第3个位置开始查找指定字符出现的位置
  sop("s1.indexOf(c)="+s1.indexOf('c',3));
   //从开始位置开始查找指定字符出现的位置
   sop("s1.indexOf(q)="+s1.indexOf('q'));
   //从开始位置开始查找指定字符串出现的位置
  sop("s1.indexOf(ckq)="+s1.indexOf("ckq"));
   //反向开始查找指定字符出现的位置
  sop("s1.lastIndexOf(c)="+s1.lastIndexOf('c'));
   //从指定位置开始获取字符串的一部分
  sop("s1.substring(2):"+s1.substring(2));
   //获取整串 s1.substring(0,s1.length());
   sop("s1.substring(2,5):"+s1.substring(2,5));
   sop("s1="+s1);// 原串没变化。
}
}

classStringBufferDemo {
       public static void main(String[] args) {     
              method_3();
       }
       public static void method_3(){
              StringBuffer sb = newStringBuffer("abcde");
 
              sb.replace(1,4,"haha");//替换
              sb.setCharAt(2,'k');//修改
              sb.setLength(3);//设置字符串的长度
              System.out.println(sb);
       }
       public static void method_2(){
              StringBuffer sb = newStringBuffer("abcde");
              sb.insert(1,"ak");//将字符串插入到此字符序列中
              sb.delete(1,3);//从指定位置删除
              //清空缓冲区。
              sb.delete(0,sb.length());
              sb.deleteCharAt(3);//删除指定位置的元素
              System.out.println(sb);
       }
       public static void method_1(){
              StringBuffer sb = newStringBuffer();
              sb.append(34).append("haha").append('k').append(true);//方法调用链 
              System.out.println(sb.toString());
       }
}

class StringDemo01 {
       public static void main(String[] args) {
              StringBuilder s1 = newStringBuilder("java");
              StringBuilder s2 = newStringBuilder("haha");
              show(s1,s2);
              System.out.println(s1+"....."+s2);
       }
       public static void show(StringBuilder s1,StringBuilder s2)
       {
              s1.append(s2);
              s1 = s2;
       }
}

 

classStringBuilderTest {
       public static void main(String[] args) {
              int[] arr  = {3,1,5,6,2};
              method_2(arr);
       }
    public static void method_1(int[] arr){
              String s = "[";
              for(int x=0; x<arr.length;x++){
                     if(x!=arr.length-1)
                            s+=arr[x]+",";
                     else
                            s+=arr[x]+"]";
              }
              System.out.println(s);
       }
       public static void method_2(int[] arr){
              StringBuilder sb = newStringBuilder();
              sb.append("[");
              for(int x = 0 ; x<arr.length;x++){
                     if(x!=arr.length-1)
                            sb.append(arr[x]+"-");
                     else
                            sb.append(arr[x]+"]");
              }
              System.out.println(sb);
       }
}
 

///

class IntegerDemo {
       public static void main(String[] args) {
              method_6();
       }
       public static void method_6(){
              Integer x = newInteger("123");
              Integer y = new Integer(123);
              System.out.println(x==y);//false
              System.out.println(x.equals(y));//true//复写了Object类中的方法，Integer对象比较的是对象中的封装的整数是否相同。
       }
       public static void method_5(){
              String s = Integer.toString(5);
              //String s = 5+"";
              System.out.println(s+6);
              String s1 =Integer.toString(60,16);//可以获取指定十进制数对应其他进制。
              System.out.println(s1);
       }
       public static void method_4(){
              int num =Integer.parseInt("110",2);//可以将指定的进制转成十进制。
              System.out.println(num);
       }
       public static void method_3(){
              Integer i = newInteger("123");//将一个数字格式的字符串封装成了一个Integer对象。
              int num = i.intValue();//将一个Integer对象转成对应的int数值。
              System.out.println(num+4);
       }
       public static void method_2(){
              //将字符串转成一个基本数据类型值。
              String s = "123";
              int num =Integer.parseInt("qq");//NumberFormatException
              System.out.println(num+4);
       }
       public static void method_1(){
              //把一个整数封装成对象有什么好处呢？
              System.out.println(Integer.MAX_VALUE);
              System.out.println(Integer.toBinaryString(-6));
              System.out.println(Integer.toHexString(60));
       }
}

///

class RuntimeDemo {
       public static void main(String[] args)throws Exception{
              //获取runtime对象。
              Runtime r  = Runtime.getRuntime();
              //调用exec方法。
              r.exec("notepad.exeSystemDemo.java");//可以通过指定应用程序，去解析指定的文件。
              Process p =r.exec("winmine.exe");// 本地文件的执行。
              Thread.sleep(4000);
              p.destroy();//只能杀Runtime exec开启的进程。
//      windows中的已有进程杀不了。
       }
}