JavaSE基础自学----String

String

        String s1="abc";  s1是一个类类型变量,"abc"是一个对象
                         字符串最大特点,一旦被初始化就不可以改变

        String s2=new String("abc");

           s1 s2的区别
        s1在内存中有一个对象
        s2在内存中有两个对象
        
        s1.equals(s2);    String 类覆写了Object类中的equals方法,该方法用于判断字符串是否相同

---

String 操作方法

1- 获取 ----

• length() ----返回此字符串的长度
• charAt(int index) -----返回指定位置的 char 值。
• indexOf(int ch) -----返回指定字符在此字符串中第一次出现的位置。不存在则返回-1
• indexOf(int ch, int fromIndex) -----从指定的位置开始搜索。
• indexOf(String str) ------返回指定子字符串在此字符串中第一次出现的位置。不存在则返回-1
• indexOf(String str, int fromIndex) ------从指定的位置开始搜索。
• lastIndexOf(int ch) ----返回指定字符在此字符串中最后一次出现的位置。
• indexOf前面可以加last,不一一列出了,

2 -判断 -----

• contains(String/char) -----判断字符串中是否包含某个字符串或字符
  特殊之处 : indexOf 返回字符出现的位置,如果不存在则返回-1,所以也可以用来判断是否包含字符
  if(str.indexOf(“xx”)!=-1) : 可以获取位置,又可以判断是否包含
• isEmpty() -----判断字符串是否有内容,原理是判断长度是否为0
• startsWith(String prefix) ------ 字符串是否以指定内容开头
• endsWith(String suffix) ------ 字符串结尾是否为指定内容
• equals(Object anObject) ----判断两个字符串内容相同
• equalsIgnoreCase(String anotherString) -------将此 String 与另一个 String 比较，不考虑大小写。

3 - 转换 -----

• 字符 数组 转换成字符串
  构造函数 :
  String(char[ ] value)
  String(char[ ] value, int offset, int count) --指定范围
  静态方法 :
  copyValueOf(char[ ] data)
  copyValueOf(char[ ] data, int offset, int count) -----指定范围
  ValueOf(char[ ] data)
• toCharArray() -----字符串转换为字符数组。
• getBytes() ------字符串转换成字节数组
• 字节数组 转换成字符串
  String(byte[ ] bytes)
  String(byte[ ] bytes, int offset, int count) -----指定范围
• 将基本数据类型转换成字符串
  static | valueOf(int i)
  static | valueOf(double d)

4 - 替换 -----

• replace(char oldChar, char newChar) -----返回一个新的字符串， newChar 替换此字符串中出现的所有 oldChar

5 -切割 -----
split(String regex) ----- 根据给定正则表达式的匹配拆分此字符串。返回一个字符串数组;

6 - 子串,获取字符串的一部分

• substring(int beginIndex)
  substring(int beginIndex, int endIndex) —到指定位置结束,不包含endIndex位置

7 - 转换,去除空格,比较

• toLowerCase() -----将此 String 中的所有字符都转换为小写。
  toUpperCase() ------将此 String 中的所有字符都转换为大写。
• trim() ------将字符串两端空格去除
• s1.compareTo(s2) -----两个字符串进行自然顺序比较
  compareToIgnoreCase(String str) ------不考虑大小写。

代码演示-----

public class DEMO {
    public static void method1() {  //获取功能
        String s = "abcdefc";

        sop(s.length()); //打印字符串长度

        sop(s.charAt(2));  //打印指定位置的字符,如果不存在该角标则发生异常

        sop(s.indexOf("c", 3)); //从指定位置开始寻找指定字符位置,如果不存在该字符则返回-1

        sop(s.indexOf("cd"));  //打印该字符串的位置

        sop(s.lastIndexOf("c", 1));  //从指定位置反方向寻找字符
    }

    public static void method2() {  //判断功能
        String s = "ArrayDemo.java";
        String s1 = "arrayDemo.java";

        sop(s.startsWith("Array")); //判断文件名是否以Array开头

        sop(s.endsWith(".java"));  //判断文件名是否.java的文件

        sop(s.contains("Demo"));   //判断文件名是否包含Demo

        sop(s.equalsIgnoreCase(s1));  //比较字符中内容,字母不分大小写
    }

    public static void method3() { //转换功能
        char[] ch = {'a', 'b', 'c', 'd'};
        String s1 = new String(ch, 1, 3);//将字符数组转换成字符串,从角标1开始到角标3
        sop(s1);

        sop(String.copyValueOf(ch, 1, 3)); //将字符数组转换成字符串,从角标1开始到角标3

        sop(String.valueOf(ch));   //将字符数组转成字符串

        String s2 = "aaabbb";
        char[] ch1 = s2.toCharArray(); //字符串转成字符数组
        for (int i = 0; i < ch1.length; i++) {  //打印字符数组
            System.out.print(ch1[i]);
        }

        byte[] b = s2.getBytes(); //字符串转成字节数组
        for (int i = 0; i < b.length; i++) {//打印字节数组
            System.out.print(b[i] + " ");
        }

        byte[] b1 = {80, 98, 99};  //Pbc的字节
        String ss = new String(b1);//字节数组转换成字符串
        sop(ss);

        sop(String.valueOf(3.5555));  //将基本类型double转成字符串
    }

    public static void method4() {  //替换功能
        String s = "hallo java";
        String s1 = s.replace("hallo", "hehe");  //用指定字符串修改成指定字符串
        String s2 = s.replace('a', 'n');//用指定字符修改成指定字符
        sop(s1);
        sop(s2);
    }

    public static void method5() {  //分割功能
        String s = "zhangsan,lisi,wangwu";
        String[] s1 = s.split(",");  //用","分割字符串 返回一个字符串数组
        for (int i = 0; i < s1.length; i++) {
            sop(s1[i]);
        }
    }

    public static void method6() {  //获取字符串一部分
        String s = "javaisgood";
        String s1 = s.substring(2); //从指定位置开始到结尾,
        String s2 = s.substring(0, 4); //从指定位置开始到结尾,不包含结尾
        sop(s1);
        sop(s2);
    }

    public static void method7() {
        String s1 = "   Hallo Java  ";
        sop(s1.toLowerCase());   //转换成小写
        sop(s1.toUpperCase());   //转换成大写

        sop(s1.trim());   //去除两端空格

        String s3 = "adc";
        String s4 = "abc";
        sop(s3.compareTo(s4)); //比较自然顺序,如果返回值大于0则s3比s4后;
    }

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

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

---

练习

    public static void myTrim(String s) {  //去除字符串两端的空格
        char[] ch = s.toCharArray();  //字符串转成字符数组
        int start = 0;             //头角标
        int end = s.length() - 1;  //尾角标
        while (start <= end && ch[start] == ' ') {   //前角标小于等于后角标
            start++;
        }
        while (start <= end && ch[end] == ' ') {
            end--;
        }
        String s1 = s.substring(start,end+1);  
        sop(s1);
        sop(start+" "+end);
    }
    
    -------------------------------------------------------------------------------------
    
     public static void reversal(String s,int x,int y){  //翻转指定部分字符串,不包含尾
        char[] ch=s.toCharArray();

        int d=ch[x],f=ch[y-1];  //检测角标是否越界,

        for (int start=x,end=y-1;start<end;start++,end--){abcd
            char c=ch[start];
            ch[start]=ch[end];
            ch[end]=c;
        }

        String s1=new String(ch);
        sop(s1);
    }
    public static void reversalAll(String s){//反转全部字符串
        reversal(s,0,s.length());
    }  

----------------------------------------------------------------------------------------

    //获取一个字符串在另一个字符串出现的次数
    public static void count(String s,String key){
        int count=0;  //指定字符串出现的次数
        int i=0;     //开始查找的位置
        int index;  //指定字符出现的位置

        while ((index=s.indexOf(key,i))!=-1){ //判断字符串中是否有指定字符串
            count++;
            i=index+key.length();   //更新起始查找位置
            sop(index);             //打印指定字符串出现的位置
        }
        sop("该字符串出现的次数="+count);
    }
    
-------------------------------------------------------------------------------

    //获取两个字符串中最大的相同子串
    public static String contanis1(String s1,String s2){
        String max=((s1.length()>s2.length())?s1:s2);  //获取长度最长的字符串
        String min=((max==s1)?s2:s1);     //获取长度最短的字符串

        for (int i=0;i<min.length();i++){

            for (int j=0,z=min.length()-i;z!=min.length()+1;j++,z++ ){  //min.lenght-1确定遍历最大范围....j++,z++移动最大范围,
                                                                        //z!=min.length()+1,尾角标小于字符串长度+1,
                String temp=min.substring(j,z);     //使用substring获取该范围字符串

                if (max.contains(temp)){
                    return temp;
                }
            }
        }return "无";
    }

StringBuffer/StringBuilder

StringBuffer 是字符串缓冲区,是一个容器

• 特点
  1,长度是可变化的
  2,可以直接操作多个数据类型
  3,最终会通过 toString 变成字符串

Jdk1.5后出现了StringBuilder
StringBuilder功能跟StringBuffer一样
但是StringBuffer:线程是同步的…StringBuilder:线程不同步

• 1 - 存储
  StringBuffer | append( ) ----将指定数据作为参数添加到已知数据结尾处
  StringBuffer | insert(index , 基本数据类型) ----可以将数据插入指定位置index
• 2 - 删除
  StringBuffer | delete(int start, int end) -----删除缓冲区中的数据,包含 start ,不包含end
  StringBuffer | deleteCharAt(int index) -----删除指定位置字符
• 3 -获取
  charAt(int index) ------获取指定位置字符
  indexOf(String str)
  indexOf(String str, int fromIndex) ----返回指定字符串位置,从指定位置开始
  String substring(int start, int end) -----获取子串,从start开始到end结束,不包含end
• 4 - 修改
  StringBuffer | replace(int start, int end, String str) -----指定范围中修改成指定字符串,不包含尾
  setCharAt(int index, char ch) -----修改指定位置的字符
• 5 - 反转
  StringBuffer | reverse()
• 6 - 复制
  getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) -----将字符从此字符串复制到目标字符数组。

 public static void method1() {
        StringBuffer sb = new StringBuffer();
        sb.append(36.5).append("aa");  //往StringBuffer中添加
        sop(sb.toString());

        sb.insert(4, "--"); //在指定位置存入字符串
        sop("insert :" + sb.toString());

        sb.delete(2, 3);             //删除指定范围字符串,不包含尾
        sop("delete :" + sb);

        sb.deleteCharAt(3);
        sop("deleteCharAt :" + sb); //删除指定位置字符

        sb.replace(1, 3, "aa"); //修改指定范围字符串,不包含尾
        sop("replace :" + sb);

        sb.reverse();        //反转字符串
        sop(sb.toString());

        String s1 = sb.toString();
        sop(s1);

        char[] ch = new char[6];
        sb.getChars(1, 4, ch, 1); //将Buffer中的字符串复制到字符数组
        for (int i = 0; i < ch.length; i++) {
            sop("ch[" + i + "]=" + ch[i]);
        }

---

基本数据类型包装类

基本数据类型对象包装类
char ----- Character —16bit
int ----- Integer —32bit
byte ----- Byte —8bit
short ----- short —16bit
long ----- Long —64bit
boolean ----- Boolean —1bit
float ----- Float —32bit
double ----- Double —64bit

基本数据类型对象包装类的常见作用
就是用于基本数据类型和字符串之间的做转换

• 基本数据类型转成字符串
  基本数据类型+""
  基本数据类型.toString(基本数据类型值):

 String s1=34+"";
 String s1=Integer.toString(345);
 String s1=String.valueOf(3645);
 String s1=Double.toString(3.5);

---

• 字符串转成基本数据类型

int i=Integer.parseInt("98");
double d=Double.parseDouble("3.15");
boolean b=Boolean.parseBoolean("true");

Integer a=new Integer("168"); //非静态方法
int num=a.inValue();

---

• 十进制转成其他进制

sop(Integer.toBinaryString(6));  //转成2进制
sop(Integer.toHexString(60));   //转成16进制
sop(Integer.toOctalString(60)); //转成8进制

• 其他进制转成十进制

sop(Integer.parseInt("110",2));//radix:进制,什么的2进制是110
sop(Integer.parseInt("3C",16));//radix:进制,什么的16进制是3C

• JDK1.5新特性,自动装箱,自动拆箱

Integer x=4; //自动装箱,new Integer(4);
x=x+2; // x.intValue(),x 进行自动拆箱,变成int类型,和2进行运算;
               //再进行装箱赋值给x

Integer z=128;
Integer y=128;
sop(z==y); //结果为flase

Integer a=127;
Integer b=127;
sop(a==b);//结果为true, a,b指向了同一个Integer对象
      //因为当数值在bety范围内,对于新特性,如果该值已经存在,则不会开辟新空间