class="p0" style="margin-top: 0pt; margin-bottom: 0pt;">第一节???基本数据类型和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
}
}
?
相关文章
