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

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 为基本数 据类型提供了所对应的类，这个类称为包装类。

基本数据类型	包装类
byte	Byte
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

【位于 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 )：判断两个字符串的内容是否一样

【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搜索相关方法

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修改相关方法

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 永远效率是最低的