Random随机数类、包装类、String类、StringBuffer和StringBuilder类

我就是我 2022-12-02 12:21 235阅读 0赞

# 1、Random随机数类 #

## 1.1、什么是Random类 ##

此类的对象用于生产伪随机数

## 1.2、构造方法 ##

Random() 创建一个新的随机数生成器，默认使用当前时间的毫秒值作为种子。  
Random(long seed) 使用单个 long 种子创建一个新的随机数生成器。  
【如果两个随机数的对象使用相同的种子，那么这两个随机数对象调用相同的方法时，那么 生成的随机数也一样】

## 1.3、普通方法 ##

public int nextInt(int n)：返回一个伪随机数，范围在 0(包括)和指定值 n(不包括)之间的 int 值。

package com.bdit; 
     
    import java.util.Random; 
     
    /* 
    Random 随机数  
    */ 
    public class Test3 {
             
    	public static void main(String[] args) {
         
    	  	//创建对象         
    	  	Random rd1=new Random();         
    	  	System.out.println(rd1.nextInt());         
    	  	System.out.println(rd1.nextInt(10));         
    	  	System.out.println(rd1.nextDouble());         
    	  	System.out.println(rd1.nextBoolean()); 
     
            //指定种子参数，创建 Random 对象         
            Random rd2=new Random(565789L);         
            System.out.println(rd2.nextInt());         
            Random rd3=new Random(565789L);         
            System.out.println(rd3.nextInt(10));     
         } 
     }

## 1.4、猜数字小游戏 ##

游戏开始，随机生成一个 1-100 之间的整数，玩家猜测一个数字，与随机生成的对比，系统 提示大或者小，直到玩家猜中，游戏结束

package com.bdit; 
     
    import java.util.Random; 
    import java.util.Scanner; 
     
    /**  
    * Random 随机数练习  
    * 游戏开始，随机生成一个 1-100 之间的整数，玩家猜测一个数字，与随机生成的对比，
    * 系统提示大或者小，直到玩家猜中，游戏结束  
    * */ 
    public class Test3 {
             
    	public static void main(String[] args) {
                 
    		Random rd1=new Random();         
    		int num=rd1.nextInt(100)+1;         
    		Scanner input=new Scanner(System.in);         
    		while(true){
                     
    			System.out.println("请输入要猜的整数：");             
    			int temp=input.nextInt();             
    			if(temp>num){
                         
    				System.out.println("大了");             
    			}else if(temp<num){
                         
    				System.out.println("小了")
    			}else if(temp==num){
                         
    				System.out.println("恭喜，猜中了");                 
    				break;             
    			}else{
                         
    				System.out.println("输入有误");             
    			}         
    		}     
    	} 
    }

## 1.5、随机生成字母 ##

随机生成 5 个不重复的小写字母，并按照字母顺序排列输出。

package com.bdit; 
     
    import java.util.Arrays; 
    import java.util.Random; 
     
    /* 
    随机生成 5 个不重复的小写字母，并按照字母顺序排列输出 
    1、ASCII  a=97   英文字母 26 个 
    */ 
    public class Test4 {
             
    	public static void main(String[] args) {
                 
    		Random random=new Random(); 
     
            char[]c=new char[5]; 
    
            for(int i=0;i<c.length;i++){
                     
            	int temp=random.nextInt(26)+97; 
                char ctemp=(char)temp;             
                if(!isValidator(ctemp,c)){
        //条件成立，就往数组 C 中存储数据                 
                	c[i]=ctemp;             
                }else{
        //当数组中已存在，就不再存储，而且--i                 
                	--i;                 
                	continue;             
                }         
           }
            Arrays.sort(c);//对数组中的元素进行升序排列 
            for(int i=0;i<c.length;i++){
                     
            	System.out.print(c[i]+" ");         
            }     
      } 
      
    /*
    @param temp 表示当前循环生成的字符       
    @param c 表示存储字符的数组      
    @return      
    */ 
     	public static boolean isValidator(char temp,char[]c){
                 
     		boolean flag=false;         
     		for(int i=0;i<c.length;i++){
                     
     			if(temp==c[i]){
                         
     				flag=true;                 
     				break;             
     			}         
     		}         
     		return flag;     
     	} 
    }

## 2、包装类 ##

为了丰富基本数据类型之间的各种操作，以及更加符合面向对象编程的思想，java 为基本数 据类型提供了所对应的类，这个类称为包装类。

<table> 
 <thead> 
  <tr> 
   <th>基本数据类型</th> 
   <th>包装类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>Byte</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>Character</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>Integer</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>Boolean</td> 
  </tr> 
 </tbody> 
</table>

【位于 java.lang 包下的所有的类，无需导包，可以直接使用】  
为了方便基本数据类型和包装类之间的相互转换，从 JDK5.0 开始，提供了装箱和拆箱。

装箱：就是把基本数据类型可以直接赋值给所对应的包装类对象

拆箱：可以把一个包装类对象直接赋值给所对应的基本数据类型

装箱和拆箱是自动完成的。

package com.bdit; 
     
    /*
    包装类  
    */ 
    public class Test5 {
             
    	public static void main(String[] args) {
                 
    		Integer integer=new Integer(10);         
    		System.out.println(integer);         
    		//可以利用该构造方法，完成字符串转换为 int 类型的效果         
    		//如果接受字符串作为参数，那么字符串只能是整数，不能出现数字以外的任何 字符         
    		Integer integer1=new Integer("123");         
    		System.out.println(integer1+1); 
     
            //针对构造方法的替代者是 valueOf 方法，static 修饰的方法，只需要通过 类名. 方法名(参数列表);调用   
            Integer integer2=Integer.valueOf(150);         
            Integer integer3=Integer.valueOf("200");         
            System.out.println(integer2+10);         
            System.out.println(integer3+10); 
    
     		System.out.println(integer2.byteValue());         
     		System.out.println(integer2.floatValue());         
     		System.out.println(integer2.doubleValue());         
     		System.out.println(integer2.longValue());         
     		System.out.println(integer2.shortValue());         
     		System.out.println(integer2.intValue()); 
     		System.out.println("字符串转换为 int 类型--->"+(Integer.parseInt("99")+1)); 
    
     		//装箱：就是把一个基本数据类型变量，直接赋值给所对应的包装类对象         
     		int n1=20;         
     		Integer it1=n1;         
     		System.out.println(it1); 
     		//拆箱：把一个包装类的对象，可以直接赋值给所对应的基本数据类型变量         
     		Double d1=Double.valueOf(99.65);         
     		double d2=d1;         
     		System.out.println(d2); 
     
            //字符类型 
            Character c1=Character.valueOf('a');         
            System.out.println("是否为数字："+Character.isDigit('5'));         
            System.out.println("是否为字母："+Character.isLetter('&'));         
            System.out.println("是否为小写字母："+Character.isLowerCase('z'));         
            System.out.println("是否为大写字母："+Character.isUpperCase('Z'));
    
      		//boolean 类型         
      		Boolean b1=Boolean.valueOf("true");         
      		System.out.println(b1); 
      	}
    }

# 3、String 类 #

### 3.1、String类概述 ###

java.lang.String 类代表字符串。 Java 程序中所有的字符串文字都可以被看作是实现此类的实 例(对象)，也就是说凡是用双引号引起来的内容，都是一个字符串 String 类的对象。

特点：  
字符串是一个不可变的类，也就是字符串的值在创建后不能修改。  
此处说的不可变指的是值本身不能更改，但是重新给字符串对象赋值，会 改变字符串对象指向的内存地址。

字符串池的原理来实现以上的过程：字符串池是一个专门用来存储字符串 值得空间，所有创建的字符串对象在赋值时，都需要和字符串池中已有的 内容进行对比，如果内容已经存在，直接引用已存在的值得内存地址；如 果不存在，才会把新的内容放到字符串池中。

String 的构造方法 :  
1.默认创建一个字符串对象时，可以直接把内容使用双引号引起来即可。  
例如： String name=”张三”;  
2.可以使用 String 的构造方法来创建对象。  
例如: String name=new String(“李四”);但是，该方式会创建两个对象，原 始对象是构造方法中的字符串参数，name 其实就是一个对象副本

char[]chars={
        'a','b','c','d'};         
    		String str1=new String(chars);         
    		System.out.println(str1); 
     
            byte[]bytes={
        48,49,50,51};         
            String str2=new String(bytes);         
            System.out.println(str2);

### 3.2、String类中比较方法 ###

==:比较的是两个字符串对象指向的内存地址是否一样  
public boolean equals(Object str )：判断两个字符串的内容是否一样  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZsdWNreV9sb25n_size_16_color_FFFFFF_t_70_pic_center]  
【compareTo()方法比较两个字符串，首先比较两个字符串的首字母是否一致，如果不一致 就直接使用它们的 ASCII 码值相减作为最终的结果；如果相同，则比较第二个字符，以此类 推。如果有一方已经比较完毕，这种情况下，直接把两个字符串的长度相减作为最终的结果；】

package com.bdit; 
    /* 
    字符串比较  
    */ 
    public class Test3 {
             
    	public static void main(String[] args) {
                 
    		String s1="abc";         
    		String s2="ABC";         
    		System.out.println(s1.equals(s2));//false         
    		System.out.println(s1.equalsIgnoreCase(s2));//true         
    		String s3="abcd";         
    		System.out.println(s1.compareTo(s3)); 
     
            System.out.println("zhangsan".startsWith("zhang"));         
            System.out.println("wangwu".endsWith("u"));     
        } 
    }

### 3.3、String搜索相关方法 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZsdWNreV9sb25n_size_16_color_FFFFFF_t_70_pic_center 1]

package com.bdit; 
    /* 
    字符串搜索相关方法  
    */ 
    public class Test4 {
             
    	public static void main(String[] args) {
                 
    		String str="zhangsan";         
    		System.out.println(str.indexOf('a'));         
    		System.out.println(str.indexOf('a',3));         
    		System.out.println(str.indexOf("an"));         
    		System.out.println(str.indexOf("an",4)); 
     
            System.out.println(str.lastIndexOf('a')); 
     
            System.out.println(str.charAt(0)); 
     
       } 
    }

### 3.4、String修改相关方法 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZsdWNreV9sb25n_size_16_color_FFFFFF_t_70_pic_center 2]

### 3.5、String长度 ###

public int length()：返回此字符串的长度

package com.bdit; 
    /* 
    字符串修改相关方法  
    */ 
    public class Test5 {
             
    	public static void main(String[] args) {
                 
    		System.out.println("zhangsan".substring(1)); 
     
            System.out.println("zhangsan".substring(0,5)); 
     
            System.out.println("zhang".concat("san")); 
     
            System.out.println("zhangsan".replace('a','w'));         
            System.out.println("      zhangsan      ");         
            System.out.println("      zhangsan    ".trim());         
            System.out.println("bdit".toUpperCase());         
            System.out.println("BDIT".toLowerCase()); 
     
            System.out.println("zhangsan".length());     
       } 
    }

### 3.6、字符串转换和分割相关的方法 ###

public char\[\] toCharArray()：将此字符串转换为新的字符数组  
public String\[\] split(String regex)：将此字符串按照给定的规则进行字符串的拆分

package com.bdit; 
     
    public class Test6 {
             
    	public static void main(String[] args) {
                 
    		//把字符串转换成字符数组         
    		char[]c="zhangsan".toCharArray();         
    		for(char a:c){
                     
    			System.out.println(a);         
    		}         
    		//字符串拆分         
    		String str="welcome to shandong liaocheng";         
    		String[]strs=str.split(" ");         
    		for(String s:strs){
                     
    			System.out.println(s);         
    		}     
    	} 
    }

# 4、StringBuffer 和 StringBuilder 类 #

### 4.1、概括 ###

由于 String 类的对象内容是不可改变的，所以每当进行字符串操作后，总会在内存中创建一 个新的对象，既耗时又浪费内存空间。为了解决这一问题，java中提供了java.lang.StringBuffer 和java.lang.StringBuilder 类，这两个类又称为可变字符序列，他是一个类似于 String 的字符 串缓冲区，通过某些方法调用可以改变该对象的长度和内容。

StringBuffer 和 StringBuilder 是个字符串的缓冲区，即它是一个容器，容器中可以装很多字 符串，并且能够对其中的字符串进行各种操作。 它们的内部都拥有一个数组用来存放字符串内容，进行字符串操作时，直接在数组中操作， 它们会自动维护数组的扩容。

### 4.2、StringBuffer 构造方法 ###

●public StringBuffer() :构造一个没有字符的字符串缓冲区，初始容量为 16 个字符。  
●public StringBuffer(String str) :构造一个初始化为指定字符串内容的字符串缓冲区。

### 4.3、StringBuilder 构造方法 ###

●public StringBuilder() :构造一个没有字符的字符串缓冲区，初始容量为16个字符。 ●public StringBuilder(String str) :构造一个初始化为指定字符串内容的字符串缓冲区。

### 4.4、两者的区别 ###

【StringBuffer 和 StringBuilder 两者的操作几乎是一模一样的，只不过 StringBuffer 是线程安 全(同步)的，StringBuilder 是线程不安全(同步)。】

如果不考虑，线程问题，那么 StringBuilder 的效率是最高的，String 永远效率是最低的

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZsdWNreV9sb25n_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/4ac5031952be48ff973b6fe4d35fd64a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZsdWNreV9sb25n_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/41ccf39e184f44a1a01ef06282663767.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZsdWNreV9sb25n_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/f250daf9209d4b889754b18ca94b79e0.png