黑马程序员-Java API-day13-CSDN博客

本文链接：https://blog.csdn.net/yinbolove576/article/details/10276273

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

1、String类

1.字符串是一个特殊的对象

2.字符串一旦初始化就不可以被改变。

public finalclass String extends Object，发现final说明该String没有子类，也不能复写

3.字符串在内存中有一个常量池，也就是一个数组，专门用于存储字符串数组也有长度，但是它的length后没有括号；字符串也有长度，但是它是通过方法完成的，所以带括号。

class StringDemo
{
       public static void main(String[] args)
       {
              String s1 = "abc";//s1是一个类类型变量，"abc"是一个对象。
                                          //字符串最大特点：一旦被初始化就不可以被改变。
              String s2 = new String("abc");
              /*
              s1和s2有什么区别？
              s1在内存中有一个对象，s2在内存中有两个对象。
              */
              System.out.println(s1==s2);//false
              System.out.println(s1.equals(s2));//true
              //String类复写了Object类中的equals方法，该方法用于判断字符串是否相同。
       }
}

2、String类常见功能

String类使用与描述字符串事物，那么它就提供了多个方法对字符串进行操作。

常见的操作有哪些？“abcd”

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在字符串中出现的位置。

2.判断

2.1字符串中是否包含某一个字串booleancontains(str);

特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1，表示该字符串str不在字符串中存在，所以，也可以用于对指定判断是否包含。if(str.indexOf("aa")!=-1)

而且该方法既可以判断，又可以获取出现的位置。

2.2字符中是否有内容

boolean isEmpty():原理就是判断长度是否为0

2.3字符串是否是以指定内容开头

boolean startsWith(str);

2.4字符串是否是以自定内容结尾

boolean endsWith(str);

2.5判断字符串内容是否相同，复写了Object类中的equals方法。

boolean equals(str);

2.6判断内容是否相同，并忽略大小写。

boolean equanlIgnoreCase();

3.转换

3.1将字符数组转成字符串

构造函数： String(char[])

String(char[],offset,count):将字符数组中的一部分转成字符串。

静态方法： static StringcopyValueOf(char[]);

staticString copyValueOf(char[],data,int offset,int count);

staticString valueOf(char[]);

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)

3+"";-->String.valueOf(3);

特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

4.替换

Stringreplace(char oldchar,char newchar);

StringreplaceAll(String regex,String replacement)

StringreplaceFirst(String regex,String replacement)

5.切割

String[]split(regex);

6.子串，获取字符串中的一部分

Stringsubstring(begin);

Stringsubstring(begin,end);

7.转换、去除空格、比较。

7.1将字符串转成大写或者小写。

String toUpperCase();

String toLowerCase();

7.2将字符串两端的多个空格去除

String trim();

7.3对两个字符串进行自然顺序的比较。

int compareTo(String);//如果参数字符串等于此字符串，则返回值为0，如果此字符串按自然顺序小于字符串参数，则返回一个小于0的值，否则返回大于0的值。

class StringMethodDemo
{
       public static void method_7()
       {
              String s = "   Hello Java";
 
              sop(s.toUpperCase());
              sop(s.toLowerCase());
              sop(s.trim());
       }
       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 s1 =s.replace("java","world");
 
              sop("s ="+s);
              sop("s1 ="+s1);
       }
       public static void method_trans()
       {
              char[] arr = {'a','b','c','d','e','f'};
              String s = new String(arr,1,3);
              sop("s ="+s);
 
              String s1 = "zxcvbnm";
              char[] chs = s1.toCharArray();
              for(int x=0; x<chs.length; x++)
              {
                     sop("chs="+chs[x]);
              }
       }
       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 = "abcdefeakfp";
              //长度
              sop(str.length());
              //根据索引获取字符：
              sop(str.charAt(4));//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException    
              //根据字符获取索引
              sop(str.indexOf('a',3));//如果没有找到，则返回-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);
       }
}

字符串练习

1.模拟一个trim方法，去除字符串两端的空格。

2.将一个字符串进行反转。将字符串中指定部分进行反转，”abcdefg”;”abfedcg”

3.获取一个字符串在另一个字符串中出现的次数。

4.获取两个字符串中最大相同字串。第一个动作，将短的那个船进行场地一次递减的字串打印。

class StringMethodDemo
{
       public static void method_7()
       {
              String s = "   Hello Java";
 
              sop(s.toUpperCase());
              sop(s.toLowerCase());
              sop(s.trim());
       }
       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 s1 =s.replace("java","world");
 
              sop("s ="+s);
              sop("s1 ="+s1);
       }
       public static void method_trans()
       {
              char[] arr = {'a','b','c','d','e','f'};
              String s = new String(arr,1,3);
              sop("s ="+s);
 
              String s1 = "zxcvbnm";
              char[] chs = s1.toCharArray();
              for(int x=0; x<chs.length; x++)
              {
                     sop("chs="+chs[x]);
              }
       }
       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 = "abcdefeakfp";
              //长度
              sop(str.length());
              //根据索引获取字符：
              sop(str.charAt(4));//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException    
              //根据字符获取索引
              sop(str.indexOf('a',3));//如果没有找到，则返回-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);
       }
}

3.获取一个字符串在领一个字符串中出现的次数。

"abkkcdkkdfkkskk"

class StringMethodDemo
{
       public static void method_7()
       {
              String s = "   Hello Java";
 
              sop(s.toUpperCase());
              sop(s.toLowerCase());
              sop(s.trim());
       }
       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 s1 =s.replace("java","world");
 
              sop("s ="+s);
              sop("s1 ="+s1);
       }
       public static void method_trans()
       {
              char[] arr = {'a','b','c','d','e','f'};
              String s = new String(arr,1,3);
              sop("s ="+s);
 
              String s1 = "zxcvbnm";
              char[] chs = s1.toCharArray();
              for(int x=0; x<chs.length; x++)
              {
                     sop("chs="+chs[x]);
              }
       }
       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 = "abcdefeakfp";
              //长度
              sop(str.length());
              //根据索引获取字符：
              sop(str.charAt(4));//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException    
              //根据字符获取索引
              sop(str.indexOf('a',3));//如果没有找到，则返回-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);
       }
}

//4.获取两个字符串中最大相同子串。

class StringTest3
{
       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<s2.length(); x++)
              {
                     for(inty=0,z=min.length()-x;z!=min.length()+1;y++,z++)//z是尾角标,-x是遍历字符串的
                     {
                            String temp = min.substring(y,z);
                            //sop(temp);
                            if(max.contains(temp))//if(s1.indexOf(temp)!=-1)
                                   return temp;
                     }
              }
              return "";
       }
       public static void main(String[] args)
       {
              String s1 ="abcwerhelloyuiodef";
              String s2 = "cvhellobnm";
 
              sop(getMaxSubString(s1,s2));
       }
       public static void sop(String str)
       {
              System.out.println(str);
       }
}

3、StringBuffer

字符串的组成原理就是通过该类实现的；

StringBuffer可以对字符串内容进行增删；

StringBuffer是一个容器；很多方法与String相同。StringBuffer是可变长度的。

StringBuffer是字符串缓冲区。

特点：

1、是一个容器,而且长度是可变化的；

2.可以直接操作多个数据类型。

3.最终会通过toString方法编程字符串。

C create U update R read D delete

1.存储

StringBufferappend();将指定数据作为参数添加到已有数据结尾处。

StringBufferinsert(index,数据):可以将数据插入到制定的index位置。

2.删除

StringBufferdelete(start,end):删除缓冲区中的数据，包含start，不包含end

StringBufferdeleteCharAt(index):删除指定位置的字符。

3.获取

charcharAt(int index)

intindexOf(String str)

intlastIndexOf(String str)

intlength()

Stringsubstring(int start,int end)

4.修改

StringBufferreplace(int start,int end,String str)

voidsetCharAt(int index,char ch)

5.反转

StringBufferreverse()

6.将缓冲区指定数据存储到指定字符数组中。

voidgetChars(int srcBegin,int srcEnd,char[] dst,int dstBegin);

代码演示：

class StringBufferDemo
{
       public static void main(String[] args)
       {
              method_get();
              //method_update();
              //method_del();
              //method_add();
       }
       public static void method_get()
       {
              StringBuilder sb = newStringBuilder("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 method_update()
       {
              StringBuffer sb = newStringBuffer("abcde");
              //sb.replace(1,4,"java");
              sb.setCharAt(2,'k');
              sop(sb.toString());
 
       }
       public static void method_del()
       {
              StringBuffer sb = newStringBuffer("abcde");
              //sb.delete(1,3);
              //清空缓冲区
              //sb.delete(0,sb.length());
              //sb.delete(2,3);
              sb.deleteCharAt(2);
              sop(sb.toString());
       }
       public static void method_add()
       {
              StringBuffer sb = new StringBuffer();
              sb.append("abc").append(true).append(34);
              sb.insert(1,"qq");
              sop(sb.toString());
       }
       public static void sop(String str)
       {
              System.out.println(str);
       }
}

4、StringBuilder

Java升级的三个特性：提高效率、简化书写、提高安全性

一个可变的字符序列。此类提供一个与StringBuffer兼容的API，但不保证同步。该类被设计用作StringBuffer的一个简易替换，用在字符缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为大多数实现中，它比StringBuffer要快。

JDK1.5版本之后出现了StringBuilder。

特点：

StringBuffer是线程同步的，

StringBuilder是线程不同步的。

将StringBuilder的实例用于多线程是不安全的，如果需要这样做，则建议使用StringBuffer

以后开发，建议使用StringBuilder

Java升级三要素:

1.提高效率；

2.简化书写；

3.提高安全性。

5、基本数据类型对象包装类

1.基本数据类型对象包装类

基本数据类型引用数据类型

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

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

(1)基本数据类型转成字符串

基本数据类型+""

基本数据类型.toString(基本数据类型值);

如：Integer.toString(34);//将34整数变成"34";

(2)字符串转成基本数据类型

静态方法

xxxa = Xxx.parseXxx(String);

inta = Integer.parseInt("123");

doubleb = Double.parseDouble("12.23");

booleanb = Boolean.parseBoolean("true");

非静态方法：

Integeri = new Integer("123");

intnum = i.intValue();

3.十进制转成其它进制

toBinaryString();

toOctalString();

toHexString();

4.其它进制转成十进制

parseInt(string,radix);

class IntegerDemo
{
       public static void main(String[] args)
       {
              //整数类型的最大值
              //sop("int max="+Integer.MAX_VALUE);
 
              //将一个字符串转成整数
              int num =Integer.parseInt("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);
       }
}

5.基本数据类型包装类新特性JDK1.5版本出现的新特性：自动拆箱、装箱

class IntegerDemo1
{
       public static void main(String[] args)
       {
              //Integer x = new Integer(4);
              Integer x = 4;//自动装箱-->new Integer(4);
                            //特别注意一点就是Integer x 的赋值不能为null,否则会出现空指针异常。
 
              x = x/*x.intValue()*/+2;//x+2:x进行自动拆箱，变成了int类型，和2进行加法运算，再将和进行装箱赋给x.
              Integer m = 128;
              Integer n = 128;
 
              sop("m==n:"+(m==n));
 
              Integer a = 127;
              Integer b = 127;
 
              sop("a==b:"+(a==b));//结果为true，因为a和b指向了同一个Integer对象。
                     //因为当数值在byte范围内时，对于新特性，如果该数值已经存在，则不会开辟新空间。
       }
      
       public static void method()
       {
              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);
       }
}

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------
详细请查看：http://edu.csdn.net