Java-------实现类（进阶）

/*	所有包装类都可将与之对应的基本数据类型作为参数
		，来构造它们的实例*/
		byte num1 = 10;
		Byte byte1 = new Byte(num1);//------------------->首字母大写
		System.out.println(byte1);

		short num2 = 100;
		Short short1 = new Short(num2);
		
		int num3 = 200;
		Integer int1 = new Integer(num3);
		
		long num4=300;
		Long Long=new Long(num4);
		
		double num5=12.4;
		Double double1=new Double(num5);
		
		char num6 = '我';
		Character cha=new Character(num6);
		
		Integer int2=new Integer("123");
		System.out.println(int2);
		
		Short short2 =new Short("122");
		System.out.println(short2);
		
		Byte byte2 = new Byte("11");
		System.out.println(byte2);
		
		Long long2 = new Long("456");
		System.out.println(long2);

不能使用第二种构造方法创建Character类的包装类对象，只能是Character charValue = new Character('x')这种形式。

2）使用包装类的valueOf()方法

a）包装类中一般包含静态的重载的valueOf()方法，它可以接收基本数据类型数据和字符串作为参数并返回包装类的对象。

b）以Integer包装类为例，valueOf()方法的定义如下表所示

c）Character类的valueOf()方法只有一个版本的定义，即valueOf(char c)，它返回一个表示指定char值的Character对象。

（2）包装类转换成基本数据类型

包装类转换成基本数据类型通常采用如下的方法：public type typeValue();

其中，type指的是基本数据类型，如byteValue()、charValue()等，相应的返回值为byte、char。

// 包装类常用方法
		//XXXValue():包装类转换成基本类型
		
		Integer int1=new Integer("100");
		System.out.println(int1);
		System.out.println("***********");
		
		int num1=int1.intValue();
		System.out.println(num1);
		
		Double double1 =new Double("10.0");
		double num2=double1.doubleValue();
		System.out.println(num2);

（3）基本类型和包装类的自动转换

1）在Java SE 5.0版本之后程序员不需要编码实现基本数据类型和包装类之间的转换，编译器会自动完成。

Integer intObject = 5; //装箱：基本数据类型转换为包装类

int intValue = intObject; //拆箱：包装类转换为基本数据类型

package deno02;

public class demo04 {

	public static void main(String[] args) {
		// 包装类和基本数据的自动转换
		//装箱----------基本----->包装类
		int num1=10;      //基本
		Integer int1 =num1;       //包装类
		//拆箱----------->包装类--->基本
		Character char1=new Character('a');
		char num2=char1;
		
		Integer int2= new Integer(10);
		int num3=10;
		//运算-----------》直接进行数学运算
		Integer int3 = new Integer(300);
		int num5 = 300;
		Integer int4 =int3+num5;  //--------->类的add
		int sum =int3+num5;         //---------->
	}
}

2）虽然Java平台提供了基本数据类型和包装类的自动转换功能。程序员在程序中也不能只使用对象，而抛弃了基本数据类型。

3）包装对象只有在基本数据类型需要用对象表示时才使用，包装类并不是用来取代基本数据类型的。

包装类把基本类型数据转换为对象
每个基本类型在java.lang包中都有一个相应的包装类
包装类的作用提供了一系列实用的方法
集合不允许存放基本数据类型数据，存放数字时，要用包装类型

3.1 Math类

（1）java.lang.Math类提供了一些基本数学运算和几何运算的方法。

（2）此类中的所有方法都是静态的。这个类是final类，因此没有子类。

（3）Math类常见方法如下：

-->static double abs(double a)：返回double值的绝对值。例如，Math.abs(-3.5)返回3.5。

//求一个数的绝对值，正数的绝对值是它本身，负数的绝对值是其相反数
System.out.println(Math.abs(100));
System.out.println(Math.abs(-100));

-->static double max(double a,double b)：返回两个double值中较大的一个。例如，Math.max(2.5,90.5);返回90.5。

    //求最大值和最小值
       System.out.println(Math.max(25, 18));
       System.out.println(Math.min(99, 33));

-->static double random()：返回一个随机的double值，该值大于等于0.0且小于1.0。

用法代码；

package deno04;

import java.util.Random;

public class RandomDemo01 {

	public static void main(String[] args) {
		//创建Random类对象
		Random random = new Random();//------------导包
		
		//获取随机数
//		int int1=random.nextInt();
//		System.out.println(int1);
		
		int int2=random.nextInt(10);//-------------->int在10 以内的随机数
		System.out.println(int2);
		System.out.println("***");
		long long1=random.nextLong();
		System.out.println(long1);

（4）随机获取一个[num1,num2)之间的整数（num2>num1）公式：
int num = (int)(Math.random()*(num2-num1)+num1);

	//求随机数
		//Math.random():返回一个[0.0,1.0)之间的double类型数据
		double random1 = Math.random();
		System.out.println(random1);
		//Math.random()*10：返回一个[0.0,10.0)之间的double类型的数据
		double random2 = Math.random()*10;
		System.out.println(random2);
		//(int)(Math.random()*10):返回一个[0,10)之间的int类型的数据
		int random3 = (int)(Math.random()*10);
		System.out.println(random3);
		//(int)(Math.random()*(num2-num1)+num1):返回一个[num1,num2)(num2>num1)之间的int类型的数据
		//随机获取一个[63,81)之间的int类型的数据
		int random4 =(int)(Math.random()*(81-63)+63);
		System.out.println(random4);

4、 String类概述

（1）在Java中，字符串被作为String类型的对象来处理。

（2）String类位于java.lang包中，默认情况下，该包被自动导入所有的程序。

（3）创建String对象的方法如下代码所示

String s = "Hello World";

String s = new String("Hello World");

（4）String类提供了许多有用的方法来操作字符串，比如获取字符串长度、对两个字符串进行比较、连接两个字符串以及提取一个字符串中的某一部分。

（5）字符串是一个字符序列，每一个字符都有自己的位置，字符串事实上也是一个字符数组，因此它的索引位置从0开始到（字符串长度-1）结束。

4、1 String类常用方法

（1）求字符串长度：length()

（2）字符串比较：equals(字符串2)

（3）忽略带小写的字符串比较：equalsIgnoreCase(字符串2)

（4）转换字符串中的英文字符为小写：toLowerCase()

（5）转换字符串中的英文字符为大写：toUpperCase()

（6）字符串的连接：concat(字符串2)

（7）字符串提取和查询

（8）字符串拆分：split(separator,limit)

-->separator是可选项，表示根据匹配指定的正则表达式来拆分此字符串。如果匹配不上，则结果数组只有一个元素，即此字符串。

-->limit可选项，该值用来限制返回数组中的元素个数。

4、2使用StringBuffer类处理字符串

（1）StringBuffer类也是Java提供的用于处理字符串的一个类，而且它是比String类更高效的存储字符串的一种引用数据类型。

（2）StringBuffer类对字符串进行连接操作时，使用StringBuffer类可以大大提高程序的执行效率。

（3）如何使用StringBuffer类

StringBuffer类位于java.util包中，是String类的增强类。StringBuffer类提供了很多方法可供使用。

StringBuffer 对象名 = new StringBuffer("字符串内容");

（4）常用的StringBuffer类方法

1）toString()方法：将StringBuffer类型的字符串转换为String类型的对象。

2）append(参数)方法：将参数连接到字符串后，可以将任何类型的值追加到字符串后。

3）insert(位置,参数)方法：将参数插入到字符串指定位置后并返回。参数值可以是包括String的任何类型。

4、3使用StringBuilder类处理字符串

（1）java.lang.StringBuilder是JDK 5.0版本新增的类，它是一个可变的字符序列。

（2）此类提供一个与StringBuffer类兼容的API，被设计用作StringBuffer类的一个简易替换，在大多数实现中，它比StringBuffer执行要快。

（3）使用StringBuilder类处理字符串的方法与StringBuffer类基本一样。

4、4 String类、StringBuffer类及StringBuilder类对比

String、StringBuffer、StringBuilder这3个类在处理字符串时有各自的特点和实用场合，具体如下：

public class StringDemo01 {

   public static void main(String[] args) {
       // 创建String类对象
       String str1 = new String("qwertyuiop");
       String str2 = "QWErtyuiop";

       //String类中包含很多方法实现不同的功能
       //char charAt(int index) 返回指定索引处的 char 值。
       char ch1 =str1.charAt(2);
       System.out.println("下标为2的字符："+ch1);

       //int length() 返回此字符串的长度。
       int length =str1.length();
       System.out.println("str1的长度："+length);

       // boolean equals(Object anObject) 将此字符串与指定的对象比较。 String类中重写了Object类中的equals()方法，比较的是两个字符串的内容是否相同
       boolean result =str1.equals(str2);
       System.out.println("str1和str2字符串内容相同："+result);
       // boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写
       System.out.println("str1和str2字符串内容相同："+str1.equalsIgnoreCase(str2));

       String str3 = "QWERT";
       String str4 = "asdfg";
       // String toLowerCase() 将此 String 中的所有字符都转换为小写
       //String toUpperCase() 将此 String 中的所有字符都转换为大写。
       String newStr3 =str3.toLowerCase();
       System.out.println(str3);
       System.out.println(newStr3);
       System.out.println(str4.toUpperCase());
       System.out.println(str4);

（1）String：字符串常量

String是不可变的对象，在每次对String类型进行改变时其实都等同于生成了一个新的String对象，然后指向新的String对象，所以经常改变内容的字符串最好不要用String类型，因为每次生成对象都会对系统性能产生影响。

（2）StringBuffer：字符串变量

StringBuffer是可变的字符串，在每次对StringBuffer对象进行改变时，会对StringBuffer对象本身进行操作，而不是生成新的对象，再改变对象引用。所以，在字符串对象经常改变的情况下，推荐使用StringBuffer类。

public class StringBufferDemo01 {

   public static void main(String[] args) {

       StringBuffer sb1 = new StringBuffer("qwertyuiop");

       StringBuffer sb2 = sb1.append("asdfg");
       System.out.println(sb1);
       System.out.println(sb2);

       StringBuffer sb3 = sb1.delete(2, 5);
       System.out.println(sb1);       //qwyuiopasdfg
       System.out.println(sb3);

       sb1.insert(3, "opq");
       System.out.println(sb1);//qwyopquiopasdfg

       sb1.reverse();
       System.out.println(sb1);

       /*
       * 一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，
       * 但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。
       * 如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。
       * 在 StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。
       * 每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串生成器中。
       * append 方法始终将这些字符添加到生成器的末端；而 insert 方法则在指定的点添加字符
       */