黑马程序员——java基础—String类和StringBuffer类

最新推荐文章于 2020-08-03 16:17:58 发布

Cathy_ndi杯中有羽￥雨

最新推荐文章于 2020-08-03 16:17:58 发布

阅读量705

点赞数

本文链接：https://blog.csdn.net/Cathy_ndi/article/details/47347747

版权

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

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

String类的概述和使用：

(1)多个字符组成的一串数据。

其实它可以和字符数组进行相互转换。

(2)构造方法：

A:publicString() 无参构造

B:publicString(byte[] bytes) 把字节数组转成字符串

C:publicString(byte[] bytes,int offset,int length) 把字节数组的一部分转成字符串

D:publicString(char[] value) 把字符数组转成字符串

E:publicString(char[] value,int offset,int count) 把字符数组的一部分转成字符串

F:publicString(String original) 把字符串常量值转成字符串

下面的这一个虽然不是构造方法，但是结果也是一个字符串对象

G:Strings = "hello";

(3)字符串的特点

A:字符串一旦被赋值，就不能改变。

注意：这里指的是字符串的内容不能改变，而不是引用不能改变。

B:字面值作为字符串对象和通过构造方法创建对象的不同

String s = newString("hello");和String s = "hello"的区别?

1.前者造就了两个对象，堆内存一个，方法区一个。前者会创建2个对象，后者创建1个对象。

(4)字符串的面试题(看程序写结果)

A:==和equals()

Strings1 = new String("hello");

Strings2 = new String("hello");

System.out.println(s1== s2);// false

System.out.println(s1.equals(s2));//true

Strings3 = new String("hello");

Strings4 = "hello";

System.out.println(s3== s4);// false

System.out.println(s3.equals(s4));//true

Strings5 = "hello";

Strings6 = "hello";

System.out.println(s5== s6);// true

System.out.println(s5.equals(s6));//true

B:字符串的拼接

Strings1 = "hello";

Strings2 = "world";

Strings3 = "helloworld";

System.out.println(s3== s1 + s2);// false

System.out.println(s3.equals((s1+ s2)));// true

System.out.println(s3 =="hello" + "world");// false这个我们错了，应该是true

System.out.println(s3.equals("hello"+ "world"));// true

(5)字符串的功能：

A:判断功能

booleanequals(Object obj) 比较字符串的内容是否相同，区分大小写。

booleanequalsIgnoreCase(String str) 比较字符串内容是否相同，忽忽略大小写。

booleancontains(String str) 判断大串中是否包含小字符串

booleanstartsWith(String str) 判断字符串是否以某个指定的字符串开头

booleanendsWith(String str) 判断字符串是否以某个指定的字符串结尾

booleanisEmpty() 判读字符串是否为空

注意：字符串为空和字符串对象为空。

String s =” ”

String s= null;

B:获取功能

int length() 获取字符串的长度

charcharAt(int index) 获取指定索引位置的字符

intindexOf(int ch) 返回指定字符在此字符串中第一次出现的索引。

intindexOf(String str) 返回指定字符串在此字符串第一次出现的索引。

intindexOf(int ch,int fromIndex) 返回指定在此字符中从指定位置后第一次出现处的索引。

intindexOf(String str,int fromIndex) 返回指定在此字符串中从指定位置后第一次出现处的索引。

Stringsubstring(int start) 从指定位置开始截取字符串，默认到末尾（包左不包右）

Stringsubstring(int start,int end) 从指定位置开始到指定位置结束截取字符串。（包左不包右）

C:转换功能

byte[]getBytes() 把字符串转换为字节数组。

char[]toCharArray() 把字符串转换为字符数组。

staticString valueOf(char[] chs) 把字符数组转成字符串。

staticString valueOf(int i) 把int类型的数据转换成字符串。

注意：String类的valuueof( )方法可以把任意类型的数据转成字符串。

StringtoLowerCase() 把字符串转成小写。

StringtoUpperCase() 把字符串转成大写。

Stringconcat(String str) 把字符串拼接。

D:其他功能

a:替换功能

Stringreplace(char old,char new) 替换

Stringreplace(String old,String new) 替换字符串。

b:去空格功能

Stringtrim() 去除字符串两空格。

c:按字典比较功能

intcompareTo(String str) 按字典顺序比较两个字符串。

intcompareToIgnoreCase(String str) 按字典顺序忽略大小写比较字符串。

(6)字符串的案例

A:模拟用户登录

String username="adim";
      String password="1234";
     
//    for(int x=1;x<6;x++){
//       System.out.println(x);
//    }
      for(int x=0;x<3;x++){
      Scanner sc= new Scanner(System.in);
      System.out.println("请输入用户名：");
      System.out.println("----------------");
      String username1= sc.nextLine();
      System.out.println("请输入密码：");
      String  password1=sc.nextLine();
     
      if(username.equals(username1) &&password.equals(password1)){
         System.out.println("登陆成功，");
         numberguess.start();
        
        
         break;
      }else  {
         if(0==(2-x)){
            System.out.println("账号被锁定，请联系班长");
         }else{
         System.out.println("登陆失败，你还有"+(2-x)+"机会");
      }
        
     
  
      }

B:字符串遍历

两种思路：1. sr.length()和sr.charAt（）

2.知道其字符串的长度，定义相长的数组，sr. char[]toCharArray() 把字符串转换为字符数组，然后遍历其数组。

C:根据键盘录入，判断其中字符串的大写，小写，数字的分别个数。

 Scanner sc =new Scanner(System.in);
     String  sr = sc.nextLine();
      int small=0;
      int big=0;
      int number=0;
      //遍历出每一个字符串；
      for(int x=0;x<sr.length();x++){
         char cha =sr.charAt(x);
        System.out.print(cha);
     
      //比较每有一个字符的大小写；
      if(cha>='0' && cha<='9'){
        number++;
      }else if(cha>='a' && cha<='z'){
        small++;
      }else if(cha>='A' &&   cha<='z')
      big++;
    
     System.out.println(number);
     System.out.println(big);
     System.out.println(small);

D:把字符串的首字母转成大写，其他小写

String s = "helloWORLD";
 
      // 先获取第一个字符
      String s1 = s.substring(0, 1);
      // 获取除了第一个字符以外的字符
      String s2 = s.substring(1);
      // 把A转成大写
      String s3 = s1.toUpperCase();
      // 把B转成小写
      String s4 = s2.toLowerCase();
      // C拼接D
      String s5 = s3.concat(s4);
      System.out.println(s5);
 
      // 优化后的代码
      // 链式编程
      String result = s.substring(0,1).toUpperCase()
            .concat(s.substring(1).toLowerCase());
      System.out.println(result);

E:把int数组拼接成一个指定格式的字符串

int []  number={1, 2, 5};
      //定义一个祖父串；
      String sr="";
      String s=new String("[");
      //遍历数组；
      for(int x=0;x<number.length;x++){
         if(x==number.length-1){
              s+=number[x]+"]";
            System.out.println(number[x]+"]");
         }else {
            System.out.println(number[x]+","+"");
            s+=number[x]+","+""+"jjjjj";
            System.out.println(s);
         }
      }
     
         System.out.println(s);

F:字符串反转

/ 键盘录入一个字符串
      Scanner sc = newScanner(System.in);
      System.out.println("请输入一个字符串：");
      String line = sc.nextLine();
 
      /*
      // 定义一个新字符串
      String result = "";
 
      // 把字符串转成字符数组
      char[] chs = line.toCharArray();
 
      // 倒着遍历字符串，得到每一个字符
      for (int x = chs.length - 1; x>= 0; x--) {
         // 用新字符串把每一个字符拼接起来
         result += chs[x];
      }
 
      // 输出新串
      System.out.println("反转后的结果是：" + result);
      */
 
      // 改进为功能实现
      String s = myReverse(line);
      System.out.println("实现功能后的结果是：" + s);
   }
 
   /*
    * 两个明确：返回值类型：String参数列表：String
    */
   public static String myReverse(Strings) {
      // 定义一个新字符串
      String result = "";
 
      // 把字符串转成字符数组
      char[] chs = s.toCharArray();
 
      // 倒着遍历字符串，得到每一个字符
      for (int x = chs.length - 1; x >= 0; x--) {
         // 用新字符串把每一个字符拼接起来
         result += chs[x];
      }
      return result;
   }

G:统计大串中小串出现的次数

public static void main(String[] args) {
      // 定义大串
      String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
      // 定义小串
      String minString = "java";
 
      // 写功能实现
      int count =getCount(maxString,minString);
      System.out.println("Java在大串中出现了：" + count +"次");
   }
 
   /*
    * 两个明确：返回值类型：int参数列表：两个字符串
    */
   public static int getCount(String maxString,StringminString) {
      // 定义一个统计变量，初始化值是0
      int count = 0;
 
      /*
      // 先在大串中查找一次小串第一次出现的位置
      int index =maxString.indexOf(minString);
      // 索引不是-1，说明存在，统计变量++
      while (index != -1) {
         count++;
         // 把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回一个新的字符串，并把该字符串的值重新赋值给大串
         // int startIndex = index +minString.length();
         // maxString =maxString.substring(startIndex);
         maxString = maxString.substring(index +minString.length());
         // 继续查
         index = maxString.indexOf(minString);
      }
      */
     
      int index;
      //先查，赋值，判断
      while((index=maxString.indexOf(minString))!=-1){
         count++;
         maxString = maxString.substring(index +minString.length());
      }
 
      return count;
   }

2:StringBuffer

(1)StringBuffer概述：

用字符串做拼接，每次拼接，都会构建一个新的String对象，既耗时并且也耗内存，而这种拼接操作又是比较常见的，为了解决这个问题，Java就提供了

一个字符串缓冲区类。StringBuffer供我们使用。

StringBuffer: 线层安全的可变字符串。

StringBuffer 和String 的区别？

前者长度和内容可变，后者不可变。

如果使用前者做字符串的拼接，不会浪费太多的资源。

(2)StringBuffer的构造方法

A:StringBuffer() 构造一个其中不带字符的字符串缓冲区，其初始容量为16字符。

B:StringBuffer(int capacity) 指定容量的字符串缓冲区对象。

C:StringBuffer(Stringstr) 指定字符串内容的字符串缓冲区对象。

DStringBuffer（CharSequence seq）

StringBuffer的方法:

public int capacity() 返回当前容量。（理论值）

Pubic int length（）：放回长度（字符数）。实际值

(3)StringBuffer的常见功能：

A:添加功能

PublicStringBuffer append(Xxx xxx):可以把任意类型添加到字符串缓冲区里面。

StringBuffer sb = new StringBuffer（）//创建了一个字符串缓冲区。

StringBuffer sb2 = sb.append（“hello”）

Sb == sb2 //true

PublicStringBffer insert(int offset, String str): 在指定位置把任意类型的数据插入到字符串缓冲区里面。

B:删除功能

Public StringBuffer deleteCharAt(int index) : 删除指定位置的字符，并返回返回本身。

Public StringBuffer delete(int start ,int end) ：删除指定位置开始指定位置结束的内容，并返回本身。（包左不包右）

删除所有数据： sb.delete（0，sb.length()）

C:替换功能

PublicStringBuffer replace（int start，int end，string str）：从Start开始到end用Str替换。

D:反转功能

PublicStringBuffer reverse（）字符串反转。

E:截取功能(注意这个返回值)

返回值类型是String类型，本身没有发生改变。

Public String substring（int start）：

Public String substring（int Start ，int end）：

(4)StringBuffer的练习(做一遍)

A:String和StringBuffer相互转换

String– StringBuffer

1. 通过构造方法

StringBuffer sb = new StringBuffer(s);

2. 通过append（）方法

<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">              StringBuffer-- String</span>

1.通过构造方法 String str = new String(buffer);

2.toString()方法

B:字符串的拼接

public static String arrayToString(int [] arr){
      StringBuffer sb = new StringBuffer();
     
      sb.append("[");
      for(int x=0; x < arr.length;x++){
         if(x==arr.length-1){
            sb.append(arr[x]);
         }else{
            sb.append(arr[x]);
            sb.append(", ");
         }
      }
      sb.append("]");
     
     
     
      return sb.toString();
   }

C:把字符串反转

public static String myReverse(String s){
      String result ="";
     
      char[]  chs= s.toCharArray();
      for(int x = chs.length - 1; x>= 0; x--){
         //char ch = chs[x]
         //result += ch;
         result += chs[x];
      }
      return result;
   }
   public static String myReverse2(String s){
//    StringBuffer sb = new StringBuffer();
//    sb.append(s);
//    System.out.println(sb);
//          StringBuffer      sb3=sb.reverse();
//                 System.out.println(sb3);
//                 System.out.println("-----------");
//     StringBuffer sb2 = new StringBuffer(s);
//     sb2.reverse();
//
//    return sb.toString();
     
      return new StringBuffer(s).reverse().toString();
     
   }

D:判断一个字符串是否对称

public static boolean issame(String s){
     return newStringBuffer(s).reverse().toString().equals(s);
  }
 
//  public static boolean isSame2(String s){
//
// 
//   //把字符串转成字符数组
//   char[] chs= s.toCharArray();
//  
//   for(intstart = 0, end = chs.length -1; start <= end; start++, end-- ){
//    if(chs[start]!= chs [end]){
//      return  false; 
//    }
//  }
//   return  true;
// 
//  }
  public static boolean isSame(String s){
     boolean flag = true;
 
     //把字符串转成字符数组
     char[] chs = s.toCharArray();
    
     for(int start = 0, end = chs.length -1; start<= end; start++, end-- ){
      if(chs[start] != chs [end]){
          flag = false;
          break;
      }
  }
     return  true;
 
  }
}

(5)面试题

小细节：

StringBuffer：同步的，数据安全，效率低。

StringBuilder：不同步的，数据不安全，效率高。

A:String,StringBuffer,StringBuilder的区别

1. String是内容不可变，而StringBuffer, StringBuilder都是内容可变的。

2. 看上面。

B:StringBuffer和数组的区别?

1. 二者都可以看出是一个容器，装其他的数据。

2. 然而StringBuffer的数据最终是一个字符串数据、

而数组可以放置多种数据，但必须是同一种数据类型。

(6)注意的问题：

String作为形式参数，StringBuffer作为形式参数。

形式参数：

* 基本类型：形式参数的改变不影响实际参数

* 引用类型：形式参数的改变直接影响实际参数

* 注意：

* String作为参数传递，效果和基本类型作为参数传递是一样的。

public class StringBufferDemo {
   public static void main(String[] args) {
      String s1 = "hello";
      String s2 = "world";
      System.out.println(s1 + "---" + s2);// hello---world
      change(s1, s2);
      System.out.println(s1 + "---" + s2);// hello---world
 
      StringBuffer sb1 = new StringBuffer("hello");
      StringBuffer sb2 = new StringBuffer("world");
      System.out.println(sb1 + "---" + sb2);// hello---world
      change(sb1, sb2);
      System.out.println(sb1 + "---" + sb2);// hello---worldworld
 
   }
 
   public static void change(StringBuffer sb1, StringBuffer sb2) {
      sb1 = sb2;
      sb2.append(sb1);
   }
 
   public static void change(String s1, String s2) {
      s1 = s2;
      s2 = s1 + s2;
   }

Cathy_ndi杯中有羽￥雨

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员——java基础—String类和StringBuffer类

String类的概述和使用： (1)多个字符组成的一串数据。其实它可以和字符数组进行相互转换。 (2)构造方法： A:publicString() 无参构造 B:publicString(byte[] bytes) 把字节数组转成字符串 C:
复制链接

扫一扫