java----基本数据类型和String类(7.6)

第一节   基本数据类型和String类

纲要：1.八种基本数据类型

      2.数据类型之间的转换

      3.String类

 

一．八种基本数据类型

整数类型：十进制存储格式

     byte    字节型    8bits     表示范围：-128~127

     short   短整型    16bits    表示范围：-2^15~2^15-1

     int      整型     32bits    表示范围：-2^31~2^31-1

     long    长整型    64bits    表示范围：-2^63~2^63-1

浮点型：十六进制存储格式，默认格式为double

     float    浮点型    32bits   

     double   双精度浮点型    64bits

布尔型：

     boolean   布尔型    true/false

字符型：

      char     字符型    16bits 

 

（数据值域说明：

     1.一个bit是计算机可以存储的最小数据单位。即1位，不是0就是1。

     2.1K=1024bit ， 1M=1024K ， 1G=1024M   ）

 

/**
 * 测试基本数据类型的取值范围
 * @author zhouxiaoxiao
 *
 */
public class range {

	/**
	 * 程序主函数入口
	 */
	public static void main(String[] args) {
      
		//byte 类型可取的最小值:-2^7
		System.out.println("byte 类型可取的最小值: "+Byte.MIN_VALUE);
		//byte 类型可取的最大值:2^7-1
		System.out.println("byte 类型可取的最大值: "+Byte.MAX_VALUE);
		
		//short 类型可取的最小值:-2^15
		System.out.println("short 类型可取的最小值: "+Short.MIN_VALUE);
		//short 类型可取的最大值:2^15-1
		System.out.println("short 类型可取的最大值: "+Short.MAX_VALUE);
		
		//int 类型可取的最小值:-2^31
		System.out.println("int 类型可取的最小值: "+Integer.MIN_VALUE);
		//int 类型可取的最大值:2^31-1
		System.out.println("int 类型可取的最大值: "+Integer.MAX_VALUE);
		
		//long 类型可取的最小值:-2^63
		System.out.println("long 类型可取的最小值: "+Long.MIN_VALUE);
		//long 类型可取的最大值:2^63-1
		System.out.println("long 类型可取的最大值: "+Long.MAX_VALUE);	
		
		//float 类型可取的最小正值:2^(-149)=1.4E-45
		System.out.println("float 类型可取的最小正非零值的常量: "+Float.MIN_VALUE);
		//float 类型可取的最大正值:(2-2^(-23))2^127=3.4028235E38
		System.out.println("float 类型可取的最大正有限值的常量: "+Float.MAX_VALUE);
		
		//double 类型可取的最小正非零值:2^(-1074)=4.9E-324
		System.out.println("double 类型可取的最小正非零值: "+Double.MIN_VALUE);
		//double 类型可取的最大正有限值: (2-2^(-52))*2^1023=1.7976931348623157E308
		System.out.println("double 类型可取的最大正有限值: "+Double.MAX_VALUE);
		
		//boolean 类型只可取两个值：true 或 false
		System.out.println("boolean 的true值: "+Boolean.TRUE);
		System.out.println("boolean 的false值: "+Boolean.FALSE);		
		
		//char 类型可取的最小值： '\u0000'即Unicode值为0000的字符‘ ’。
		System.out.println("char 类型可取的最小值: "+Character.MIN_VALUE);
		System.out.println("char 类型可取的最小值的Unicode值为: "+(int)Character.MIN_VALUE);
		//char 类型可取的最大值: '\uFFFF'即Unicode值为FFFF的字符‘?’。
		System.out.println("char 类型可取的最大值: "+Character.MAX_VALUE);	
		System.out.println("char 类型可取的最大值的Unicode值为: "+(int)Character.MAX_VALUE);
	}

}

 结果如下：

 

二．数据类型之间的转换

数据范围大小：byte<short<char<int<long<float<double

 1.boolean类型不能和其他任何类型进行相互转换。

2.小范围的类型转换成大范围的类型时，只有在整型转成char型时才需要强制转换，

  其他情况下都可以通过赋值的方式直接转型。

代码如下：

/**
 * 数据类型之间的转换，小范围转大范围
 * byte<short<char<int<long<float<double
 * @author zhouxiaoxiao
 * 
 */
public class minTRANSmax {

	/**
	 * 程序主函数入口
	 */
	public static void main(String[] args) {

		/**********boolean类型与其他类型之间的转换***********/
		//boolean类型既不能通过直接复制转为其他类型，也不能通过强制转化转为其他类型
		//boolean bool=true;
		//byte b0=bool; ×
        //byte b0=(byte)bool; ×
		
		/**********byte型转其他大范围的***********/
		byte b1=123;
		
		//byte型可直接通过赋值转short型,int型,long型,float型,double型
		//byte型转short型如下：
		short s1=b1;
		System.out.println("byte型值为：123，转换为short型后为："+s1);
		
		//byte不能通过赋值直接转为char型
		//char c1=b1; ×
		//byte型经过强制转换转为char型
		char c1=(char)b1;
		System.out.println("byte型值为：123，强制转换为char型后为："+c1);

		/********short型转其他大范围的*******/
		short s2=1234;
		
		//short不能通过赋值直接转为char型
		//char c1=b1; ×
		//short型经过强制转换转为char型
		char c2=(char)s2;
		System.out.println("short型值为：123，强制转换转为char型后的值为："+c2);
		
		//short型可直接通过赋值转为int型,long型,float型,double型
		//short型转int型如下：
		int t2=s2;
		System.out.println("short型值为：123，转换为int型后的值为："+t2);

		/**********char型转为其他大范围的*********/
		char c3='3';  //字符3的ASCII值为51
		
		//char型可直接通过赋值转为int型,long型,float型,double型
		//char型转int型如下：
		int t3=c3;
		System.out.println("char型字符为：3，转换为int型后的值为："+t3);

		/********int型转其他大范围的*******/
		int t4=12345;
		
		//int型可直接通过赋值转为long型,float型,double型
		//int型转为long型如下：
		long lg4=t4;
		System.out.println("int型值为：12345，转换为long型后的值为："+lg4);

		/********long型转其他大范围的*******/
		long lg5=123456;
		
		//long型可直接通过赋值转为float型,double型
		//long型转为float型如下：
		float f5=lg5;
		System.out.println("long型值为：123456，转换为float型后的值为："+f5);

		/********float型转其他大范围的*******/
		 //浮点类型默认的格式为double型,因此不可以将12345.6直接赋值给float型
		//float f6=12345.6; ×
		float f6=(float)12345.6;  
		
		//float型可直接通过赋值转为double型
		double d6=f6;
		System.out.println("float型值为：12345.6，转换为double型后的值为："+d6);			
	}

}

 结果如下：

 

3.大范围数据类型转换为小范围数据类型时

 （1）都需要用强制转换，强制转换的格式如下：

         数据类型 类型名=（数据类型）数据;

 （2）大范围的数据类型转换为char型时若值未超过char型的最大范围，则会输出相应的字符，

 若已经超出了char的最大范围，则不输出任何结果。

 （3）浮点型转整数类型时，若没有超出整型的数据范围，则只会丢失小数点部分的数据。

 若超出了整数类型的数据范围，则从“头”开始到对应位置即可，但数据已经不正确了。

 例：对byte型，数据范围为-128~127,

        -129已经超出了范围，它在byte中对应的数为127,-130则对应值126......以此类推

          128也超出了数据范围，它在byte中对应的数据为-128，129则对应值-127......以此类推。

 （4）整数数据类型之间的转换，若没有超出数据范围，则数据不产生影响。

   若超出了整数类型的数据范围，也会从“头”开始到对应位置即可，但数据也会不正确。

代码测试如下：

 

/**
 * 数据类型之间的装换，大范围转小范围
 * byte<short<char<int<long<float<double
 * @author zhouxiaoxiao
 * 
 */
public class maxTRANSmin {

	/**
	 * 程序主函数入口
	 */
	public static void main(String[] args) {

		/*******double型转成范围比它小的类型*********/
		double d1=123456.3456;

		//double型不能直接转为float型，必须通过强制转型
		//float f1=d1;   X
		float f1=(float)d1;   //float精度比double低，会有一些小数点丢失
		System.out.println("double型的数据值为：123456.3456，强制转为float型后的值："+f1);
		
		//double转为整型时也必须用强制转型，若值未超过整型的最大范围，则只会丢失小数部分的值
		//long lg1=d1;  X
		long lg1=(long)d1;
		System.out.println("double型的数据值为：123456.3456，强制转为long型后的值："+lg1);
		
		//double转为整型时，若超过了整数的最大范围，则从头开始数，输出对应的值
		//short s1=d1; X
		short s1=(short)d1;
		System.out.println("double型的数据值为：123456.3456，强制转为short型后的值："+s1);
		
		//double转为char型时也必须用强制转型，若值未超过char型的最大范围，则会输出相应的字符
		//若已经超出了char的最大范围，则不输出任何结果
		//char c1=d1;  X
		char c1=(char)d1;    //d1已经超出了最大范围
		System.out.println("double型的数据值为：123456.3456，强制转为char型后的值："+c1);
		
		//double型不能转为boolean型
		//boolean bool=d1;  X
                //boolean bool=(boolean)d1;  X
		
		/*******float转为范围比它小的类型*********/
		float f2=(float)1234.5;
		
		//float转为整型时也必须用强制转型，若值未超过整型的最大范围，则只会丢失小数部分的值
		//long lg2=f2;  X
		long lg2=(long)f2;
		System.out.println("float型的数据值为：1234.5，强制转为long型后的值："+lg2);
		
		//float转为整型时，若超过了整数的最大范围，则从头开始数，输出对应的值
		//byte b2=f2;  X
		byte b2=(byte)f2;   
		System.out.println("float型的数据值为：1234.5，强制转为byte型后的值："+b2);
		
		//double转为char型时也必须用强制转型，若值未超过char型的最大范围，则会输出相应的字符
		//若已经超出了char的最大范围，则不输出任何结果
		//char c2=f2;  X
		char c2=(char)f2;   //f2没有超出最大范围
		System.out.println("float型的数据值为：1234.5，强制转为char型后的值："+c2);
		
		//double型不能转为boolean型
		//boolean bool=f2;  X
                //boolean bool=(boolean)f2; X
		
		/*******long转为范围比它小的类型********/
		long lg3=1234;
		
		//long型转成范围比它小的整型时必须用强制转换，若没有超过最大值，则数据不影响
		//int t3=lg3;  X
		int t3=(int)lg3;
		System.out.println("long型的数据值为：1234，强制转为int型后的值："+t3);
		
		//long型转为范围比它小的整型时，若超过了整数的最大范围，则从头开始数，输出对应的值
		//byte b3=lg3;  X
		byte b3=(byte)lg3;
		System.out.println("long型的数据值为：1234，强制转为byte型后的值："+b3);
		
		//long转为char型时也必须用强制转型，若值未超过char型的最大范围，则会输出相应的字符
		//若已经超出了char的最大范围，则不输出任何结果
		//char c3=lg3;  X
		char c3=(char)lg3;
		System.out.println("long型的数据值为：1234，强制转为char型后的值："+c3);
		
		//long型不能转为boolean型
		//boolean bool=lg3;  X
                //boolean bool=(boolean)lg3; X
		
		/*******int转为范围比它小的类型********/
		int t4=123;
		
		//int型转成范围比它小的整型时必须用强制转换，若没有超过最大值，则数据不影响
		//若超过了整数的最大范围，则从头开始数，输出对应的值
		//byte b4=t4;  X
		byte b4=(byte)t4;   //123没有超出byte型的最大范围
		System.out.println("int型的数据值为：123，强制转为byte型后的值："+b4);
		
		//int转为char型时也必须用强制转型，若值未超过char型的最大范围，则会输出相应的字符
		//若已经超出了char的最大范围，则不输出任何结果
		//char c4=lg3; X
		char c4=(char)t4;
		System.out.println("int型的数据值为：123，强制转为char型后的值："+c4);
		
		//int型不能转为boolean型
		//boolean bool=t4; X
               //boolean bool=(boolean)t4;  X
		
		/*******char转为范围比它小的类型********/
                char c5='A';
                System.out.println(c5);
        
              //char型转整型时，若ASCII的值未超过整型的最大范围，则整型值直接为字符的ASCII值
                //若超过了，则从头开始数，输出对应的值
                //short s5=c5;   X
               short s5=(short)c5;
              System.out.println("char型的字符为：A，强制转为short型后的值："+s5);
        
		//byte b5=c5;  X
		byte b5=(byte)c5;
		System.out.println("char型的字符为：A，强制转为byte型后的值："+b5);
		
		//char型不能转为boolean型
		//boolean bool=c5;  X
               //boolean bool=(boolean)c5;   X
		
		/************short型转byte型*************/
		short s6=123;
		
		//byte b5=s6;  X
		byte b6=(byte)s6;
		System.out.println("short型的数据值为：123，强制转为byte型后的值："+b6);
		
		//short型不能转为boolean型
		//boolean bool=s6;   X
               //boolean bool=(boolean)s6;   X
	}
}
 

 结果如下：

 

三．String类：String在java中是类，String类表示的是字符串。

       String 类提供处理 Unicode 代码点（即字符）和 Unicode 代码单元（即 char 值）的方法。

1.创建并出示化字符串的方法：

     （1）使用字符串常量直接初始化

     （2）使用构造方法创建并初始化

/**
 * 创建并初始化string对象
 * @author zhouxiaoxiao
 *
 */
public class st {

	/**
	 * 程序主函数入口
	 */
	public static void main(String[] args) {

		//方法一：使用字符串常量直接初始化
		String s1="dcddjcidjm";
		System.out.println("字符串常量直接初始化s1 :"+s1);
		//输出结果：字符串常量直接初始化s1 :dcddjcidjm
		
		//方法二：使用构造方法创建,然后再赋值
		String s2=new String();
		s2="jkdnvk";
		System.out.println("构造方法创建,然后再赋值s2 :"+s2);
		//输出结果：构造方法创建,然后再赋值s2 :jkdnvk
		
		//方法三：使用构造方法创建的同时初始化
		char [] ch={'a','p','p','l','e'};
		String s3=new String(ch);
		System.out.println("构造方法创建同时初始化s3 :"+s3);
		//输出结果：构造方法创建同时初始化s3 :apple
	}

}

 

2.String类中常用的方法：

  2.1获取指定索引处字符，Unicode 代码点（Unicode值）及Unicode 代码点数的方法

        public char charAt(int index);

        public int codePointAt(int index);

        public int codePointBefore(int index);

        public int codePointCount(int beginIndex,int endIndex);

  方法实现的代码及说明如下：

/**
 * 指定索引处字符的方法
 * @author zhouxiaoxiao
 *
 */
public class st {

	/**
	 * 程序主函数入口
	 */
	public static void main(String[] args) {

		//初始化字符串
		String s1="djdvdejkrkrhttmdd";

		/***String类中的有关指定索引处字符的有关方法*****/
		//返回指定索引处的char值
		char c1=s1.charAt(3);    //3表示索引值，索引值范围为：0~length-1
		System.out.println("字符串  "+s1+"在索引值为3位置的字符为："+c1); 
		
		// 返回指定索引处的字符（Unicode 代码点）。
		int t1=s1.codePointAt(3);   //在索引值为3的字符为v，它对应的Unicode值为118
		System.out.println("t1="+t1); //输出结果为：t1=118
		
		//返回指定索引之前的字符（Unicode 代码点）。
		int t2=s1.codePointBefore(3);  //在索引值为3之前的字符为d，它对应的Unicode值为100
		System.out.println("t2:"+t2);   //输出结果为：t2=118
		
		//返回此 String 的指定文本范围中的 Unicode 代码点数。
		//文本范围为：beginIndex~endIndex-1
		int t3=s1.codePointCount(3, 5);  //3是开始的索引值，5是结束的索引值，则取定的范围只包含了3，4
		System.out.println("t3:"+t3);	//输出的结果为：t3=2
	}

}

 

   2.2比较两个字符串的方法：

        public int compareTo(String anotherString);

        public int compareToIgnoreCase(String str);

        public boolean equals(Object anObject);

        public boolean equalsIgnoreCase(String anotherString);

      方法的实现及说明如下代码：

/**
 * 比较两个字符串的方法
 * @author zhouxiaoxiao
 *
 */
public class st {

	/**
	 * 程序主函数入口
	 */
	public static void main(String[] args) {

		//初始化字符串
		String s1="dejkriivjri";
		String s2=new String("Dabcdjdhjhvd  ");
		String s3=new String("dejkr");
		String s4="DEJKRIIVJRI";

		//按字典顺序比较两个字符串
		int t4=s1.compareTo(s2);    //字符串之间不存在包含关系时，判断第一个不同的字符之间Unicode差值
		System.out.println("t4:"+t4);   //d的Unicode值为：100，D的为：68.  100-68=32, t4=32
		t4=s1.compareTo(s3);    //一个字符串是另一个字符串的前部分或整个部分时，为两个字符串的长度之差
		System.out.println("t4:"+t4);   //s3是s1的前面部分，两者长度相差6，所以t4=6
		 
		//按字典顺序比较两个字符串，不考虑大小写。
		int t5=s1.compareToIgnoreCase(s4);
		System.out.println("t5:"+t5);  //不考虑大小写，s1和s4相同,长度相差0,所以t5=0
		
		//将此字符串与指定的对象比较，考虑大小写。
		boolean bool5=s1.equals(s2);   //字符串相同则返回true不同则返回false
		System.out.println("bool5:"+bool5);  //结果为：true
		
		//将此 String 与另一个 String 比较，不考虑大小写。
		boolean bool6=s1.equalsIgnoreCase(s4);  //字符串相同(不区分大小写)则返回true不同则返回false
		System.out.println("bool6:"+bool6);   //结果为：false
	}
}