zoukankan      html  css  js  c++  java
  • 字符串

    1、String字符串一般不用new来初始化。字符串最大的特点是一旦被初始化就不可以再修改,String为final类。字符串常见操作有获取和判断。字符串定义了后放在字符串池中,是一个常量,一旦新的字符串定义就检测字符串池有没有这个字符串,如果有就将之赋给新的字符串。用new创建字符串时是定义两个字符串,白开辟了一个空字符串空间。

     1 package pack;
     2 
     3 public class Test
     4 {
     5     public static void main(String[] args) 
     6     {
     7         String str=new String();    //这种方式不常见
     8         str="hahahah";
     9         
    10         String s="hehehehe";        //一般是这种定义方式,s为指向"hehehehe"对象的引用
    11         s="lalalala";                //此时s为指向"lalalala"对象的引用,对象本身没有变,也不可以变
    12         
    13         String str1=new String("nnnnnn");
    14         String str2="nnnnnn";
    15         String str3="nnnnnn";
    16         //str1和str2的区别是:str1在内存中有一个对象,str2有两个对象。
    17         System.out.println(str1==str2);    //判断两个对象是否相同,此时是两个对象,当然不同
    18         System.out.println(str2==str3);    //内存中的常量池使str3不再重复开辟空间
    19         System.out.println(str1.equals(str2));    //判断两个字符串是否相同
    20         getString();
    21         getIs();
    22     }
    23     public static void str(Object obj)
    24     {
    25         System.out.println(obj);
    26     }
    27     public static void getString()
    28     {
    29         String s="abcdefghi";
    30         str(s.length());
    31         str(s.charAt(3));
    32         str(s.indexOf('n',3)); //找不到就返回-1
    33         str(s.lastIndexOf("f"));
    34     }
    35     public static void getIs()
    36     {
    37         String str1="ArrayDemo.java";
    38         //判断文件是否以Array开头
    39         str(str1.startsWith("Array"));
    40         //判断文件是否是.java文件
    41         str(str1.endsWith(".java"));
    42         //判断字符串中是否有某个子串Demo
    43         str(str1.contains("Demo"));
    44     }
    45 }

    2、String类的操作

     1 package pack;
     2 //字符串的转换动作、替换动作、切割动作和获得字符串中的一部分子串,转换大小写,将字符串两端的多个空格去除,对两个字符串进行自然顺序的比较
     3 public class Test
     4 {
     5     public static void main(String[] args) 
     6     {
     7         /*将字符数组转换为字符串
     8          * 构造函数:String(char[]);
     9          * 构造函数:String(char[],offset,count);一部分转化为字符串
    10          * 静态方法:static String copyValueOf(char[]);
    11          *         static String copyValueOf(char[] data,int offset,int count);
    12          *         static String valueOf(char[]);
    13          */
    14         char[]    a={'a','b','c','d','e'};
    15         String a1=new String(a);
    16         String a2=new String(a,1,3);
    17         sop("a1="+a1);
    18         sop("a2="+a2);
    19         /*将字节数组转换为字符串
    20          * 构造函数:String(byte[]);
    21          * 构造函数:String(byte[],offset,count);一部分转化为字符串
    22          */
    23         
    24         /*将字符串转成字符数组
    25          * char[] toCharArray();
    26          */
    27         
    28         /*将字符串转成字节数组
    29          * byte[] getBytes();
    30          */
    31     
    32         //字符串和字节数组在转换的过程中是可以制定编码表的
    33         
    34         
    35         //字符串的替换动作
    36         /*String replace(oldchar,newchar);
    37          * 如果要替换的字符串不存在就返回原字符串
    38          */
    39         String a3="hello java";
    40         String a33=a3.replace('h', 'n'); //字符串不可以被修改,这是又新定义了一个字符串a33
    41         String a4="hello java1";
    42         String a5="hello java2";
    43         a3.replace('a', 'b');
    44         a4.replace('x', 'b');
    45         String a6=a5.replace("hello", "nohello");//连续字符串替换需要新定义字符串
    46         sop("a3="+a3);
    47         sop("a33="+a33);
    48         sop("a4="+a4);
    49         sop("a6="+a6);
    50         
    51         //字符串切割动作
    52         /*String[] split(regex);
    53          * 
    54          */
    55         String s="zhangsan,lisi,wangwu";
    56         String[] arr=s.split(",");
    57         for(int i=0;i<arr.length;i++)
    58         {
    59             sop(arr[i]);
    60         }
    61         
    62         //获得子串
    63         String ss="woshine";
    64         sop(ss.substring(2));//从指定位置开始到结尾,如果index不存在,会出现越界异常
    65         sop(ss.substring(2,4));//包含头,不包含尾
    66         
    67         /*转换:String toUpperCase();
    68          *         String toLowerCase();
    69          * 字符串去除两端的空格:String trim();
    70          * 字符串比较大型: String compareTo();
    71          */
    72         String b="  hello  ";
    73         String c="  adf";
    74         sop(b.toUpperCase());
    75         sop(b.toLowerCase());
    76         sop(b.trim());
    77         sop(b.compareTo(c)); //以ASCII值比较
    78     }
    79     public static void sop(Object obj)
    80     {
    81         System.out.println(obj);
    82     }
    83 }

    3、字符串的组成原理就是通过StringBuffer类来实现的。StringBuffer是一个容器(在容器中可以添加任何东西,但容器只有一个),一个字符串缓冲区,具有增删改查的特性,不能被继承,长度是可变的,可以操作多个数据类型,最终会通过toString方法变成字符串。

     1 package pack;
     2 //StringBuffer类
     3 public class Test
     4 {
     5     public static void main(String[] args) 
     6     {
     7         //存储:append();方法将字符串放入缓冲区末尾
     8         //存储:insert();方法可以将字符插入指定的位置处
     9         //删除:StringBuffer delete(start,end):删除缓冲区中的数据,包含start,不包含end
    10         //删除:s.deleteCharAt(index);
    11         //清空缓冲区:s=new StringBuffer();重新在定义
    12         //情况缓冲区:s.delete(0,arr.length());
    13         //获取:char charAt(index);int inexOf(String str);int lastIndexOf(String str);int length();
    14         //        String subString(int start,int end);
    15         //修改:StringBuffer replace(start,end,str);void setCharAt(index,'char');
    16         //反转:StringBuffer reverse();
    17         //getChars();将字符数组中指定位置的字符存到一个字符数组中
    18         StringBuffer s=new StringBuffer();
    19         s.append("abcd").append("eeee");
    20         s.insert(2, "bbbb");
    21         sop(s);
    22         sop(s.delete(0, 1));
    23         sop(s.deleteCharAt(0));
    24     }
    25     public static void sop(Object obj)
    26     {
    27         System.out.println(obj);
    28     }
    29 }

    4、StringBuilder是StringBuffer的替代方案。前者是1.5版本后出现的,是线程不同步的,后者是线程同步的。多个线程,建议使用StringBuffer。StringBuilder的效率高,建议使用它开发。一般升级的三个因素是:安全性、代码简洁性、提高效率。

    5、基本数据类型和引用数据类型:byte,int,short,long,boolean,float,double,char和Byte,Integer,Short,Long,Boolean,Float,Double,Character。引用类型的最多用处是基本数据类型和字符串之间的转换。

     1 package pack;
     2 //基本数据类型的引用类型
     3 public class Test
     4 {
     5     public static void main(String[] args) 
     6     {        
     7         sop(Integer.MAX_VALUE);
     8         //基本数据类型转字符串的两种方法
     9         //基本数据类型+""或者基本数据类型.toString(基本数据类型值);
    10         
    11         //字符串转换成基本数据类型
    12         //基本数据类型  变量=基本数据类型.parse基本数据类型(String);
    13         //parseInt
    14         
    15         //十进制转化为其它进制
    16         //toBinaryString();toHexString();toOctalString();
    17         //其它进制转化为十进制
    18         //parseInt(进制数,进制);
    19         
    20         int num=Integer.parseInt("233");
    21         sop(num+4);
    22         boolean b=Boolean.parseBoolean("true");
    23         sop(b);
    24         
    25         //JDK1.5版本以后出现的新特性
    26         Integer x1=null;//新特性中x不可以为空,所以需要判断
    27         Integer x=2;  //x是引用数据类型,右边是对象。这叫自动装箱,右边等价于new Integer(4);
    28         x=x+2;  //右边的x+2中的x进行了自动的拆箱动作,从对象变成了int类型,和2进行加法运算,然后装箱赋给x
    29         
    30         Integer m=23;
    31         Integer n=23;
    32         sop(m==n);        //结果为false
    33         Integer p=128;
    34         Integer q=128;
    35         sop(p==q);        //结果为true,因为在新特性中p和q指向了同一个Integer对象,但数值在byte类型范围内时就不再开辟新空间
    36         
    37     }
    38     public static void sop(Object obj)
    39     {
    40         System.out.println(obj);
    41     }
    42 }
  • 相关阅读:
    欧拉回路 定理
    UESTC 1087 【二分查找】
    POJ 3159 【朴素的差分约束】
    ZOJ 1232 【灵活运用FLOYD】 【图DP】
    POJ 3013 【需要一点点思维...】【乘法分配率】
    POJ 2502 【思维是朴素的最短路 卡输入和建图】
    POJ 2240 【这题貌似可以直接FLOYD 屌丝用SPFA通过枚举找正权值环 顺便学了下map】
    POJ 1860【求解是否存在权值为正的环 屌丝做的第一道权值需要计算的题 想喊一声SPFA万岁】
    POJ 1797 【一种叫做最大生成树的很有趣的贪心】【也可以用dij的变形思想~】
    js 实现slider封装
  • 原文地址:https://www.cnblogs.com/joeshine/p/4415291.html
Copyright © 2011-2022 走看看