Day7/8总结-----String

最新推荐文章于 2023-03-22 14:45:28 发布

98K满配THX

最新推荐文章于 2023-03-22 14:45:28 发布

阅读量174

点赞数

分类专栏： summary 文章标签： string java 对象

本文链接：https://blog.csdn.net/kiwi_juice/article/details/78923452

版权

summary 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

String概述：

package stringdemo;
/*String概述：
 * String类,java中所有字符串字面值如"abc"都可以作为此类的实例实现
 * 双引号引起来的都可以作为此类的具体实现对象
 * 字符串是一个特殊的对象
 * 字符串一旦被初始化就不可以改变
 * String str="abc";
 * String str1=new String("abc");
 * public final class String , extends object
 * 
 * 操作字符串这个功能是不可以复写的，不可能有子类 
 * 字符串有自己独特的比较方式 equals判断内容是否相同
 * */
public class StringDemo
{
    public static void main(String [] args) 
    {
        String s1="abc";
        //s1="kk";
        String s2=new String("abc"); 
        String s3="abc";//s3发现"abc"已经在内存中存在 而且不能改变所以s3不会再开辟空间
        System.out.println(s1);
        System.out.println(s1.equals(s2));//String类复写了object类中的equals方法，该方法用于判断字符串是否相同
        System.out.println(s1==s2);
        System.out.print(s1==s3);
        /*
        s1 s2有什么区别？？
        s1在内存中有一个对象
        s2在内存中有两个对象
        */
    }

}

package stringdemo;
/*常见的操作：获取，判断，转换
 * "abcd"
 * 1.获取
 * 1.1字符串中包含的字符数，也就是字符串的长度
 *  int length()：获取长度//数组的length是属性，而这里的length是方法
 * 1.2根据位置获取某个字符
 *  返回值类型char 
 *  char charAt(int index):
 * 1.3根据字符获取该字符在字符串中的位置
 *  返回值类型int 
 * 字符：
 *  int indexOf(int ch)接受的是ASCAMA:返回的是ch在字符串中第一次出现的位置
 *  int indexOf(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中出现的位置
 * 字符串：
 *  int indexOf(int str)接受的是ASCAMA:返回的是str在字符串中第一次出现的位置
 *  int indexOf(int str,int fromIndex):从fromIndex指定位置开始，获取str在字符串中出现的位置
 * 反向索引：
 *  int lastIndexOf(int ch):
 * 
 * 
 * 2.判断
 * 2.1字符串中是否包含某一个子串
 *  boolean contains(str):判断字符串是否存在
 *  特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1则表示str不在字符串中存在
 *  所以，也可以用于指定判断是否包含
 *  if(str.indexOf("aa"!=-1))
 *  而且该方法既可以判断又可以获取出现的位置
 * 2.2字符串中是否有内容
 *  boolean isEmpty():原理就是判断长度是否为0
 * 2.3字符串是否以指定内容开头
 *  返回值类型boolean
 *  boolean startsWith(str);
 * 2.4字符串以什么结尾
 *  boolean endsWith(str);
 * 2.5判断字符串的内容是否相同，复写了Object类中的equals方法
 *  boolean equals(str);
 * 2.6判断内容是否相同，并忽略大小写
 *  boolean equalsIgnoreCase();
 * 
 * 
 * 3.转换//不太会
 * 3.1将字符数组转成字符串
 *  构造函数：String (char[])
 *         String (char[],offset,count):将字符数组中的一部分转成字符串
 *  静态方法：static String copyValueOf(char[]);
 *         static String copyValueOf(char[] data,int offset,int count)
 * 3.2将字符串转换成字符数组
 *  char[] toCharArray():
 * 3.3将字节数组转换成字符串
 *  String(byte[])
 *  String(byte[],offset,count):将字节数组中的一部分转换成字符串
 * 3.4将字符串转换成字节数组
 *  byte[] getBytes();
 * 3.5将基本数据类型转换成字符串
 *  static String valueOf(int)
 *  static String valueOf(double)   
 * 
 * 
 *  4.替换
 *  String replace(oldchar,new char);
 * 
 * 
 * 5.切割
 *  String[] split(regex);
 * 
 * 
 * 6.子串：获取字符串中的一部分
 *  String subString(begin);
 *  String subString(begin,end);
 * 
 * 
 * 7.转换，去除空格，比较
 *  7.1将字符串转换成大写或小写
 *  String toUpperCase();
 *  String toLowerCase();
 *  7.2将字符串两段的多个空格去除
 *  String trim();
 *  7.3对两个字符串进行自然顺序的比较
 *  int compareTo(String);
 */

public class StringMethod 

{
    public static void method_7() 
    {
        String s="     Hello Java     ";
        sop(s.toUpperCase());
        sop(s.toLowerCase());
        sop(s.trim());
        String s1="a1c";       
        String s2="aaa";
        sop(s1.compareTo(s2));//s1是此字符串，s2是字符串参数
        //如果参数字符串等于此字符串则返回值0；
        //如果此字符串按字典顺序小于字符串参数则返回一个小于0的值
        //如果此字符串按字典顺序大于字符串参数则返回一个大于0的值



    }
    public static void method_sub() 
    {
        String s="abcdef";
        sop(s.substring(2));//从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常                                                                                                                                                                                                                                                                
        sop(s.substring(2,4));//包含头不包含尾。获取整个字符串：s.subString(0,s.length());
    }
    public static void method_split() 
    {
        String s="zhangsan,lisi,wangwu";//,作为一个分隔符
        String[] arr=s.split(",");
        for(int x=0;x<arr.length;x++) 
        {
            sop(arr[x]);
        }
    }
    public static void method_replace() 
    {
        String s="hello java";
        String s1=s.replace('a','n');
        String s2=s.replace('q','n');
        String s3=s.replace("java", "world");
        sop("s="+s);
        sop("s1="+s1);
        sop("s2="+s2);//替换的字符不存在，返回的还是原来的字符串
        sop("s3="+s3);

    }
    public static void method_trans() 
    {
        char[]arr= {'a','b','c','d','e','f'};
        String s=new String(arr,1,3);//从第一位开始取三个
        sop("s="+s);
    }
    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() //方法1
    {
        String str="abcdeakpf";
        //长度
        sop(str.length());
        //根据索引获取索引
        sop(str.charAt(4));
        //根据字符获取索引
        sop(str.indexOf('a',3));//从d这位开始找a
        sop(str.charAt(40));//当访问到字符串中不存在的角标时会发生角标越界异常
        sop(str.indexOf('m'));//如果没有找到，返回-1
        //反向索引一个字符出现的位置
        sop(str.lastIndexOf("a"));//从右往左查找，但是角标按照原来
        //

    }
    public static void main(String[] args) 
    {
        method_7();
        method_sub();
        method_split();
        method_replace();
        method_trans();
        method_is();
        method_get();

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

}

package stringdemo;
//String字符串练习：
/*
 * 1.模拟一个trim方法，去除字符串两端的空格
 * 思路：
 * 1.判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是为止
 * 结尾处判断空格也是如此
 * 2.当开始和结尾都判断不是空格时，就是要获取的字符串
 * 
 * */
public class StringPractice 
{

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


    }
    public static void main(String[] args) 
    {
        String s="      ab cd     ";
        sop("("+s+")");
        s=myTrim(s);
        sop("("+s+")");
        sop("("+reverseString(s)+")");
        String str="abkkcdkkefkkskk";
        sop("count="+getSubCount(str,"kk"));
        String s1="abcwerthelloyuiodef";
        String s2="cvhellobhm";
        sop(getMaxSubString(s1,s2));


    }
    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);
    }



/*
 * 2.将一个字符串进行反转，将字符串中指定部分进行反转，"abcdefg"，"abfedcg"
 * 思路：
 * 1.将字符串变成数组
 * 2.对数组反转
 * 3.将数组变成字符串
 * */

    public static String reverseString(String s) 
    {
        //字符串变数组
        char[] chs=s.toCharArray();
        //反转数组
        reverse(chs);
        //将数组变成字符串
        return new String(chs);

    }



    private static void reverse(char[]arr) 
    {
        for(int start=0,end=arr.length-1;start<end;start++,end--)

        {
            swap(arr,start,end);
        }
    }
    private static void swap(char[]arr,int x,int y) 
    {
        char temp=arr[x];
        arr[x]=arr[y];
        arr[y]=temp;
    }



/*
 * 3.获取一个字符串在另一个字符串中出现的次数
 * "abkkcdkkefkkskk"
 * 思路：
 * 1.定义个计数器
 * 2.获取kk第一次出现的位置
 * 3.从第一次出现后剩余的字符串中继续获取kk出现的位置
 * 4.当获取不到时，计数完成
 * 
 **/

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




/*4.获取两个字符串中最大相同子串，第一个动作：将短的那个串进行长度一次递减的子串打印
 * "abcwerthelloyuiodef"
 * "cvhellobhm"
 * 思路：
 * 1.将短的那个子串按照长度递减的方式获取到
 * 2.将每获取到的子串去长串中判断是否包含
 * 如果包含，已经找到
 * */   
    public static String getMaxSubString(String s1,String s2) 
    {
        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 "";
    }


    /*
     * s1,s2没有确定值
    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+".......min="+min);

        for(int x=0;x<min.length();x++) 
        {
            for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++) 

            {
                String temp=min.substring(y,z);
                sop(temp);
                if(max.contains(temp)) //if(indexOf(temp)!=-1)
                {
                return temp;
                }
            }

        }
        return "";
    }

    */
}